schemos 0.0.1 → 0.1.1

package/dist/schemas/cw20/responses.d.ts

@@ -0,0 +1,386 @@
+/**
+ * CW20 query response schemas.
+ * Generated from cw-plus v2.0.0 cw20-base cargo schema output.
+ */
+export declare const cw20ResponseSchemas: {
+    readonly all_accounts: {
+        readonly type: "object";
+        readonly required: readonly ["accounts"];
+        readonly properties: {
+            readonly accounts: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+    readonly all_allowances: {
+        readonly type: "object";
+        readonly required: readonly ["allowances"];
+        readonly properties: {
+            readonly allowances: {
+                readonly type: "array";
+                readonly items: {
+                    readonly $ref: "#/definitions/AllowanceInfo";
+                };
+            };
+        };
+        readonly definitions: {
+            readonly AllowanceInfo: {
+                readonly type: "object";
+                readonly required: readonly ["allowance", "expires", "spender"];
+                readonly properties: {
+                    readonly allowance: {
+                        readonly $ref: "#/definitions/Uint128";
+                    };
+                    readonly expires: {
+                        readonly $ref: "#/definitions/Expiration";
+                    };
+                    readonly spender: {
+                        readonly type: "string";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly Expiration: {
+                readonly description: "Expiration represents a point in time when some event happens. It can compare with a BlockInfo and will return is_expired() == true once the condition is hit (and for every block in the future)";
+                readonly oneOf: readonly [{
+                    readonly description: "AtHeight will expire when `env.block.height` >= height";
+                    readonly type: "object";
+                    readonly required: readonly ["at_height"];
+                    readonly properties: {
+                        readonly at_height: {
+                            readonly type: "integer";
+                            readonly format: "uint64";
+                            readonly minimum: 0;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }, {
+                    readonly description: "AtTime will expire when `env.block.time` >= time";
+                    readonly type: "object";
+                    readonly required: readonly ["at_time"];
+                    readonly properties: {
+                        readonly at_time: {
+                            readonly $ref: "#/definitions/Timestamp";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }, {
+                    readonly description: "Never will never expire. Used to express the empty variant";
+                    readonly type: "object";
+                    readonly required: readonly ["never"];
+                    readonly properties: {
+                        readonly never: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+            };
+            readonly Timestamp: {
+                readonly description: "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```";
+                readonly allOf: readonly [{
+                    readonly $ref: "#/definitions/Uint64";
+                }];
+            };
+            readonly Uint128: {
+                readonly description: "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```";
+                readonly type: "string";
+            };
+            readonly Uint64: {
+                readonly description: "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```";
+                readonly type: "string";
+            };
+        };
+    };
+    readonly all_spender_allowances: {
+        readonly type: "object";
+        readonly required: readonly ["allowances"];
+        readonly properties: {
+            readonly allowances: {
+                readonly type: "array";
+                readonly items: {
+                    readonly $ref: "#/definitions/SpenderAllowanceInfo";
+                };
+            };
+        };
+        readonly definitions: {
+            readonly Expiration: {
+                readonly description: "Expiration represents a point in time when some event happens. It can compare with a BlockInfo and will return is_expired() == true once the condition is hit (and for every block in the future)";
+                readonly oneOf: readonly [{
+                    readonly description: "AtHeight will expire when `env.block.height` >= height";
+                    readonly type: "object";
+                    readonly required: readonly ["at_height"];
+                    readonly properties: {
+                        readonly at_height: {
+                            readonly type: "integer";
+                            readonly format: "uint64";
+                            readonly minimum: 0;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }, {
+                    readonly description: "AtTime will expire when `env.block.time` >= time";
+                    readonly type: "object";
+                    readonly required: readonly ["at_time"];
+                    readonly properties: {
+                        readonly at_time: {
+                            readonly $ref: "#/definitions/Timestamp";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }, {
+                    readonly description: "Never will never expire. Used to express the empty variant";
+                    readonly type: "object";
+                    readonly required: readonly ["never"];
+                    readonly properties: {
+                        readonly never: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+            };
+            readonly SpenderAllowanceInfo: {
+                readonly type: "object";
+                readonly required: readonly ["allowance", "expires", "owner"];
+                readonly properties: {
+                    readonly allowance: {
+                        readonly $ref: "#/definitions/Uint128";
+                    };
+                    readonly expires: {
+                        readonly $ref: "#/definitions/Expiration";
+                    };
+                    readonly owner: {
+                        readonly type: "string";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly Timestamp: {
+                readonly description: "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```";
+                readonly allOf: readonly [{
+                    readonly $ref: "#/definitions/Uint64";
+                }];
+            };
+            readonly Uint128: {
+                readonly description: "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```";
+                readonly type: "string";
+            };
+            readonly Uint64: {
+                readonly description: "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```";
+                readonly type: "string";
+            };
+        };
+    };
+    readonly allowance: {
+        readonly type: "object";
+        readonly required: readonly ["allowance", "expires"];
+        readonly properties: {
+            readonly allowance: {
+                readonly $ref: "#/definitions/Uint128";
+            };
+            readonly expires: {
+                readonly $ref: "#/definitions/Expiration";
+            };
+        };
+        readonly definitions: {
+            readonly Expiration: {
+                readonly description: "Expiration represents a point in time when some event happens. It can compare with a BlockInfo and will return is_expired() == true once the condition is hit (and for every block in the future)";
+                readonly oneOf: readonly [{
+                    readonly description: "AtHeight will expire when `env.block.height` >= height";
+                    readonly type: "object";
+                    readonly required: readonly ["at_height"];
+                    readonly properties: {
+                        readonly at_height: {
+                            readonly type: "integer";
+                            readonly format: "uint64";
+                            readonly minimum: 0;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }, {
+                    readonly description: "AtTime will expire when `env.block.time` >= time";
+                    readonly type: "object";
+                    readonly required: readonly ["at_time"];
+                    readonly properties: {
+                        readonly at_time: {
+                            readonly $ref: "#/definitions/Timestamp";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }, {
+                    readonly description: "Never will never expire. Used to express the empty variant";
+                    readonly type: "object";
+                    readonly required: readonly ["never"];
+                    readonly properties: {
+                        readonly never: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+            };
+            readonly Timestamp: {
+                readonly description: "A point in time in nanosecond precision.\n\nThis type can represent times from 1970-01-01T00:00:00Z to 2554-07-21T23:34:33Z.\n\n## Examples\n\n``` # use cosmwasm_std::Timestamp; let ts = Timestamp::from_nanos(1_000_000_202); assert_eq!(ts.nanos(), 1_000_000_202); assert_eq!(ts.seconds(), 1); assert_eq!(ts.subsec_nanos(), 202);\n\nlet ts = ts.plus_seconds(2); assert_eq!(ts.nanos(), 3_000_000_202); assert_eq!(ts.seconds(), 3); assert_eq!(ts.subsec_nanos(), 202); ```";
+                readonly allOf: readonly [{
+                    readonly $ref: "#/definitions/Uint64";
+                }];
+            };
+            readonly Uint128: {
+                readonly description: "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```";
+                readonly type: "string";
+            };
+            readonly Uint64: {
+                readonly description: "A thin wrapper around u64 that is using strings for JSON encoding/decoding, such that the full u64 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u64` to get the value out:\n\n``` # use cosmwasm_std::Uint64; let a = Uint64::from(42u64); assert_eq!(a.u64(), 42);\n\nlet b = Uint64::from(70u32); assert_eq!(b.u64(), 70); ```";
+                readonly type: "string";
+            };
+        };
+    };
+    readonly balance: {
+        readonly type: "object";
+        readonly required: readonly ["balance"];
+        readonly properties: {
+            readonly balance: {
+                readonly $ref: "#/definitions/Uint128";
+            };
+        };
+        readonly additionalProperties: false;
+        readonly definitions: {
+            readonly Uint128: {
+                readonly description: "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```";
+                readonly type: "string";
+            };
+        };
+    };
+    readonly download_logo: {
+        readonly description: "When we download an embedded logo, we get this response type. We expect a SPA to be able to accept this info and display it.";
+        readonly type: "object";
+        readonly required: readonly ["data", "mime_type"];
+        readonly properties: {
+            readonly data: {
+                readonly $ref: "#/definitions/Binary";
+            };
+            readonly mime_type: {
+                readonly type: "string";
+            };
+        };
+        readonly additionalProperties: false;
+        readonly definitions: {
+            readonly Binary: {
+                readonly description: "Binary is a wrapper around Vec<u8> to add base64 de/serialization with serde. It also adds some helper methods to help encode inline.\n\nThis is only needed as serde-json-{core,wasm} has a horrible encoding for Vec<u8>. See also <https://github.com/CosmWasm/cosmwasm/blob/main/docs/MESSAGE_TYPES.md>.";
+                readonly type: "string";
+            };
+        };
+    };
+    readonly marketing_info: {
+        readonly type: "object";
+        readonly properties: {
+            readonly description: {
+                readonly description: "A longer description of the token and it's utility. Designed for tooltips or such";
+                readonly type: readonly ["string", "null"];
+            };
+            readonly logo: {
+                readonly description: "A link to the logo, or a comment there is an on-chain logo stored";
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/LogoInfo";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+            readonly marketing: {
+                readonly description: "The address (if any) who can update this data structure";
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/Addr";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+            readonly project: {
+                readonly description: "A URL pointing to the project behind this token.";
+                readonly type: readonly ["string", "null"];
+            };
+        };
+        readonly definitions: {
+            readonly Addr: {
+                readonly description: "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.";
+                readonly type: "string";
+            };
+            readonly LogoInfo: {
+                readonly description: "This is used to display logo info, provide a link or inform there is one that can be downloaded from the blockchain itself";
+                readonly oneOf: readonly [{
+                    readonly description: "A reference to an externally hosted logo. Must be a valid HTTP or HTTPS URL.";
+                    readonly type: "object";
+                    readonly required: readonly ["url"];
+                    readonly properties: {
+                        readonly url: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }, {
+                    readonly description: "There is an embedded logo on the chain, make another call to download it.";
+                    readonly type: "string";
+                    readonly enum: readonly ["embedded"];
+                }];
+            };
+        };
+    };
+    readonly minter: {
+        readonly type: "object";
+        readonly required: readonly ["minter"];
+        readonly properties: {
+            readonly cap: {
+                readonly description: "cap is a hard cap on total supply that can be achieved by minting. Note that this refers to total_supply. If None, there is unlimited cap.";
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/Uint128";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+            readonly minter: {
+                readonly type: "string";
+            };
+        };
+        readonly additionalProperties: false;
+        readonly definitions: {
+            readonly Uint128: {
+                readonly description: "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```";
+                readonly type: "string";
+            };
+        };
+    };
+    readonly token_info: {
+        readonly type: "object";
+        readonly required: readonly ["decimals", "name", "symbol", "total_supply"];
+        readonly properties: {
+            readonly decimals: {
+                readonly type: "integer";
+                readonly format: "uint8";
+                readonly minimum: 0;
+            };
+            readonly name: {
+                readonly type: "string";
+            };
+            readonly symbol: {
+                readonly type: "string";
+            };
+            readonly total_supply: {
+                readonly $ref: "#/definitions/Uint128";
+            };
+        };
+        readonly additionalProperties: false;
+        readonly definitions: {
+            readonly Uint128: {
+                readonly description: "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```";
+                readonly type: "string";
+            };
+        };
+    };
+};
+//# sourceMappingURL=responses.d.ts.map

package/dist/schemas/cw20/responses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.d.ts","sourceRoot":"","sources":["../../../src/schemas/cw20/responses.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwbtB,CAAA"}