schemos 0.0.1 → 0.1.1

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

@@ -0,0 +1,2507 @@
+import { cw721ExecuteSchema } from './execute.js';
+import { cw721QuerySchema } from './query.js';
+import { cw721ResponseSchemas } from './responses.js';
+export declare const cw721: {
+    readonly execute: {
+        readonly oneOf: readonly [{
+            readonly description: "Deprecated: use UpdateMinterOwnership instead! Will be removed in next release!";
+            readonly deprecated: true;
+            readonly type: "object";
+            readonly required: readonly ["update_ownership"];
+            readonly properties: {
+                readonly update_ownership: {
+                    readonly $ref: "#/definitions/Action";
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly type: "object";
+            readonly required: readonly ["update_minter_ownership"];
+            readonly properties: {
+                readonly update_minter_ownership: {
+                    readonly $ref: "#/definitions/Action";
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly type: "object";
+            readonly required: readonly ["update_creator_ownership"];
+            readonly properties: {
+                readonly update_creator_ownership: {
+                    readonly $ref: "#/definitions/Action";
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "The creator is the only one eligible to update `CollectionInfo`.";
+            readonly type: "object";
+            readonly required: readonly ["update_collection_info"];
+            readonly properties: {
+                readonly update_collection_info: {
+                    readonly type: "object";
+                    readonly required: readonly ["collection_info"];
+                    readonly properties: {
+                        readonly collection_info: {
+                            readonly $ref: "#/definitions/CollectionInfoMsg_for_Nullable_CollectionExtensionMsg_for_RoyaltyInfoResponse";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Transfer is a base message to move a token to another account without triggering actions";
+            readonly type: "object";
+            readonly required: readonly ["transfer_nft"];
+            readonly properties: {
+                readonly transfer_nft: {
+                    readonly type: "object";
+                    readonly required: readonly ["recipient", "token_id"];
+                    readonly properties: {
+                        readonly recipient: {
+                            readonly type: "string";
+                        };
+                        readonly token_id: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Send is a base message to transfer a token to a contract and trigger an action on the receiving contract.";
+            readonly type: "object";
+            readonly required: readonly ["send_nft"];
+            readonly properties: {
+                readonly send_nft: {
+                    readonly type: "object";
+                    readonly required: readonly ["contract", "msg", "token_id"];
+                    readonly properties: {
+                        readonly contract: {
+                            readonly type: "string";
+                        };
+                        readonly msg: {
+                            readonly $ref: "#/definitions/Binary";
+                        };
+                        readonly token_id: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Allows operator to transfer / send the token from the owner's account. If expiration is set, then this allowance has a time/height limit";
+            readonly type: "object";
+            readonly required: readonly ["approve"];
+            readonly properties: {
+                readonly approve: {
+                    readonly type: "object";
+                    readonly required: readonly ["spender", "token_id"];
+                    readonly properties: {
+                        readonly expires: {
+                            readonly anyOf: readonly [{
+                                readonly $ref: "#/definitions/Expiration";
+                            }, {
+                                readonly type: "null";
+                            }];
+                        };
+                        readonly spender: {
+                            readonly type: "string";
+                        };
+                        readonly token_id: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Remove previously granted Approval";
+            readonly type: "object";
+            readonly required: readonly ["revoke"];
+            readonly properties: {
+                readonly revoke: {
+                    readonly type: "object";
+                    readonly required: readonly ["spender", "token_id"];
+                    readonly properties: {
+                        readonly spender: {
+                            readonly type: "string";
+                        };
+                        readonly token_id: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Allows operator to transfer / send any token from the owner's account. If expiration is set, then this allowance has a time/height limit";
+            readonly type: "object";
+            readonly required: readonly ["approve_all"];
+            readonly properties: {
+                readonly approve_all: {
+                    readonly type: "object";
+                    readonly required: readonly ["operator"];
+                    readonly properties: {
+                        readonly expires: {
+                            readonly anyOf: readonly [{
+                                readonly $ref: "#/definitions/Expiration";
+                            }, {
+                                readonly type: "null";
+                            }];
+                        };
+                        readonly operator: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Remove previously granted ApproveAll permission";
+            readonly type: "object";
+            readonly required: readonly ["revoke_all"];
+            readonly properties: {
+                readonly revoke_all: {
+                    readonly type: "object";
+                    readonly required: readonly ["operator"];
+                    readonly properties: {
+                        readonly operator: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Mint a new NFT, can only be called by the contract minter";
+            readonly type: "object";
+            readonly required: readonly ["mint"];
+            readonly properties: {
+                readonly mint: {
+                    readonly type: "object";
+                    readonly required: readonly ["owner", "token_id"];
+                    readonly properties: {
+                        readonly extension: {
+                            readonly description: "Any custom extension used by this contract";
+                            readonly anyOf: readonly [{
+                                readonly $ref: "#/definitions/Empty";
+                            }, {
+                                readonly type: "null";
+                            }];
+                        };
+                        readonly owner: {
+                            readonly description: "The owner of the newly minter NFT";
+                            readonly type: "string";
+                        };
+                        readonly token_id: {
+                            readonly description: "Unique ID of the NFT";
+                            readonly type: "string";
+                        };
+                        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 additionalProperties: false;
+        }, {
+            readonly description: "Burn an NFT the sender has access to";
+            readonly type: "object";
+            readonly required: readonly ["burn"];
+            readonly properties: {
+                readonly burn: {
+                    readonly type: "object";
+                    readonly required: readonly ["token_id"];
+                    readonly properties: {
+                        readonly token_id: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Add an additional minter. Only the primary minter (manager) can call this.";
+            readonly type: "object";
+            readonly required: readonly ["add_minter"];
+            readonly properties: {
+                readonly add_minter: {
+                    readonly type: "object";
+                    readonly required: readonly ["minter"];
+                    readonly properties: {
+                        readonly minter: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Remove an additional minter. Only the primary minter (manager) can call this.";
+            readonly type: "object";
+            readonly required: readonly ["remove_minter"];
+            readonly properties: {
+                readonly remove_minter: {
+                    readonly type: "object";
+                    readonly required: readonly ["minter"];
+                    readonly properties: {
+                        readonly minter: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Custom msg execution. This is a no-op in default implementation.";
+            readonly type: "object";
+            readonly required: readonly ["update_extension"];
+            readonly properties: {
+                readonly update_extension: {
+                    readonly type: "object";
+                    readonly required: readonly ["msg"];
+                    readonly properties: {
+                        readonly msg: {
+                            readonly $ref: "#/definitions/Empty";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "The creator is the only one eligible to update NFT's token uri and onchain metadata (`NftInfo.extension`). NOTE: approvals and owner are not affected by this call, since they belong to the NFT owner.";
+            readonly type: "object";
+            readonly required: readonly ["update_nft_info"];
+            readonly properties: {
+                readonly update_nft_info: {
+                    readonly type: "object";
+                    readonly required: readonly ["token_id"];
+                    readonly properties: {
+                        readonly extension: {
+                            readonly anyOf: readonly [{
+                                readonly $ref: "#/definitions/Empty";
+                            }, {
+                                readonly type: "null";
+                            }];
+                        };
+                        readonly token_id: {
+                            readonly type: "string";
+                        };
+                        readonly token_uri: {
+                            readonly description: "NOTE: Empty string is handled as None";
+                            readonly type: readonly ["string", "null"];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Sets address to send withdrawn fees to. Only owner can call this.";
+            readonly type: "object";
+            readonly required: readonly ["set_withdraw_address"];
+            readonly properties: {
+                readonly set_withdraw_address: {
+                    readonly type: "object";
+                    readonly required: readonly ["address"];
+                    readonly properties: {
+                        readonly address: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Removes the withdraw address, so fees are sent to the contract. Only owner can call this.";
+            readonly type: "object";
+            readonly required: readonly ["remove_withdraw_address"];
+            readonly properties: {
+                readonly remove_withdraw_address: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Withdraw from the contract to the given address. Anyone can call this, which is okay since withdraw address has been set by owner.";
+            readonly type: "object";
+            readonly required: readonly ["withdraw_funds"];
+            readonly properties: {
+                readonly withdraw_funds: {
+                    readonly type: "object";
+                    readonly required: readonly ["amount"];
+                    readonly properties: {
+                        readonly amount: {
+                            readonly $ref: "#/definitions/Coin";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }];
+        readonly definitions: {
+            readonly Action: {
+                readonly description: "Actions that can be taken to alter the contract's ownership";
+                readonly oneOf: readonly [{
+                    readonly description: "Propose to transfer the contract's ownership to another account, optionally with an expiry time.\n\nCan only be called by the contract's current owner.\n\nAny existing pending ownership transfer is overwritten.";
+                    readonly type: "object";
+                    readonly required: readonly ["transfer_ownership"];
+                    readonly properties: {
+                        readonly transfer_ownership: {
+                            readonly type: "object";
+                            readonly required: readonly ["new_owner"];
+                            readonly properties: {
+                                readonly expiry: {
+                                    readonly anyOf: readonly [{
+                                        readonly $ref: "#/definitions/Expiration";
+                                    }, {
+                                        readonly type: "null";
+                                    }];
+                                };
+                                readonly new_owner: {
+                                    readonly type: "string";
+                                };
+                            };
+                            readonly additionalProperties: false;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }, {
+                    readonly description: "Accept the pending ownership transfer.\n\nCan only be called by the pending owner.";
+                    readonly type: "string";
+                    readonly enum: readonly ["accept_ownership"];
+                }, {
+                    readonly description: "Give up the contract's ownership and the possibility of appointing a new owner.\n\nCan only be invoked by the contract's current owner.\n\nAny existing pending ownership transfer is canceled.";
+                    readonly type: "string";
+                    readonly enum: readonly ["renounce_ownership"];
+                }];
+            };
+            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 Coin: {
+                readonly type: "object";
+                readonly required: readonly ["amount", "denom"];
+                readonly properties: {
+                    readonly amount: {
+                        readonly $ref: "#/definitions/Uint128";
+                    };
+                    readonly denom: {
+                        readonly type: "string";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly CollectionExtensionMsg_for_RoyaltyInfoResponse: {
+                readonly description: "NOTE: In case `info` is not provided in `create()` or `validate()` (like for migration), creator/minter assertion is skipped.";
+                readonly type: "object";
+                readonly properties: {
+                    readonly banner_url: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly description: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly explicit_content: {
+                        readonly type: readonly ["boolean", "null"];
+                    };
+                    readonly external_link: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly image: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly royalty_info: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/RoyaltyInfoResponse";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                    readonly start_trading_time: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/Timestamp";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly CollectionInfoMsg_for_Nullable_CollectionExtensionMsg_for_RoyaltyInfoResponse: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly extension: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/CollectionExtensionMsg_for_RoyaltyInfoResponse";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                    readonly name: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly symbol: {
+                        readonly type: readonly ["string", "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 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 RoyaltyInfoResponse: {
+                readonly type: "object";
+                readonly required: readonly ["payment_address", "share"];
+                readonly properties: {
+                    readonly payment_address: {
+                        readonly type: "string";
+                    };
+                    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 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: "Return the owner of the given token, error if token does not exist";
+            readonly type: "object";
+            readonly required: readonly ["owner_of"];
+            readonly properties: {
+                readonly owner_of: {
+                    readonly type: "object";
+                    readonly required: readonly ["token_id"];
+                    readonly properties: {
+                        readonly include_expired: {
+                            readonly description: "unset or false will filter out expired approvals, you must set to true to see them";
+                            readonly type: readonly ["boolean", "null"];
+                        };
+                        readonly token_id: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Return operator that can access all of the owner's tokens.";
+            readonly type: "object";
+            readonly required: readonly ["approval"];
+            readonly properties: {
+                readonly approval: {
+                    readonly type: "object";
+                    readonly required: readonly ["spender", "token_id"];
+                    readonly properties: {
+                        readonly include_expired: {
+                            readonly type: readonly ["boolean", "null"];
+                        };
+                        readonly spender: {
+                            readonly type: "string";
+                        };
+                        readonly token_id: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Return approvals that a token has";
+            readonly type: "object";
+            readonly required: readonly ["approvals"];
+            readonly properties: {
+                readonly approvals: {
+                    readonly type: "object";
+                    readonly required: readonly ["token_id"];
+                    readonly properties: {
+                        readonly include_expired: {
+                            readonly type: readonly ["boolean", "null"];
+                        };
+                        readonly token_id: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Return approval of a given operator for all tokens of an owner, error if not set";
+            readonly type: "object";
+            readonly required: readonly ["operator"];
+            readonly properties: {
+                readonly operator: {
+                    readonly type: "object";
+                    readonly required: readonly ["operator", "owner"];
+                    readonly properties: {
+                        readonly include_expired: {
+                            readonly type: readonly ["boolean", "null"];
+                        };
+                        readonly operator: {
+                            readonly type: "string";
+                        };
+                        readonly owner: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "List all operators that can access all of the owner's tokens";
+            readonly type: "object";
+            readonly required: readonly ["all_operators"];
+            readonly properties: {
+                readonly all_operators: {
+                    readonly type: "object";
+                    readonly required: readonly ["owner"];
+                    readonly properties: {
+                        readonly include_expired: {
+                            readonly description: "unset or false will filter out expired items, you must set to true to see them";
+                            readonly type: readonly ["boolean", "null"];
+                        };
+                        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: "Total number of tokens issued";
+            readonly type: "object";
+            readonly required: readonly ["num_tokens"];
+            readonly properties: {
+                readonly num_tokens: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Deprecated: use GetCollectionInfoAndExtension instead! Will be removed in next release!";
+            readonly deprecated: true;
+            readonly type: "object";
+            readonly required: readonly ["contract_info"];
+            readonly properties: {
+                readonly contract_info: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Returns `AllCollectionInfoResponse`";
+            readonly type: "object";
+            readonly required: readonly ["get_config"];
+            readonly properties: {
+                readonly get_config: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Returns `CollectionInfoAndExtensionResponse`";
+            readonly type: "object";
+            readonly required: readonly ["get_collection_info_and_extension"];
+            readonly properties: {
+                readonly get_collection_info_and_extension: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "returns `AllInfoResponse` which contains contract, collection and nft details";
+            readonly type: "object";
+            readonly required: readonly ["get_all_info"];
+            readonly properties: {
+                readonly get_all_info: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Returns `CollectionExtensionAttributes`";
+            readonly type: "object";
+            readonly required: readonly ["get_collection_extension_attributes"];
+            readonly properties: {
+                readonly get_collection_extension_attributes: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Deprecated: use GetMinterOwnership instead! Will be removed in next release!";
+            readonly deprecated: true;
+            readonly type: "object";
+            readonly required: readonly ["ownership"];
+            readonly properties: {
+                readonly ownership: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Return the minter Deprecated: use GetMinterOwnership instead! Will be removed in next release!";
+            readonly deprecated: true;
+            readonly type: "object";
+            readonly required: readonly ["minter"];
+            readonly properties: {
+                readonly minter: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly type: "object";
+            readonly required: readonly ["get_minter_ownership"];
+            readonly properties: {
+                readonly get_minter_ownership: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly type: "object";
+            readonly required: readonly ["get_creator_ownership"];
+            readonly properties: {
+                readonly get_creator_ownership: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "Returns the list of additional minters (paginated).";
+            readonly type: "object";
+            readonly required: readonly ["get_additional_minters"];
+            readonly properties: {
+                readonly get_additional_minters: {
+                    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: "With MetaData Extension. Returns metadata about one particular token, based on *ERC721 Metadata JSON Schema* but directly from the contract";
+            readonly type: "object";
+            readonly required: readonly ["nft_info"];
+            readonly properties: {
+                readonly nft_info: {
+                    readonly type: "object";
+                    readonly required: readonly ["token_id"];
+                    readonly properties: {
+                        readonly token_id: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly type: "object";
+            readonly required: readonly ["get_nft_by_extension"];
+            readonly properties: {
+                readonly get_nft_by_extension: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly extension: {
+                            readonly anyOf: readonly [{
+                                readonly $ref: "#/definitions/Empty";
+                            }, {
+                                readonly type: "null";
+                            }];
+                        };
+                        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: "With MetaData Extension. Returns the result of both `NftInfo` and `OwnerOf` as one query as an optimization for clients";
+            readonly type: "object";
+            readonly required: readonly ["all_nft_info"];
+            readonly properties: {
+                readonly all_nft_info: {
+                    readonly type: "object";
+                    readonly required: readonly ["token_id"];
+                    readonly properties: {
+                        readonly include_expired: {
+                            readonly description: "unset or false will filter out expired approvals, you must set to true to see them";
+                            readonly type: readonly ["boolean", "null"];
+                        };
+                        readonly token_id: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly description: "With Enumerable extension. Returns all tokens owned by the given address, [] if unset.";
+            readonly type: "object";
+            readonly required: readonly ["tokens"];
+            readonly properties: {
+                readonly tokens: {
+                    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: "With Enumerable extension. Requires pagination. Lists all token_ids controlled by the contract.";
+            readonly type: "object";
+            readonly required: readonly ["all_tokens"];
+            readonly properties: {
+                readonly all_tokens: {
+                    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: "Custom msg query. Default implementation returns an empty binary.";
+            readonly type: "object";
+            readonly required: readonly ["extension"];
+            readonly properties: {
+                readonly extension: {
+                    readonly type: "object";
+                    readonly required: readonly ["msg"];
+                    readonly properties: {
+                        readonly msg: {
+                            readonly $ref: "#/definitions/Empty";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly type: "object";
+            readonly required: readonly ["get_collection_extension"];
+            readonly properties: {
+                readonly get_collection_extension: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly msg: {
+                            readonly anyOf: readonly [{
+                                readonly $ref: "#/definitions/CollectionExtension_for_RoyaltyInfo";
+                            }, {
+                                readonly type: "null";
+                            }];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
+        }, {
+            readonly type: "object";
+            readonly required: readonly ["get_withdraw_address"];
+            readonly properties: {
+                readonly get_withdraw_address: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                };
+            };
+            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 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 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 responses: {
+        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;
+        };
+    };
+};
+export { cw721ExecuteSchema, cw721QuerySchema, cw721ResponseSchemas };
+//# sourceMappingURL=index.d.ts.map