schemos 0.0.1 → 0.1.1

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

@@ -0,0 +1,1485 @@
+/**
+ * CW721 query response schemas.
+ * Generated from cw-nfts cw721-base cargo schema output.
+ */
+export declare const cw721ResponseSchemas: {
+    readonly all_nft_info: {
+        readonly type: "object";
+        readonly required: readonly ["access", "info"];
+        readonly properties: {
+            readonly access: {
+                readonly description: "Who can transfer the token";
+                readonly allOf: readonly [{
+                    readonly $ref: "#/definitions/OwnerOfResponse";
+                }];
+            };
+            readonly info: {
+                readonly description: "Data on the token itself,";
+                readonly allOf: readonly [{
+                    readonly $ref: "#/definitions/NftInfoResponse_for_Nullable_Empty";
+                }];
+            };
+        };
+        readonly additionalProperties: false;
+        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 Approval: {
+                readonly type: "object";
+                readonly required: readonly ["expires", "spender"];
+                readonly properties: {
+                    readonly expires: {
+                        readonly description: "When the Approval expires (maybe Expiration::never)";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Expiration";
+                        }];
+                    };
+                    readonly spender: {
+                        readonly description: "Account that can transfer/send the token";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Addr";
+                        }];
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly Empty: {
+                readonly description: "An empty struct that serves as a placeholder in different places, such as contracts that don't set a custom message.\n\nIt is designed to be expressible in correct JSON and JSON Schema but contains no meaningful data. Previously we used enums without cases, but those cannot represented as valid JSON Schema (https://github.com/CosmWasm/cosmwasm/issues/451)";
+                readonly type: "object";
+                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 NftInfoResponse_for_Nullable_Empty: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly extension: {
+                        readonly description: "You can add any custom metadata here when you extend cw721-base";
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/Empty";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                    readonly token_uri: {
+                        readonly description: "Universal resource identifier for this NFT Should point to a JSON file that conforms to the ERC721 Metadata JSON Schema";
+                        readonly type: readonly ["string", "null"];
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly OwnerOfResponse: {
+                readonly type: "object";
+                readonly required: readonly ["approvals", "owner"];
+                readonly properties: {
+                    readonly approvals: {
+                        readonly description: "If set this address is approved to transfer/send the token as well";
+                        readonly type: "array";
+                        readonly items: {
+                            readonly $ref: "#/definitions/Approval";
+                        };
+                    };
+                    readonly owner: {
+                        readonly description: "Owner of the token";
+                        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 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_operators: {
+        readonly type: "object";
+        readonly required: readonly ["operators"];
+        readonly properties: {
+            readonly operators: {
+                readonly type: "array";
+                readonly items: {
+                    readonly $ref: "#/definitions/Approval";
+                };
+            };
+        };
+        readonly additionalProperties: false;
+        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 Approval: {
+                readonly type: "object";
+                readonly required: readonly ["expires", "spender"];
+                readonly properties: {
+                    readonly expires: {
+                        readonly description: "When the Approval expires (maybe Expiration::never)";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Expiration";
+                        }];
+                    };
+                    readonly spender: {
+                        readonly description: "Account that can transfer/send the token";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Addr";
+                        }];
+                    };
+                };
+                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 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_tokens: {
+        readonly type: "object";
+        readonly required: readonly ["tokens"];
+        readonly properties: {
+            readonly tokens: {
+                readonly description: "Contains all token_ids in lexicographical ordering If there are more than `limit`, use `start_after` in future queries to achieve pagination.";
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly additionalProperties: false;
+    };
+    readonly approval: {
+        readonly type: "object";
+        readonly required: readonly ["approval"];
+        readonly properties: {
+            readonly approval: {
+                readonly $ref: "#/definitions/Approval";
+            };
+        };
+        readonly additionalProperties: false;
+        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 Approval: {
+                readonly type: "object";
+                readonly required: readonly ["expires", "spender"];
+                readonly properties: {
+                    readonly expires: {
+                        readonly description: "When the Approval expires (maybe Expiration::never)";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Expiration";
+                        }];
+                    };
+                    readonly spender: {
+                        readonly description: "Account that can transfer/send the token";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Addr";
+                        }];
+                    };
+                };
+                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 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 approvals: {
+        readonly type: "object";
+        readonly required: readonly ["approvals"];
+        readonly properties: {
+            readonly approvals: {
+                readonly type: "array";
+                readonly items: {
+                    readonly $ref: "#/definitions/Approval";
+                };
+            };
+        };
+        readonly additionalProperties: false;
+        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 Approval: {
+                readonly type: "object";
+                readonly required: readonly ["expires", "spender"];
+                readonly properties: {
+                    readonly expires: {
+                        readonly description: "When the Approval expires (maybe Expiration::never)";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Expiration";
+                        }];
+                    };
+                    readonly spender: {
+                        readonly description: "Account that can transfer/send the token";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Addr";
+                        }];
+                    };
+                };
+                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 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 contract_info: {
+        readonly description: "This is a wrapper around CollectionInfo that includes the extension.";
+        readonly type: "object";
+        readonly required: readonly ["name", "symbol", "updated_at"];
+        readonly properties: {
+            readonly extension: {
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/CollectionExtension_for_RoyaltyInfo";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+            readonly name: {
+                readonly type: "string";
+            };
+            readonly symbol: {
+                readonly type: "string";
+            };
+            readonly updated_at: {
+                readonly $ref: "#/definitions/Timestamp";
+            };
+        };
+        readonly additionalProperties: false;
+        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 CollectionExtension_for_RoyaltyInfo: {
+                readonly type: "object";
+                readonly required: readonly ["description", "image"];
+                readonly properties: {
+                    readonly banner_url: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                    readonly explicit_content: {
+                        readonly type: readonly ["boolean", "null"];
+                    };
+                    readonly external_link: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly image: {
+                        readonly type: "string";
+                    };
+                    readonly royalty_info: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/RoyaltyInfo";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                    readonly start_trading_time: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/Timestamp";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly Decimal: {
+                readonly description: "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)";
+                readonly type: "string";
+            };
+            readonly RoyaltyInfo: {
+                readonly type: "object";
+                readonly required: readonly ["payment_address", "share"];
+                readonly properties: {
+                    readonly payment_address: {
+                        readonly $ref: "#/definitions/Addr";
+                    };
+                    readonly share: {
+                        readonly $ref: "#/definitions/Decimal";
+                    };
+                };
+                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 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 extension: {
+        readonly type: "null";
+    };
+    readonly get_additional_minters: {
+        readonly type: "object";
+        readonly required: readonly ["minters"];
+        readonly properties: {
+            readonly minters: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly additionalProperties: false;
+    };
+    readonly get_all_info: {
+        readonly description: "This is a wrapper around CollectionInfo that includes the extension, contract info, and number of tokens (supply).";
+        readonly type: "object";
+        readonly required: readonly ["collection_extension", "collection_info", "contract_info", "num_tokens"];
+        readonly properties: {
+            readonly collection_extension: {
+                readonly type: "array";
+                readonly items: {
+                    readonly $ref: "#/definitions/Attribute";
+                };
+            };
+            readonly collection_info: {
+                readonly $ref: "#/definitions/CollectionInfo";
+            };
+            readonly contract_info: {
+                readonly $ref: "#/definitions/ContractInfoResponse";
+            };
+            readonly num_tokens: {
+                readonly type: "integer";
+                readonly format: "uint64";
+                readonly minimum: 0;
+            };
+        };
+        readonly additionalProperties: false;
+        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 Attribute: {
+                readonly type: "object";
+                readonly required: readonly ["key", "value"];
+                readonly properties: {
+                    readonly key: {
+                        readonly type: "string";
+                    };
+                    readonly value: {
+                        readonly $ref: "#/definitions/Binary";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            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 CollectionInfo: {
+                readonly type: "object";
+                readonly required: readonly ["name", "symbol", "updated_at"];
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                    };
+                    readonly symbol: {
+                        readonly type: "string";
+                    };
+                    readonly updated_at: {
+                        readonly $ref: "#/definitions/Timestamp";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly ContractInfoResponse: {
+                readonly type: "object";
+                readonly required: readonly ["code_id", "creator", "pinned"];
+                readonly properties: {
+                    readonly admin: {
+                        readonly description: "admin who can run migrations (if any)";
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/Addr";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                    readonly code_id: {
+                        readonly type: "integer";
+                        readonly format: "uint64";
+                        readonly minimum: 0;
+                    };
+                    readonly creator: {
+                        readonly description: "address that instantiated this contract";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Addr";
+                        }];
+                    };
+                    readonly ibc_port: {
+                        readonly description: "set if this contract has bound an IBC port";
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly pinned: {
+                        readonly description: "if set, the contract is pinned to the cache, and thus uses less gas when called";
+                        readonly type: "boolean";
+                    };
+                };
+                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 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 get_collection_extension: {
+        readonly type: "null";
+    };
+    readonly get_collection_extension_attributes: {
+        readonly type: "array";
+        readonly items: {
+            readonly $ref: "#/definitions/Attribute";
+        };
+        readonly definitions: {
+            readonly Attribute: {
+                readonly type: "object";
+                readonly required: readonly ["key", "value"];
+                readonly properties: {
+                    readonly key: {
+                        readonly type: "string";
+                    };
+                    readonly value: {
+                        readonly $ref: "#/definitions/Binary";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            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 get_collection_info_and_extension: {
+        readonly description: "This is a wrapper around CollectionInfo that includes the extension.";
+        readonly type: "object";
+        readonly required: readonly ["name", "symbol", "updated_at"];
+        readonly properties: {
+            readonly extension: {
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/CollectionExtension_for_RoyaltyInfo";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+            readonly name: {
+                readonly type: "string";
+            };
+            readonly symbol: {
+                readonly type: "string";
+            };
+            readonly updated_at: {
+                readonly $ref: "#/definitions/Timestamp";
+            };
+        };
+        readonly additionalProperties: false;
+        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 CollectionExtension_for_RoyaltyInfo: {
+                readonly type: "object";
+                readonly required: readonly ["description", "image"];
+                readonly properties: {
+                    readonly banner_url: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                    readonly explicit_content: {
+                        readonly type: readonly ["boolean", "null"];
+                    };
+                    readonly external_link: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly image: {
+                        readonly type: "string";
+                    };
+                    readonly royalty_info: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/RoyaltyInfo";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                    readonly start_trading_time: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/Timestamp";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly Decimal: {
+                readonly description: "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)";
+                readonly type: "string";
+            };
+            readonly RoyaltyInfo: {
+                readonly type: "object";
+                readonly required: readonly ["payment_address", "share"];
+                readonly properties: {
+                    readonly payment_address: {
+                        readonly $ref: "#/definitions/Addr";
+                    };
+                    readonly share: {
+                        readonly $ref: "#/definitions/Decimal";
+                    };
+                };
+                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 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 get_config: {
+        readonly description: "This is a wrapper around CollectionInfo that includes the extension.";
+        readonly type: "object";
+        readonly required: readonly ["collection_info", "contract_info", "creator_ownership", "minter_ownership", "num_tokens"];
+        readonly properties: {
+            readonly collection_extension: {
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/CollectionExtension_for_RoyaltyInfo";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+            readonly collection_info: {
+                readonly $ref: "#/definitions/CollectionInfo";
+            };
+            readonly contract_info: {
+                readonly $ref: "#/definitions/ContractInfoResponse";
+            };
+            readonly creator_ownership: {
+                readonly $ref: "#/definitions/Ownership_for_Addr";
+            };
+            readonly minter_ownership: {
+                readonly $ref: "#/definitions/Ownership_for_Addr";
+            };
+            readonly num_tokens: {
+                readonly type: "integer";
+                readonly format: "uint64";
+                readonly minimum: 0;
+            };
+            readonly withdraw_address: {
+                readonly type: readonly ["string", "null"];
+            };
+        };
+        readonly additionalProperties: false;
+        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 CollectionExtension_for_RoyaltyInfo: {
+                readonly type: "object";
+                readonly required: readonly ["description", "image"];
+                readonly properties: {
+                    readonly banner_url: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                    readonly explicit_content: {
+                        readonly type: readonly ["boolean", "null"];
+                    };
+                    readonly external_link: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly image: {
+                        readonly type: "string";
+                    };
+                    readonly royalty_info: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/RoyaltyInfo";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                    readonly start_trading_time: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/Timestamp";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly CollectionInfo: {
+                readonly type: "object";
+                readonly required: readonly ["name", "symbol", "updated_at"];
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                    };
+                    readonly symbol: {
+                        readonly type: "string";
+                    };
+                    readonly updated_at: {
+                        readonly $ref: "#/definitions/Timestamp";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly ContractInfoResponse: {
+                readonly type: "object";
+                readonly required: readonly ["code_id", "creator", "pinned"];
+                readonly properties: {
+                    readonly admin: {
+                        readonly description: "admin who can run migrations (if any)";
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/Addr";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                    readonly code_id: {
+                        readonly type: "integer";
+                        readonly format: "uint64";
+                        readonly minimum: 0;
+                    };
+                    readonly creator: {
+                        readonly description: "address that instantiated this contract";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Addr";
+                        }];
+                    };
+                    readonly ibc_port: {
+                        readonly description: "set if this contract has bound an IBC port";
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly pinned: {
+                        readonly description: "if set, the contract is pinned to the cache, and thus uses less gas when called";
+                        readonly type: "boolean";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly Decimal: {
+                readonly description: "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)";
+                readonly type: "string";
+            };
+            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 Ownership_for_Addr: {
+                readonly description: "The contract's ownership info";
+                readonly type: "object";
+                readonly properties: {
+                    readonly owner: {
+                        readonly description: "The contract's current owner. `None` if the ownership has been renounced.";
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/Addr";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                    readonly pending_expiry: {
+                        readonly description: "The deadline for the pending owner to accept the ownership. `None` if there isn't a pending ownership transfer, or if a transfer exists and it doesn't have a deadline.";
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/Expiration";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                    readonly pending_owner: {
+                        readonly description: "The account who has been proposed to take over the ownership. `None` if there isn't a pending ownership transfer.";
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/Addr";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly RoyaltyInfo: {
+                readonly type: "object";
+                readonly required: readonly ["payment_address", "share"];
+                readonly properties: {
+                    readonly payment_address: {
+                        readonly $ref: "#/definitions/Addr";
+                    };
+                    readonly share: {
+                        readonly $ref: "#/definitions/Decimal";
+                    };
+                };
+                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 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 get_creator_ownership: {
+        readonly description: "The contract's ownership info";
+        readonly type: "object";
+        readonly properties: {
+            readonly owner: {
+                readonly description: "The contract's current owner. `None` if the ownership has been renounced.";
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/Addr";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+            readonly pending_expiry: {
+                readonly description: "The deadline for the pending owner to accept the ownership. `None` if there isn't a pending ownership transfer, or if a transfer exists and it doesn't have a deadline.";
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/Expiration";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+            readonly pending_owner: {
+                readonly description: "The account who has been proposed to take over the ownership. `None` if there isn't a pending ownership transfer.";
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/Addr";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+        };
+        readonly additionalProperties: false;
+        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 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 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 get_minter_ownership: {
+        readonly description: "The contract's ownership info";
+        readonly type: "object";
+        readonly properties: {
+            readonly owner: {
+                readonly description: "The contract's current owner. `None` if the ownership has been renounced.";
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/Addr";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+            readonly pending_expiry: {
+                readonly description: "The deadline for the pending owner to accept the ownership. `None` if there isn't a pending ownership transfer, or if a transfer exists and it doesn't have a deadline.";
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/Expiration";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+            readonly pending_owner: {
+                readonly description: "The account who has been proposed to take over the ownership. `None` if there isn't a pending ownership transfer.";
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/Addr";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+        };
+        readonly additionalProperties: false;
+        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 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 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 get_nft_by_extension: {
+        readonly anyOf: readonly [{
+            readonly $ref: "#/definitions/NftInfoResponse_for_Nullable_Empty";
+        }, {
+            readonly type: "null";
+        }];
+        readonly definitions: {
+            readonly Empty: {
+                readonly description: "An empty struct that serves as a placeholder in different places, such as contracts that don't set a custom message.\n\nIt is designed to be expressible in correct JSON and JSON Schema but contains no meaningful data. Previously we used enums without cases, but those cannot represented as valid JSON Schema (https://github.com/CosmWasm/cosmwasm/issues/451)";
+                readonly type: "object";
+                readonly additionalProperties: false;
+            };
+            readonly NftInfoResponse_for_Nullable_Empty: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly extension: {
+                        readonly description: "You can add any custom metadata here when you extend cw721-base";
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/Empty";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                    readonly token_uri: {
+                        readonly description: "Universal resource identifier for this NFT Should point to a JSON file that conforms to the ERC721 Metadata JSON Schema";
+                        readonly type: readonly ["string", "null"];
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+        };
+    };
+    readonly get_withdraw_address: {
+        readonly type: readonly ["string", "null"];
+    };
+    readonly minter: {
+        readonly description: "Deprecated: use Cw721QueryMsg::GetMinterOwnership instead! Shows who can mint these tokens.";
+        readonly type: "object";
+        readonly properties: {
+            readonly minter: {
+                readonly type: readonly ["string", "null"];
+            };
+        };
+        readonly additionalProperties: false;
+    };
+    readonly nft_info: {
+        readonly type: "object";
+        readonly properties: {
+            readonly extension: {
+                readonly description: "You can add any custom metadata here when you extend cw721-base";
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/Empty";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+            readonly token_uri: {
+                readonly description: "Universal resource identifier for this NFT Should point to a JSON file that conforms to the ERC721 Metadata JSON Schema";
+                readonly type: readonly ["string", "null"];
+            };
+        };
+        readonly additionalProperties: false;
+        readonly definitions: {
+            readonly Empty: {
+                readonly description: "An empty struct that serves as a placeholder in different places, such as contracts that don't set a custom message.\n\nIt is designed to be expressible in correct JSON and JSON Schema but contains no meaningful data. Previously we used enums without cases, but those cannot represented as valid JSON Schema (https://github.com/CosmWasm/cosmwasm/issues/451)";
+                readonly type: "object";
+                readonly additionalProperties: false;
+            };
+        };
+    };
+    readonly num_tokens: {
+        readonly type: "object";
+        readonly required: readonly ["count"];
+        readonly properties: {
+            readonly count: {
+                readonly type: "integer";
+                readonly format: "uint64";
+                readonly minimum: 0;
+            };
+        };
+        readonly additionalProperties: false;
+    };
+    readonly operator: {
+        readonly type: "object";
+        readonly required: readonly ["approval"];
+        readonly properties: {
+            readonly approval: {
+                readonly $ref: "#/definitions/Approval";
+            };
+        };
+        readonly additionalProperties: false;
+        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 Approval: {
+                readonly type: "object";
+                readonly required: readonly ["expires", "spender"];
+                readonly properties: {
+                    readonly expires: {
+                        readonly description: "When the Approval expires (maybe Expiration::never)";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Expiration";
+                        }];
+                    };
+                    readonly spender: {
+                        readonly description: "Account that can transfer/send the token";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Addr";
+                        }];
+                    };
+                };
+                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 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 owner_of: {
+        readonly type: "object";
+        readonly required: readonly ["approvals", "owner"];
+        readonly properties: {
+            readonly approvals: {
+                readonly description: "If set this address is approved to transfer/send the token as well";
+                readonly type: "array";
+                readonly items: {
+                    readonly $ref: "#/definitions/Approval";
+                };
+            };
+            readonly owner: {
+                readonly description: "Owner of the token";
+                readonly type: "string";
+            };
+        };
+        readonly additionalProperties: false;
+        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 Approval: {
+                readonly type: "object";
+                readonly required: readonly ["expires", "spender"];
+                readonly properties: {
+                    readonly expires: {
+                        readonly description: "When the Approval expires (maybe Expiration::never)";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Expiration";
+                        }];
+                    };
+                    readonly spender: {
+                        readonly description: "Account that can transfer/send the token";
+                        readonly allOf: readonly [{
+                            readonly $ref: "#/definitions/Addr";
+                        }];
+                    };
+                };
+                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 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 ownership: {
+        readonly description: "The contract's ownership info";
+        readonly type: "object";
+        readonly properties: {
+            readonly owner: {
+                readonly description: "The contract's current owner. `None` if the ownership has been renounced.";
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/Addr";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+            readonly pending_expiry: {
+                readonly description: "The deadline for the pending owner to accept the ownership. `None` if there isn't a pending ownership transfer, or if a transfer exists and it doesn't have a deadline.";
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/Expiration";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+            readonly pending_owner: {
+                readonly description: "The account who has been proposed to take over the ownership. `None` if there isn't a pending ownership transfer.";
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/definitions/Addr";
+                }, {
+                    readonly type: "null";
+                }];
+            };
+        };
+        readonly additionalProperties: false;
+        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 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 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 tokens: {
+        readonly type: "object";
+        readonly required: readonly ["tokens"];
+        readonly properties: {
+            readonly tokens: {
+                readonly description: "Contains all token_ids in lexicographical ordering If there are more than `limit`, use `start_after` in future queries to achieve pagination.";
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly additionalProperties: false;
+    };
+};
+//# sourceMappingURL=responses.d.ts.map