schemos 0.0.1 → 0.1.1

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

@@ -0,0 +1,905 @@
+import { cw20ExecuteSchema } from './execute.js';
+import { cw20QuerySchema } from './query.js';
+import { cw20ResponseSchemas } from './responses.js';
+export declare const cw20: {
+    readonly execute: {
+        readonly oneOf: readonly [{
+            readonly description: "Transfer is a base message to move tokens to another account without triggering actions";
+            readonly type: "object";
+            readonly required: readonly ["transfer"];
+            readonly properties: {
+                readonly transfer: {
+                    readonly type: "object";
+                    readonly required: readonly ["amount", "recipient"];
+                    readonly properties: {
+                        readonly amount: {
+                            readonly $ref: "#/definitions/Uint128";
+                        };
+                        readonly recipient: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Burn is a base message to destroy tokens forever";
+            readonly type: "object";
+            readonly required: readonly ["burn"];
+            readonly properties: {
+                readonly burn: {
+                    readonly type: "object";
+                    readonly required: readonly ["amount"];
+                    readonly properties: {
+                        readonly amount: {
+                            readonly $ref: "#/definitions/Uint128";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Send is a base message to transfer tokens to a contract and trigger an action on the receiving contract.";
+            readonly type: "object";
+            readonly required: readonly ["send"];
+            readonly properties: {
+                readonly send: {
+                    readonly type: "object";
+                    readonly required: readonly ["amount", "contract", "msg"];
+                    readonly properties: {
+                        readonly amount: {
+                            readonly $ref: "#/definitions/Uint128";
+                        };
+                        readonly contract: {
+                            readonly type: "string";
+                        };
+                        readonly msg: {
+                            readonly $ref: "#/definitions/Binary";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with \"approval\" extension. Allows spender to access an additional amount tokens from the owner's (env.sender) account. If expires is Some(), overwrites current allowance expiration with this one.";
+            readonly type: "object";
+            readonly required: readonly ["increase_allowance"];
+            readonly properties: {
+                readonly increase_allowance: {
+                    readonly type: "object";
+                    readonly required: readonly ["amount", "spender"];
+                    readonly properties: {
+                        readonly amount: {
+                            readonly $ref: "#/definitions/Uint128";
+                        };
+                        readonly expires: {
+                            readonly anyOf: readonly [{
+                                readonly $ref: "#/definitions/Expiration";
+                            }, {
+                                readonly type: "null";
+                            }];
+                        };
+                        readonly spender: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with \"approval\" extension. Lowers the spender's access of tokens from the owner's (env.sender) account by amount. If expires is Some(), overwrites current allowance expiration with this one.";
+            readonly type: "object";
+            readonly required: readonly ["decrease_allowance"];
+            readonly properties: {
+                readonly decrease_allowance: {
+                    readonly type: "object";
+                    readonly required: readonly ["amount", "spender"];
+                    readonly properties: {
+                        readonly amount: {
+                            readonly $ref: "#/definitions/Uint128";
+                        };
+                        readonly expires: {
+                            readonly anyOf: readonly [{
+                                readonly $ref: "#/definitions/Expiration";
+                            }, {
+                                readonly type: "null";
+                            }];
+                        };
+                        readonly spender: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with \"approval\" extension. Transfers amount tokens from owner -> recipient if `env.sender` has sufficient pre-approval.";
+            readonly type: "object";
+            readonly required: readonly ["transfer_from"];
+            readonly properties: {
+                readonly transfer_from: {
+                    readonly type: "object";
+                    readonly required: readonly ["amount", "owner", "recipient"];
+                    readonly properties: {
+                        readonly amount: {
+                            readonly $ref: "#/definitions/Uint128";
+                        };
+                        readonly owner: {
+                            readonly type: "string";
+                        };
+                        readonly recipient: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with \"approval\" extension. Sends amount tokens from owner -> contract if `env.sender` has sufficient pre-approval.";
+            readonly type: "object";
+            readonly required: readonly ["send_from"];
+            readonly properties: {
+                readonly send_from: {
+                    readonly type: "object";
+                    readonly required: readonly ["amount", "contract", "msg", "owner"];
+                    readonly properties: {
+                        readonly amount: {
+                            readonly $ref: "#/definitions/Uint128";
+                        };
+                        readonly contract: {
+                            readonly type: "string";
+                        };
+                        readonly msg: {
+                            readonly $ref: "#/definitions/Binary";
+                        };
+                        readonly owner: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with \"approval\" extension. Destroys tokens forever";
+            readonly type: "object";
+            readonly required: readonly ["burn_from"];
+            readonly properties: {
+                readonly burn_from: {
+                    readonly type: "object";
+                    readonly required: readonly ["amount", "owner"];
+                    readonly properties: {
+                        readonly amount: {
+                            readonly $ref: "#/definitions/Uint128";
+                        };
+                        readonly owner: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with the \"mintable\" extension. If authorized, creates amount new tokens and adds to the recipient balance.";
+            readonly type: "object";
+            readonly required: readonly ["mint"];
+            readonly properties: {
+                readonly mint: {
+                    readonly type: "object";
+                    readonly required: readonly ["amount", "recipient"];
+                    readonly properties: {
+                        readonly amount: {
+                            readonly $ref: "#/definitions/Uint128";
+                        };
+                        readonly recipient: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with the \"mintable\" extension. The current minter may set a new minter. Setting the minter to None will remove the token's minter forever.";
+            readonly type: "object";
+            readonly required: readonly ["update_minter"];
+            readonly properties: {
+                readonly update_minter: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly new_minter: {
+                            readonly type: readonly ["string", "null"];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with the \"marketing\" extension. If authorized, updates marketing metadata. Setting None/null for any of these will leave it unchanged. Setting Some(\"\") will clear this field on the contract storage";
+            readonly type: "object";
+            readonly required: readonly ["update_marketing"];
+            readonly properties: {
+                readonly update_marketing: {
+                    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 marketing: {
+                            readonly description: "The address (if any) who can update this data structure";
+                            readonly type: readonly ["string", "null"];
+                        };
+                        readonly project: {
+                            readonly description: "A URL pointing to the project behind this token.";
+                            readonly type: readonly ["string", "null"];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "If set as the \"marketing\" role on the contract, upload a new URL, SVG, or PNG for the token";
+            readonly type: "object";
+            readonly required: readonly ["upload_logo"];
+            readonly properties: {
+                readonly upload_logo: {
+                    readonly $ref: "#/definitions/Logo";
+                };
+            };
+            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 EmbeddedLogo: {
+                readonly description: "This is used to store the logo on the blockchain in an accepted format. Enforce maximum size of 5KB on all variants.";
+                readonly oneOf: readonly [{
+                    readonly description: "Store the Logo as an SVG file. The content must conform to the spec at https://en.wikipedia.org/wiki/Scalable_Vector_Graphics (The contract should do some light-weight sanity-check validation)";
+                    readonly type: "object";
+                    readonly required: readonly ["svg"];
+                    readonly properties: {
+                        readonly svg: {
+                            readonly $ref: "#/definitions/Binary";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }, {
+                    readonly description: "Store the Logo as a PNG file. This will likely only support up to 64x64 or so within the 5KB limit.";
+                    readonly type: "object";
+                    readonly required: readonly ["png"];
+                    readonly properties: {
+                        readonly png: {
+                            readonly $ref: "#/definitions/Binary";
+                        };
+                    };
+                    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 Logo: {
+                readonly description: "This is used for uploading logo data, or setting it in InstantiateData";
+                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: "Logo content stored on the blockchain. Enforce maximum size of 5KB on all variants";
+                    readonly type: "object";
+                    readonly required: readonly ["embedded"];
+                    readonly properties: {
+                        readonly embedded: {
+                            readonly $ref: "#/definitions/EmbeddedLogo";
+                        };
+                    };
+                    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 query: {
+        readonly oneOf: readonly [{
+            readonly description: "Returns the current balance of the given address, 0 if unset.";
+            readonly type: "object";
+            readonly required: readonly ["balance"];
+            readonly properties: {
+                readonly balance: {
+                    readonly type: "object";
+                    readonly required: readonly ["address"];
+                    readonly properties: {
+                        readonly address: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Returns metadata on the contract - name, decimals, supply, etc.";
+            readonly type: "object";
+            readonly required: readonly ["token_info"];
+            readonly properties: {
+                readonly token_info: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with \"mintable\" extension. Returns who can mint and the hard cap on maximum tokens after minting.";
+            readonly type: "object";
+            readonly required: readonly ["minter"];
+            readonly properties: {
+                readonly minter: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with \"allowance\" extension. Returns how much spender can use from owner account, 0 if unset.";
+            readonly type: "object";
+            readonly required: readonly ["allowance"];
+            readonly properties: {
+                readonly allowance: {
+                    readonly type: "object";
+                    readonly required: readonly ["owner", "spender"];
+                    readonly properties: {
+                        readonly owner: {
+                            readonly type: "string";
+                        };
+                        readonly spender: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with \"enumerable\" extension (and \"allowances\") Returns all allowances this owner has approved. Supports pagination.";
+            readonly type: "object";
+            readonly required: readonly ["all_allowances"];
+            readonly properties: {
+                readonly all_allowances: {
+                    readonly type: "object";
+                    readonly required: readonly ["owner"];
+                    readonly properties: {
+                        readonly limit: {
+                            readonly type: readonly ["integer", "null"];
+                            readonly format: "uint32";
+                            readonly minimum: 0;
+                        };
+                        readonly owner: {
+                            readonly type: "string";
+                        };
+                        readonly start_after: {
+                            readonly type: readonly ["string", "null"];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with \"enumerable\" extension (and \"allowances\") Returns all allowances this spender has been granted. Supports pagination.";
+            readonly type: "object";
+            readonly required: readonly ["all_spender_allowances"];
+            readonly properties: {
+                readonly all_spender_allowances: {
+                    readonly type: "object";
+                    readonly required: readonly ["spender"];
+                    readonly properties: {
+                        readonly limit: {
+                            readonly type: readonly ["integer", "null"];
+                            readonly format: "uint32";
+                            readonly minimum: 0;
+                        };
+                        readonly spender: {
+                            readonly type: "string";
+                        };
+                        readonly start_after: {
+                            readonly type: readonly ["string", "null"];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with \"enumerable\" extension Returns all accounts that have balances. Supports pagination.";
+            readonly type: "object";
+            readonly required: readonly ["all_accounts"];
+            readonly properties: {
+                readonly all_accounts: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly limit: {
+                            readonly type: readonly ["integer", "null"];
+                            readonly format: "uint32";
+                            readonly minimum: 0;
+                        };
+                        readonly start_after: {
+                            readonly type: readonly ["string", "null"];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with \"marketing\" extension Returns more metadata on the contract to display in the client: - description, logo, project url, etc.";
+            readonly type: "object";
+            readonly required: readonly ["marketing_info"];
+            readonly properties: {
+                readonly marketing_info: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Only with \"marketing\" extension Downloads the embedded logo data (if stored on chain). Errors if no logo data is stored for this contract.";
+            readonly type: "object";
+            readonly required: readonly ["download_logo"];
+            readonly properties: {
+                readonly download_logo: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }];
+    };
+    readonly responses: {
+        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";
+                };
+            };
+        };
+    };
+};
+export { cw20ExecuteSchema, cw20QuerySchema, cw20ResponseSchemas };
+//# sourceMappingURL=index.d.ts.map