schemos 0.0.1 → 0.1.1

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

@@ -0,0 +1,543 @@
+/**
+ * CW721 ExecuteMsg schema.
+ * Generated from cw-nfts cw721-base cargo schema output.
+ */
+export declare const cw721ExecuteSchema: {
+    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";
+        };
+    };
+};
+//# sourceMappingURL=execute.d.ts.map

package/dist/schemas/cw721/execute.d.ts.map

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