// Code generated - DO NOT EDIT.
// This file is a generated binding and any manual changes will be lost.

package operator

import (
	"errors"
	"math/big"
	"strings"

	ethereum "github.com/ethereum/go-ethereum"
	"github.com/ethereum/go-ethereum/accounts/abi"
	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/event"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = errors.New
	_ = big.NewInt
	_ = strings.NewReader
	_ = ethereum.NotFound
	_ = bind.Bind
	_ = common.Big1
	_ = types.BloomLookup
	_ = event.NewSubscription
)

// MetaRareOperatorNFTVoucher is an auto generated low-level Go binding around an user-defined struct.
type MetaRareOperatorNFTVoucher struct {
	Signer          common.Address
	TokenAddress    common.Address
	TokenType       *big.Int
	TokenId         *big.Int
	AssetAddress    common.Address
	Price           *big.Int
	Balance         *big.Int
	TotalBalance    *big.Int
	CreationTax     *big.Int
	TreasuryTax     *big.Int
	TreasuryAddress common.Address
	Uri             string
}

// ECDSAMetaData contains all meta data concerning the ECDSA contract.
var ECDSAMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212207399d7bed8861595eae1922da30eaff01349050487eb3c339a8f061492540c2364736f6c63430008000033",
}

// ECDSAABI is the input ABI used to generate the binding from.
// Deprecated: Use ECDSAMetaData.ABI instead.
var ECDSAABI = ECDSAMetaData.ABI

// ECDSABin is the compiled bytecode used for deploying new contracts.
// Deprecated: Use ECDSAMetaData.Bin instead.
var ECDSABin = ECDSAMetaData.Bin

// DeployECDSA deploys a new Ethereum contract, binding an instance of ECDSA to it.
func DeployECDSA(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ECDSA, error) {
	parsed, err := ECDSAMetaData.GetAbi()
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	if parsed == nil {
		return common.Address{}, nil, nil, errors.New("GetABI returned nil")
	}

	address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ECDSABin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &ECDSA{ECDSACaller: ECDSACaller{contract: contract}, ECDSATransactor: ECDSATransactor{contract: contract}, ECDSAFilterer: ECDSAFilterer{contract: contract}}, nil
}

// ECDSA is an auto generated Go binding around an Ethereum contract.
type ECDSA struct {
	ECDSACaller     // Read-only binding to the contract
	ECDSATransactor // Write-only binding to the contract
	ECDSAFilterer   // Log filterer for contract events
}

// ECDSACaller is an auto generated read-only Go binding around an Ethereum contract.
type ECDSACaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// ECDSATransactor is an auto generated write-only Go binding around an Ethereum contract.
type ECDSATransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// ECDSAFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type ECDSAFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// ECDSASession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type ECDSASession struct {
	Contract     *ECDSA            // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// ECDSACallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type ECDSACallerSession struct {
	Contract *ECDSACaller  // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts // Call options to use throughout this session
}

// ECDSATransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type ECDSATransactorSession struct {
	Contract     *ECDSATransactor  // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// ECDSARaw is an auto generated low-level Go binding around an Ethereum contract.
type ECDSARaw struct {
	Contract *ECDSA // Generic contract binding to access the raw methods on
}

// ECDSACallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type ECDSACallerRaw struct {
	Contract *ECDSACaller // Generic read-only contract binding to access the raw methods on
}

// ECDSATransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type ECDSATransactorRaw struct {
	Contract *ECDSATransactor // Generic write-only contract binding to access the raw methods on
}

// NewECDSA creates a new instance of ECDSA, bound to a specific deployed contract.
func NewECDSA(address common.Address, backend bind.ContractBackend) (*ECDSA, error) {
	contract, err := bindECDSA(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &ECDSA{ECDSACaller: ECDSACaller{contract: contract}, ECDSATransactor: ECDSATransactor{contract: contract}, ECDSAFilterer: ECDSAFilterer{contract: contract}}, nil
}

// NewECDSACaller creates a new read-only instance of ECDSA, bound to a specific deployed contract.
func NewECDSACaller(address common.Address, caller bind.ContractCaller) (*ECDSACaller, error) {
	contract, err := bindECDSA(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &ECDSACaller{contract: contract}, nil
}

// NewECDSATransactor creates a new write-only instance of ECDSA, bound to a specific deployed contract.
func NewECDSATransactor(address common.Address, transactor bind.ContractTransactor) (*ECDSATransactor, error) {
	contract, err := bindECDSA(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &ECDSATransactor{contract: contract}, nil
}

// NewECDSAFilterer creates a new log filterer instance of ECDSA, bound to a specific deployed contract.
func NewECDSAFilterer(address common.Address, filterer bind.ContractFilterer) (*ECDSAFilterer, error) {
	contract, err := bindECDSA(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &ECDSAFilterer{contract: contract}, nil
}

// bindECDSA binds a generic wrapper to an already deployed contract.
func bindECDSA(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(ECDSAABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_ECDSA *ECDSARaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _ECDSA.Contract.ECDSACaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_ECDSA *ECDSARaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ECDSA.Contract.ECDSATransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ECDSA *ECDSARaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ECDSA.Contract.ECDSATransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_ECDSA *ECDSACallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _ECDSA.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_ECDSA *ECDSATransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _ECDSA.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_ECDSA *ECDSATransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _ECDSA.Contract.contract.Transact(opts, method, params...)
}

// EIP712MetaData contains all meta data concerning the EIP712 contract.
var EIP712MetaData = &bind.MetaData{
	ABI: "[]",
}

// EIP712ABI is the input ABI used to generate the binding from.
// Deprecated: Use EIP712MetaData.ABI instead.
var EIP712ABI = EIP712MetaData.ABI

// EIP712 is an auto generated Go binding around an Ethereum contract.
type EIP712 struct {
	EIP712Caller     // Read-only binding to the contract
	EIP712Transactor // Write-only binding to the contract
	EIP712Filterer   // Log filterer for contract events
}

// EIP712Caller is an auto generated read-only Go binding around an Ethereum contract.
type EIP712Caller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// EIP712Transactor is an auto generated write-only Go binding around an Ethereum contract.
type EIP712Transactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// EIP712Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
type EIP712Filterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// EIP712Session is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type EIP712Session struct {
	Contract     *EIP712           // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// EIP712CallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type EIP712CallerSession struct {
	Contract *EIP712Caller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts // Call options to use throughout this session
}

// EIP712TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type EIP712TransactorSession struct {
	Contract     *EIP712Transactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// EIP712Raw is an auto generated low-level Go binding around an Ethereum contract.
type EIP712Raw struct {
	Contract *EIP712 // Generic contract binding to access the raw methods on
}

// EIP712CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type EIP712CallerRaw struct {
	Contract *EIP712Caller // Generic read-only contract binding to access the raw methods on
}

// EIP712TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type EIP712TransactorRaw struct {
	Contract *EIP712Transactor // Generic write-only contract binding to access the raw methods on
}

// NewEIP712 creates a new instance of EIP712, bound to a specific deployed contract.
func NewEIP712(address common.Address, backend bind.ContractBackend) (*EIP712, error) {
	contract, err := bindEIP712(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &EIP712{EIP712Caller: EIP712Caller{contract: contract}, EIP712Transactor: EIP712Transactor{contract: contract}, EIP712Filterer: EIP712Filterer{contract: contract}}, nil
}

// NewEIP712Caller creates a new read-only instance of EIP712, bound to a specific deployed contract.
func NewEIP712Caller(address common.Address, caller bind.ContractCaller) (*EIP712Caller, error) {
	contract, err := bindEIP712(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &EIP712Caller{contract: contract}, nil
}

// NewEIP712Transactor creates a new write-only instance of EIP712, bound to a specific deployed contract.
func NewEIP712Transactor(address common.Address, transactor bind.ContractTransactor) (*EIP712Transactor, error) {
	contract, err := bindEIP712(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &EIP712Transactor{contract: contract}, nil
}

// NewEIP712Filterer creates a new log filterer instance of EIP712, bound to a specific deployed contract.
func NewEIP712Filterer(address common.Address, filterer bind.ContractFilterer) (*EIP712Filterer, error) {
	contract, err := bindEIP712(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &EIP712Filterer{contract: contract}, nil
}

// bindEIP712 binds a generic wrapper to an already deployed contract.
func bindEIP712(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(EIP712ABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_EIP712 *EIP712Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _EIP712.Contract.EIP712Caller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_EIP712 *EIP712Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _EIP712.Contract.EIP712Transactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_EIP712 *EIP712Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _EIP712.Contract.EIP712Transactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_EIP712 *EIP712CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _EIP712.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_EIP712 *EIP712TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _EIP712.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_EIP712 *EIP712TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _EIP712.Contract.contract.Transact(opts, method, params...)
}

// IERC20MetaData contains all meta data concerning the IERC20 contract.
var IERC20MetaData = &bind.MetaData{
	ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
	Sigs: map[string]string{
		"095ea7b3": "approve(address,uint256)",
		"70a08231": "balanceOf(address)",
		"a9059cbb": "transfer(address,uint256)",
		"23b872dd": "transferFrom(address,address,uint256)",
	},
}

// IERC20ABI is the input ABI used to generate the binding from.
// Deprecated: Use IERC20MetaData.ABI instead.
var IERC20ABI = IERC20MetaData.ABI

// Deprecated: Use IERC20MetaData.Sigs instead.
// IERC20FuncSigs maps the 4-byte function signature to its string representation.
var IERC20FuncSigs = IERC20MetaData.Sigs

// IERC20 is an auto generated Go binding around an Ethereum contract.
type IERC20 struct {
	IERC20Caller     // Read-only binding to the contract
	IERC20Transactor // Write-only binding to the contract
	IERC20Filterer   // Log filterer for contract events
}

// IERC20Caller is an auto generated read-only Go binding around an Ethereum contract.
type IERC20Caller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// IERC20Transactor is an auto generated write-only Go binding around an Ethereum contract.
type IERC20Transactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// IERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
type IERC20Filterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// IERC20Session is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type IERC20Session struct {
	Contract     *IERC20           // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// IERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type IERC20CallerSession struct {
	Contract *IERC20Caller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts // Call options to use throughout this session
}

// IERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type IERC20TransactorSession struct {
	Contract     *IERC20Transactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// IERC20Raw is an auto generated low-level Go binding around an Ethereum contract.
type IERC20Raw struct {
	Contract *IERC20 // Generic contract binding to access the raw methods on
}

// IERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type IERC20CallerRaw struct {
	Contract *IERC20Caller // Generic read-only contract binding to access the raw methods on
}

// IERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type IERC20TransactorRaw struct {
	Contract *IERC20Transactor // Generic write-only contract binding to access the raw methods on
}

// NewIERC20 creates a new instance of IERC20, bound to a specific deployed contract.
func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error) {
	contract, err := bindIERC20(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &IERC20{IERC20Caller: IERC20Caller{contract: contract}, IERC20Transactor: IERC20Transactor{contract: contract}, IERC20Filterer: IERC20Filterer{contract: contract}}, nil
}

// NewIERC20Caller creates a new read-only instance of IERC20, bound to a specific deployed contract.
func NewIERC20Caller(address common.Address, caller bind.ContractCaller) (*IERC20Caller, error) {
	contract, err := bindIERC20(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &IERC20Caller{contract: contract}, nil
}

// NewIERC20Transactor creates a new write-only instance of IERC20, bound to a specific deployed contract.
func NewIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC20Transactor, error) {
	contract, err := bindIERC20(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &IERC20Transactor{contract: contract}, nil
}

// NewIERC20Filterer creates a new log filterer instance of IERC20, bound to a specific deployed contract.
func NewIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC20Filterer, error) {
	contract, err := bindIERC20(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &IERC20Filterer{contract: contract}, nil
}

// bindIERC20 binds a generic wrapper to an already deployed contract.
func bindIERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(IERC20ABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_IERC20 *IERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _IERC20.Contract.IERC20Caller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _IERC20.Contract.IERC20Transactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_IERC20 *IERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _IERC20.Contract.IERC20Transactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_IERC20 *IERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _IERC20.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _IERC20.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_IERC20 *IERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _IERC20.Contract.contract.Transact(opts, method, params...)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address owner) view returns(uint256)
func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) {
	var out []interface{}
	err := _IERC20.contract.Call(opts, &out, "balanceOf", owner)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address owner) view returns(uint256)
func (_IERC20 *IERC20Session) BalanceOf(owner common.Address) (*big.Int, error) {
	return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, owner)
}

// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
//
// Solidity: function balanceOf(address owner) view returns(uint256)
func (_IERC20 *IERC20CallerSession) BalanceOf(owner common.Address) (*big.Int, error) {
	return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, owner)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 value) returns(bool)
func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error) {
	return _IERC20.contract.Transact(opts, "approve", spender, value)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 value) returns(bool)
func (_IERC20 *IERC20Session) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) {
	return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, value)
}

// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
//
// Solidity: function approve(address spender, uint256 value) returns(bool)
func (_IERC20 *IERC20TransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) {
	return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, value)
}

// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
//
// Solidity: function transfer(address to, uint256 amount) returns(bool)
func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) {
	return _IERC20.contract.Transact(opts, "transfer", to, amount)
}

// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
//
// Solidity: function transfer(address to, uint256 amount) returns(bool)
func (_IERC20 *IERC20Session) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) {
	return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, to, amount)
}

// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
//
// Solidity: function transfer(address to, uint256 amount) returns(bool)
func (_IERC20 *IERC20TransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) {
	return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, to, amount)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address from, address to, uint256 value) returns(bool)
func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) {
	return _IERC20.contract.Transact(opts, "transferFrom", from, to, value)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address from, address to, uint256 value) returns(bool)
func (_IERC20 *IERC20Session) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) {
	return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, from, to, value)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address from, address to, uint256 value) returns(bool)
func (_IERC20 *IERC20TransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) {
	return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, from, to, value)
}

// IMetaRareERC1155CollectionMetaData contains all meta data concerning the IMetaRareERC1155Collection contract.
var IMetaRareERC1155CollectionMetaData = &bind.MetaData{
	ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"createByOperator\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"exists\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"transferOnlyOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
	Sigs: map[string]string{
		"00fdd58e": "balanceOf(address,uint256)",
		"61321c14": "createByOperator(address,uint256,uint256,string,bytes)",
		"4f558e79": "exists(uint256)",
		"8da5cb5b": "owner()",
		"f242432a": "safeTransferFrom(address,address,uint256,uint256,bytes)",
		"7c7ae4d1": "transferOnlyOperator(address,address,uint256,uint256)",
	},
}

// IMetaRareERC1155CollectionABI is the input ABI used to generate the binding from.
// Deprecated: Use IMetaRareERC1155CollectionMetaData.ABI instead.
var IMetaRareERC1155CollectionABI = IMetaRareERC1155CollectionMetaData.ABI

// Deprecated: Use IMetaRareERC1155CollectionMetaData.Sigs instead.
// IMetaRareERC1155CollectionFuncSigs maps the 4-byte function signature to its string representation.
var IMetaRareERC1155CollectionFuncSigs = IMetaRareERC1155CollectionMetaData.Sigs

// IMetaRareERC1155Collection is an auto generated Go binding around an Ethereum contract.
type IMetaRareERC1155Collection struct {
	IMetaRareERC1155CollectionCaller     // Read-only binding to the contract
	IMetaRareERC1155CollectionTransactor // Write-only binding to the contract
	IMetaRareERC1155CollectionFilterer   // Log filterer for contract events
}

// IMetaRareERC1155CollectionCaller is an auto generated read-only Go binding around an Ethereum contract.
type IMetaRareERC1155CollectionCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// IMetaRareERC1155CollectionTransactor is an auto generated write-only Go binding around an Ethereum contract.
type IMetaRareERC1155CollectionTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// IMetaRareERC1155CollectionFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type IMetaRareERC1155CollectionFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// IMetaRareERC1155CollectionSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type IMetaRareERC1155CollectionSession struct {
	Contract     *IMetaRareERC1155Collection // Generic contract binding to set the session for
	CallOpts     bind.CallOpts               // Call options to use throughout this session
	TransactOpts bind.TransactOpts           // Transaction auth options to use throughout this session
}

// IMetaRareERC1155CollectionCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type IMetaRareERC1155CollectionCallerSession struct {
	Contract *IMetaRareERC1155CollectionCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts                     // Call options to use throughout this session
}

// IMetaRareERC1155CollectionTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type IMetaRareERC1155CollectionTransactorSession struct {
	Contract     *IMetaRareERC1155CollectionTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts                     // Transaction auth options to use throughout this session
}

// IMetaRareERC1155CollectionRaw is an auto generated low-level Go binding around an Ethereum contract.
type IMetaRareERC1155CollectionRaw struct {
	Contract *IMetaRareERC1155Collection // Generic contract binding to access the raw methods on
}

// IMetaRareERC1155CollectionCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type IMetaRareERC1155CollectionCallerRaw struct {
	Contract *IMetaRareERC1155CollectionCaller // Generic read-only contract binding to access the raw methods on
}

// IMetaRareERC1155CollectionTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type IMetaRareERC1155CollectionTransactorRaw struct {
	Contract *IMetaRareERC1155CollectionTransactor // Generic write-only contract binding to access the raw methods on
}

// NewIMetaRareERC1155Collection creates a new instance of IMetaRareERC1155Collection, bound to a specific deployed contract.
func NewIMetaRareERC1155Collection(address common.Address, backend bind.ContractBackend) (*IMetaRareERC1155Collection, error) {
	contract, err := bindIMetaRareERC1155Collection(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &IMetaRareERC1155Collection{IMetaRareERC1155CollectionCaller: IMetaRareERC1155CollectionCaller{contract: contract}, IMetaRareERC1155CollectionTransactor: IMetaRareERC1155CollectionTransactor{contract: contract}, IMetaRareERC1155CollectionFilterer: IMetaRareERC1155CollectionFilterer{contract: contract}}, nil
}

// NewIMetaRareERC1155CollectionCaller creates a new read-only instance of IMetaRareERC1155Collection, bound to a specific deployed contract.
func NewIMetaRareERC1155CollectionCaller(address common.Address, caller bind.ContractCaller) (*IMetaRareERC1155CollectionCaller, error) {
	contract, err := bindIMetaRareERC1155Collection(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &IMetaRareERC1155CollectionCaller{contract: contract}, nil
}

// NewIMetaRareERC1155CollectionTransactor creates a new write-only instance of IMetaRareERC1155Collection, bound to a specific deployed contract.
func NewIMetaRareERC1155CollectionTransactor(address common.Address, transactor bind.ContractTransactor) (*IMetaRareERC1155CollectionTransactor, error) {
	contract, err := bindIMetaRareERC1155Collection(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &IMetaRareERC1155CollectionTransactor{contract: contract}, nil
}

// NewIMetaRareERC1155CollectionFilterer creates a new log filterer instance of IMetaRareERC1155Collection, bound to a specific deployed contract.
func NewIMetaRareERC1155CollectionFilterer(address common.Address, filterer bind.ContractFilterer) (*IMetaRareERC1155CollectionFilterer, error) {
	contract, err := bindIMetaRareERC1155Collection(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &IMetaRareERC1155CollectionFilterer{contract: contract}, nil
}

// bindIMetaRareERC1155Collection binds a generic wrapper to an already deployed contract.
func bindIMetaRareERC1155Collection(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(IMetaRareERC1155CollectionABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _IMetaRareERC1155Collection.Contract.IMetaRareERC1155CollectionCaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _IMetaRareERC1155Collection.Contract.IMetaRareERC1155CollectionTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _IMetaRareERC1155Collection.Contract.IMetaRareERC1155CollectionTransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _IMetaRareERC1155Collection.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _IMetaRareERC1155Collection.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _IMetaRareERC1155Collection.Contract.contract.Transact(opts, method, params...)
}

// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e.
//
// Solidity: function balanceOf(address , uint256 ) view returns(uint256)
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionCaller) BalanceOf(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int) (*big.Int, error) {
	var out []interface{}
	err := _IMetaRareERC1155Collection.contract.Call(opts, &out, "balanceOf", arg0, arg1)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e.
//
// Solidity: function balanceOf(address , uint256 ) view returns(uint256)
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionSession) BalanceOf(arg0 common.Address, arg1 *big.Int) (*big.Int, error) {
	return _IMetaRareERC1155Collection.Contract.BalanceOf(&_IMetaRareERC1155Collection.CallOpts, arg0, arg1)
}

// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e.
//
// Solidity: function balanceOf(address , uint256 ) view returns(uint256)
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionCallerSession) BalanceOf(arg0 common.Address, arg1 *big.Int) (*big.Int, error) {
	return _IMetaRareERC1155Collection.Contract.BalanceOf(&_IMetaRareERC1155Collection.CallOpts, arg0, arg1)
}

// Exists is a free data retrieval call binding the contract method 0x4f558e79.
//
// Solidity: function exists(uint256 ) view returns(bool)
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionCaller) Exists(opts *bind.CallOpts, arg0 *big.Int) (bool, error) {
	var out []interface{}
	err := _IMetaRareERC1155Collection.contract.Call(opts, &out, "exists", arg0)

	if err != nil {
		return *new(bool), err
	}

	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)

	return out0, err

}

// Exists is a free data retrieval call binding the contract method 0x4f558e79.
//
// Solidity: function exists(uint256 ) view returns(bool)
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionSession) Exists(arg0 *big.Int) (bool, error) {
	return _IMetaRareERC1155Collection.Contract.Exists(&_IMetaRareERC1155Collection.CallOpts, arg0)
}

// Exists is a free data retrieval call binding the contract method 0x4f558e79.
//
// Solidity: function exists(uint256 ) view returns(bool)
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionCallerSession) Exists(arg0 *big.Int) (bool, error) {
	return _IMetaRareERC1155Collection.Contract.Exists(&_IMetaRareERC1155Collection.CallOpts, arg0)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() view returns(address)
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
	var out []interface{}
	err := _IMetaRareERC1155Collection.contract.Call(opts, &out, "owner")

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() view returns(address)
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionSession) Owner() (common.Address, error) {
	return _IMetaRareERC1155Collection.Contract.Owner(&_IMetaRareERC1155Collection.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() view returns(address)
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionCallerSession) Owner() (common.Address, error) {
	return _IMetaRareERC1155Collection.Contract.Owner(&_IMetaRareERC1155Collection.CallOpts)
}

// CreateByOperator is a paid mutator transaction binding the contract method 0x61321c14.
//
// Solidity: function createByOperator(address , uint256 , uint256 , string , bytes ) returns(uint256)
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionTransactor) CreateByOperator(opts *bind.TransactOpts, arg0 common.Address, arg1 *big.Int, arg2 *big.Int, arg3 string, arg4 []byte) (*types.Transaction, error) {
	return _IMetaRareERC1155Collection.contract.Transact(opts, "createByOperator", arg0, arg1, arg2, arg3, arg4)
}

// CreateByOperator is a paid mutator transaction binding the contract method 0x61321c14.
//
// Solidity: function createByOperator(address , uint256 , uint256 , string , bytes ) returns(uint256)
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionSession) CreateByOperator(arg0 common.Address, arg1 *big.Int, arg2 *big.Int, arg3 string, arg4 []byte) (*types.Transaction, error) {
	return _IMetaRareERC1155Collection.Contract.CreateByOperator(&_IMetaRareERC1155Collection.TransactOpts, arg0, arg1, arg2, arg3, arg4)
}

// CreateByOperator is a paid mutator transaction binding the contract method 0x61321c14.
//
// Solidity: function createByOperator(address , uint256 , uint256 , string , bytes ) returns(uint256)
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionTransactorSession) CreateByOperator(arg0 common.Address, arg1 *big.Int, arg2 *big.Int, arg3 string, arg4 []byte) (*types.Transaction, error) {
	return _IMetaRareERC1155Collection.Contract.CreateByOperator(&_IMetaRareERC1155Collection.TransactOpts, arg0, arg1, arg2, arg3, arg4)
}

// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a.
//
// Solidity: function safeTransferFrom(address , address , uint256 , uint256 , bytes ) returns()
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionTransactor) SafeTransferFrom(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) {
	return _IMetaRareERC1155Collection.contract.Transact(opts, "safeTransferFrom", arg0, arg1, arg2, arg3, arg4)
}

// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a.
//
// Solidity: function safeTransferFrom(address , address , uint256 , uint256 , bytes ) returns()
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionSession) SafeTransferFrom(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) {
	return _IMetaRareERC1155Collection.Contract.SafeTransferFrom(&_IMetaRareERC1155Collection.TransactOpts, arg0, arg1, arg2, arg3, arg4)
}

// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a.
//
// Solidity: function safeTransferFrom(address , address , uint256 , uint256 , bytes ) returns()
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionTransactorSession) SafeTransferFrom(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int, arg4 []byte) (*types.Transaction, error) {
	return _IMetaRareERC1155Collection.Contract.SafeTransferFrom(&_IMetaRareERC1155Collection.TransactOpts, arg0, arg1, arg2, arg3, arg4)
}

// TransferOnlyOperator is a paid mutator transaction binding the contract method 0x7c7ae4d1.
//
// Solidity: function transferOnlyOperator(address , address , uint256 , uint256 ) returns()
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionTransactor) TransferOnlyOperator(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int) (*types.Transaction, error) {
	return _IMetaRareERC1155Collection.contract.Transact(opts, "transferOnlyOperator", arg0, arg1, arg2, arg3)
}

// TransferOnlyOperator is a paid mutator transaction binding the contract method 0x7c7ae4d1.
//
// Solidity: function transferOnlyOperator(address , address , uint256 , uint256 ) returns()
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionSession) TransferOnlyOperator(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int) (*types.Transaction, error) {
	return _IMetaRareERC1155Collection.Contract.TransferOnlyOperator(&_IMetaRareERC1155Collection.TransactOpts, arg0, arg1, arg2, arg3)
}

// TransferOnlyOperator is a paid mutator transaction binding the contract method 0x7c7ae4d1.
//
// Solidity: function transferOnlyOperator(address , address , uint256 , uint256 ) returns()
func (_IMetaRareERC1155Collection *IMetaRareERC1155CollectionTransactorSession) TransferOnlyOperator(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 *big.Int) (*types.Transaction, error) {
	return _IMetaRareERC1155Collection.Contract.TransferOnlyOperator(&_IMetaRareERC1155Collection.TransactOpts, arg0, arg1, arg2, arg3)
}

// IMetaRareERC721CollectionMetaData contains all meta data concerning the IMetaRareERC721Collection contract.
var IMetaRareERC721CollectionMetaData = &bind.MetaData{
	ABI: "[{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"hasRole\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"transferOnlyOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
	Sigs: map[string]string{
		"91d14854": "hasRole(bytes32,address)",
		"40c10f19": "mint(address,uint256)",
		"6352211e": "ownerOf(uint256)",
		"23b872dd": "transferFrom(address,address,uint256)",
		"5145dc57": "transferOnlyOperator(address,address,uint256)",
	},
}

// IMetaRareERC721CollectionABI is the input ABI used to generate the binding from.
// Deprecated: Use IMetaRareERC721CollectionMetaData.ABI instead.
var IMetaRareERC721CollectionABI = IMetaRareERC721CollectionMetaData.ABI

// Deprecated: Use IMetaRareERC721CollectionMetaData.Sigs instead.
// IMetaRareERC721CollectionFuncSigs maps the 4-byte function signature to its string representation.
var IMetaRareERC721CollectionFuncSigs = IMetaRareERC721CollectionMetaData.Sigs

// IMetaRareERC721Collection is an auto generated Go binding around an Ethereum contract.
type IMetaRareERC721Collection struct {
	IMetaRareERC721CollectionCaller     // Read-only binding to the contract
	IMetaRareERC721CollectionTransactor // Write-only binding to the contract
	IMetaRareERC721CollectionFilterer   // Log filterer for contract events
}

// IMetaRareERC721CollectionCaller is an auto generated read-only Go binding around an Ethereum contract.
type IMetaRareERC721CollectionCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// IMetaRareERC721CollectionTransactor is an auto generated write-only Go binding around an Ethereum contract.
type IMetaRareERC721CollectionTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// IMetaRareERC721CollectionFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type IMetaRareERC721CollectionFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// IMetaRareERC721CollectionSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type IMetaRareERC721CollectionSession struct {
	Contract     *IMetaRareERC721Collection // Generic contract binding to set the session for
	CallOpts     bind.CallOpts              // Call options to use throughout this session
	TransactOpts bind.TransactOpts          // Transaction auth options to use throughout this session
}

// IMetaRareERC721CollectionCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type IMetaRareERC721CollectionCallerSession struct {
	Contract *IMetaRareERC721CollectionCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts                    // Call options to use throughout this session
}

// IMetaRareERC721CollectionTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type IMetaRareERC721CollectionTransactorSession struct {
	Contract     *IMetaRareERC721CollectionTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts                    // Transaction auth options to use throughout this session
}

// IMetaRareERC721CollectionRaw is an auto generated low-level Go binding around an Ethereum contract.
type IMetaRareERC721CollectionRaw struct {
	Contract *IMetaRareERC721Collection // Generic contract binding to access the raw methods on
}

// IMetaRareERC721CollectionCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type IMetaRareERC721CollectionCallerRaw struct {
	Contract *IMetaRareERC721CollectionCaller // Generic read-only contract binding to access the raw methods on
}

// IMetaRareERC721CollectionTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type IMetaRareERC721CollectionTransactorRaw struct {
	Contract *IMetaRareERC721CollectionTransactor // Generic write-only contract binding to access the raw methods on
}

// NewIMetaRareERC721Collection creates a new instance of IMetaRareERC721Collection, bound to a specific deployed contract.
func NewIMetaRareERC721Collection(address common.Address, backend bind.ContractBackend) (*IMetaRareERC721Collection, error) {
	contract, err := bindIMetaRareERC721Collection(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &IMetaRareERC721Collection{IMetaRareERC721CollectionCaller: IMetaRareERC721CollectionCaller{contract: contract}, IMetaRareERC721CollectionTransactor: IMetaRareERC721CollectionTransactor{contract: contract}, IMetaRareERC721CollectionFilterer: IMetaRareERC721CollectionFilterer{contract: contract}}, nil
}

// NewIMetaRareERC721CollectionCaller creates a new read-only instance of IMetaRareERC721Collection, bound to a specific deployed contract.
func NewIMetaRareERC721CollectionCaller(address common.Address, caller bind.ContractCaller) (*IMetaRareERC721CollectionCaller, error) {
	contract, err := bindIMetaRareERC721Collection(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &IMetaRareERC721CollectionCaller{contract: contract}, nil
}

// NewIMetaRareERC721CollectionTransactor creates a new write-only instance of IMetaRareERC721Collection, bound to a specific deployed contract.
func NewIMetaRareERC721CollectionTransactor(address common.Address, transactor bind.ContractTransactor) (*IMetaRareERC721CollectionTransactor, error) {
	contract, err := bindIMetaRareERC721Collection(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &IMetaRareERC721CollectionTransactor{contract: contract}, nil
}

// NewIMetaRareERC721CollectionFilterer creates a new log filterer instance of IMetaRareERC721Collection, bound to a specific deployed contract.
func NewIMetaRareERC721CollectionFilterer(address common.Address, filterer bind.ContractFilterer) (*IMetaRareERC721CollectionFilterer, error) {
	contract, err := bindIMetaRareERC721Collection(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &IMetaRareERC721CollectionFilterer{contract: contract}, nil
}

// bindIMetaRareERC721Collection binds a generic wrapper to an already deployed contract.
func bindIMetaRareERC721Collection(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(IMetaRareERC721CollectionABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _IMetaRareERC721Collection.Contract.IMetaRareERC721CollectionCaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _IMetaRareERC721Collection.Contract.IMetaRareERC721CollectionTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _IMetaRareERC721Collection.Contract.IMetaRareERC721CollectionTransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _IMetaRareERC721Collection.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _IMetaRareERC721Collection.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _IMetaRareERC721Collection.Contract.contract.Transact(opts, method, params...)
}

// HasRole is a free data retrieval call binding the contract method 0x91d14854.
//
// Solidity: function hasRole(bytes32 , address ) view returns(bool)
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionCaller) HasRole(opts *bind.CallOpts, arg0 [32]byte, arg1 common.Address) (bool, error) {
	var out []interface{}
	err := _IMetaRareERC721Collection.contract.Call(opts, &out, "hasRole", arg0, arg1)

	if err != nil {
		return *new(bool), err
	}

	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)

	return out0, err

}

// HasRole is a free data retrieval call binding the contract method 0x91d14854.
//
// Solidity: function hasRole(bytes32 , address ) view returns(bool)
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionSession) HasRole(arg0 [32]byte, arg1 common.Address) (bool, error) {
	return _IMetaRareERC721Collection.Contract.HasRole(&_IMetaRareERC721Collection.CallOpts, arg0, arg1)
}

// HasRole is a free data retrieval call binding the contract method 0x91d14854.
//
// Solidity: function hasRole(bytes32 , address ) view returns(bool)
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionCallerSession) HasRole(arg0 [32]byte, arg1 common.Address) (bool, error) {
	return _IMetaRareERC721Collection.Contract.HasRole(&_IMetaRareERC721Collection.CallOpts, arg0, arg1)
}

// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
//
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
	var out []interface{}
	err := _IMetaRareERC721Collection.contract.Call(opts, &out, "ownerOf", tokenId)

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
//
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
	return _IMetaRareERC721Collection.Contract.OwnerOf(&_IMetaRareERC721Collection.CallOpts, tokenId)
}

// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
//
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
	return _IMetaRareERC721Collection.Contract.OwnerOf(&_IMetaRareERC721Collection.CallOpts, tokenId)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address , uint256 ) returns()
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionTransactor) Mint(opts *bind.TransactOpts, arg0 common.Address, arg1 *big.Int) (*types.Transaction, error) {
	return _IMetaRareERC721Collection.contract.Transact(opts, "mint", arg0, arg1)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address , uint256 ) returns()
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionSession) Mint(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error) {
	return _IMetaRareERC721Collection.Contract.Mint(&_IMetaRareERC721Collection.TransactOpts, arg0, arg1)
}

// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
//
// Solidity: function mint(address , uint256 ) returns()
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionTransactorSession) Mint(arg0 common.Address, arg1 *big.Int) (*types.Transaction, error) {
	return _IMetaRareERC721Collection.Contract.Mint(&_IMetaRareERC721Collection.TransactOpts, arg0, arg1)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
	return _IMetaRareERC721Collection.contract.Transact(opts, "transferFrom", from, to, tokenId)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
	return _IMetaRareERC721Collection.Contract.TransferFrom(&_IMetaRareERC721Collection.TransactOpts, from, to, tokenId)
}

// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
//
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
	return _IMetaRareERC721Collection.Contract.TransferFrom(&_IMetaRareERC721Collection.TransactOpts, from, to, tokenId)
}

// TransferOnlyOperator is a paid mutator transaction binding the contract method 0x5145dc57.
//
// Solidity: function transferOnlyOperator(address , address , uint256 ) returns()
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionTransactor) TransferOnlyOperator(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int) (*types.Transaction, error) {
	return _IMetaRareERC721Collection.contract.Transact(opts, "transferOnlyOperator", arg0, arg1, arg2)
}

// TransferOnlyOperator is a paid mutator transaction binding the contract method 0x5145dc57.
//
// Solidity: function transferOnlyOperator(address , address , uint256 ) returns()
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionSession) TransferOnlyOperator(arg0 common.Address, arg1 common.Address, arg2 *big.Int) (*types.Transaction, error) {
	return _IMetaRareERC721Collection.Contract.TransferOnlyOperator(&_IMetaRareERC721Collection.TransactOpts, arg0, arg1, arg2)
}

// TransferOnlyOperator is a paid mutator transaction binding the contract method 0x5145dc57.
//
// Solidity: function transferOnlyOperator(address , address , uint256 ) returns()
func (_IMetaRareERC721Collection *IMetaRareERC721CollectionTransactorSession) TransferOnlyOperator(arg0 common.Address, arg1 common.Address, arg2 *big.Int) (*types.Transaction, error) {
	return _IMetaRareERC721Collection.Contract.TransferOnlyOperator(&_IMetaRareERC721Collection.TransactOpts, arg0, arg1, arg2)
}

// MetaRareOperatorMetaData contains all meta data concerning the MetaRareOperator contract.
var MetaRareOperatorMetaData = &bind.MetaData{
	ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"DEFAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MINTER_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"creationTaxRate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"creators\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"creatorsWithinCollection\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenType\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"assetAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"price\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"creationTax\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"treasuryTax\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"treasuryAddress\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"uri\",\"type\":\"string\"}],\"internalType\":\"structMetaRareOperator.NFTVoucher\",\"name\":\"voucher\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"hash\",\"type\":\"bytes32\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"excuteMintingOrderWithERC1155Collection\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenType\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"assetAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"price\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"creationTax\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"treasuryTax\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"treasuryAddress\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"uri\",\"type\":\"string\"}],\"internalType\":\"structMetaRareOperator.NFTVoucher\",\"name\":\"voucher\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"hash\",\"type\":\"bytes32\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"excuteMintingOrderWithERC1155MetaRareCollection\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenType\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"assetAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"price\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"creationTax\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"treasuryTax\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"treasuryAddress\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"uri\",\"type\":\"string\"}],\"internalType\":\"structMetaRareOperator.NFTVoucher\",\"name\":\"voucher\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"hash\",\"type\":\"bytes32\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"excuteMintingOrderWithERC721Collection\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenType\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"assetAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"price\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"creationTax\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"treasuryTax\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"treasuryAddress\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"uri\",\"type\":\"string\"}],\"internalType\":\"structMetaRareOperator.NFTVoucher\",\"name\":\"voucher\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"hash\",\"type\":\"bytes32\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"excuteMintingOrderWithERC721MetaRareCollection\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenType\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"assetAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"price\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"creationTax\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"treasuryTax\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"treasuryAddress\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"uri\",\"type\":\"string\"}],\"internalType\":\"structMetaRareOperator.NFTVoucher\",\"name\":\"voucher\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"hash\",\"type\":\"bytes32\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"excuteTransferOrderWithERC1155Collection\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tokenType\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"assetAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"price\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"creationTax\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"treasuryTax\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"treasuryAddress\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"uri\",\"type\":\"string\"}],\"internalType\":\"structMetaRareOperator.NFTVoucher\",\"name\":\"voucher\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"hash\",\"type\":\"bytes32\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"excuteTransferOrderWithERC721Collection\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"msgHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"recoverAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]",
	Sigs: map[string]string{
		"a217fddf": "DEFAULT_ADMIN_ROLE()",
		"d5391393": "MINTER_ROLE()",
		"5ac3ac45": "creationTaxRate(address,uint256)",
		"cd53d08e": "creators(uint256)",
		"0370a7a2": "creatorsWithinCollection(address,uint256)",
		"b2381e3d": "excuteMintingOrderWithERC1155Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string),bytes32,uint8,bytes32,bytes32)",
		"33bd3379": "excuteMintingOrderWithERC1155MetaRareCollection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string),bytes32,uint8,bytes32,bytes32)",
		"6104c09b": "excuteMintingOrderWithERC721Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string),bytes32,uint8,bytes32,bytes32)",
		"1f247a2f": "excuteMintingOrderWithERC721MetaRareCollection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string),bytes32,uint8,bytes32,bytes32)",
		"03b5b423": "excuteTransferOrderWithERC1155Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string),bytes32,uint8,bytes32,bytes32)",
		"ec938286": "excuteTransferOrderWithERC721Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string),bytes32,uint8,bytes32,bytes32)",
		"8428cf83": "recoverAddress(bytes32,uint8,bytes32,bytes32)",
	},
	Bin: "0x61014060405234801561001157600080fd5b5060408051808201825260088152674d4554415241524560c01b6020808301918252835180850190945260018452603160f81b908401528151902060e08190527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc66101008190524660a0529192917f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f6100ab8184846100c3565b6080523060601b60c052610120525061012992505050565b600083838346306040516020016100de9594939291906100fd565b6040516020818303038152906040528051906020012090509392505050565b9485526020850193909352604084019190915260608301526001600160a01b0316608082015260a00190565b60805160a05160c05160601c60e05161010051610120516122fd6200016a6000396000505060005050600050506000505060005050600050506122fd6000f3fe6080604052600436106100a75760003560e01c80638428cf83116100645780638428cf831461015d578063a217fddf1461017d578063b2381e3d14610192578063cd53d08e146101a5578063d5391393146101c5578063ec938286146101da576100a7565b80630370a7a2146100ac57806303b5b423146100e25780631f247a2f146100f757806333bd33791461010a5780635ac3ac451461011d5780636104c09b1461014a575b600080fd5b3480156100b857600080fd5b506100cc6100c7366004611ef7565b6101ed565b6040516100d99190612018565b60405180910390f35b6100f56100f0366004611f7c565b610213565b005b6100f5610105366004611f7c565b61087a565b6100f5610118366004611f7c565b610d0a565b34801561012957600080fd5b5061013d610138366004611ef7565b61133c565b6040516100d9919061212b565b6100f5610158366004611f7c565b611359565b34801561016957600080fd5b506100cc610178366004611f42565b6115a5565b34801561018957600080fd5b5061013d611600565b6100f56101a0366004611f7c565b611605565b3480156101b157600080fd5b506100cc6101c0366004611fe8565b61183a565b3480156101d157600080fd5b5061013d611855565b6100f56101e8366004611f7c565b611879565b60016020908152600092835260408084209091529082529020546001600160a01b031681565b6000610221858585856115a5565b90506102306020870187611ebf565b6001600160a01b0316816001600160a01b0316146102695760405162461bcd60e51b81526004016102609061218b565b60405180910390fd5b61027b61016087016101408801611ebf565b600380546001600160a01b0319166001600160a01b039290921691909117905560006102ad6040880160208901611ebf565b604051627eeac760e11b8152909150819060c0890135906001600160a01b0383169062fdd58e906102e890879060608e0135906004016120b1565b60206040518083038186803b15801561030057600080fd5b505afa158015610314573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103389190612000565b10156103565760405162461bcd60e51b8152600401610260906121b6565b600061036860a08a0160808b01611ebf565b6001600160a01b031614156104f9578760a0013534101561039b5760405162461bcd60e51b815260040161026090612169565b8260006001816103b160408d0160208e01611ebf565b6001600160a01b0390811682526020808301939093526040918201600090812060608f01358252909352908220541691506104016127106103fb60a08e01356101208f0135611e7e565b90611e91565b905060008b60a00135905061042a6127106103fb8e610100013584611e7e90919063ffffffff16565b905060a08c01356104458261043f8386611e9d565b90611e9d565b6003546040519192506001600160a01b03169084156108fc029085906000818181858888f19350505050158015610480573d6000803e3d6000fd5b506040516001600160a01b0385169083156108fc029084906000818181858888f193505050501580156104b7573d6000803e3d6000fd5b506040516001600160a01b0386169082156108fc029083906000818181858888f193505050501580156104ee573d6000803e3d6000fd5b505050505050610804565b600061050b60a08a0160808b01611ebf565b90508860a00135816001600160a01b03166370a08231336040518263ffffffff1660e01b815260040161053e9190612018565b60206040518083038186803b15801561055657600080fd5b505afa15801561056a573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061058e9190612000565b10156105ac5760405162461bcd60e51b815260040161026090612169565b60006105c76127106103fb60a08d01356101208e0135611e7e565b905060006105e46127106103fb60a08e01356101008f0135611e7e565b905060006105fa8261043f60a08f013586611e9d565b90506000600160008e60200160208101906106159190611ebf565b6001600160a01b03166001600160a01b0316815260200190815260200160002060008e60600135815260200190815260200160002060009054906101000a90046001600160a01b03169050846001600160a01b03166323b872dd33600360009054906101000a90046001600160a01b0316876040518463ffffffff1660e01b81526004016106a59392919061202c565b602060405180830381600087803b1580156106bf57600080fd5b505af11580156106d3573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106f79190611f22565b506040516323b872dd60e01b81526001600160a01b038616906323b872dd906107289033908590889060040161202c565b602060405180830381600087803b15801561074257600080fd5b505af1158015610756573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061077a9190611f22565b506040516323b872dd60e01b81526001600160a01b038616906323b872dd906107ab9033908c90879060040161202c565b602060405180830381600087803b1580156107c557600080fd5b505af11580156107d9573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906107fd9190611f22565b5050505050505b604051637c7ae4d160e01b81526001600160a01b03821690637c7ae4d19061083e908690339060608e01359060c08f013590600401612050565b600060405180830381600087803b15801561085857600080fd5b505af115801561086c573d6000803e3d6000fd5b505050505050505050505050565b6000610888858585856115a5565b90506108976020870187611ebf565b6001600160a01b0316816001600160a01b0316146108c75760405162461bcd60e51b81526004016102609061218b565b606086013560009081526020818152604080832080546001600160a01b0319166001600160a01b0386811691909117918290551692600192909161091091908b01908b01611ebf565b6001600160a01b03166001600160a01b0316815260200190815260200160002060008860600135815260200190815260200160002060006101000a8154816001600160a01b0302191690836001600160a01b03160217905550856101000135600260008860200160208101906109869190611ebf565b6001600160a01b031681526020808201929092526040908101600090812060608b013582529092529020556109c361016087016101408801611ebf565b600380546001600160a01b0319166001600160a01b039290921691909117905560006109f56040880160208901611ebf565b9050806000610a0a60a08a0160808b01611ebf565b6001600160a01b03161415610ae6578760a00135341015610a3d5760405162461bcd60e51b815260040161026090612169565b826000610a596127106103fb60a08d01356101208e0135611e7e565b90506000610a6b60a08c013583611e9d565b6003546040519192506001600160a01b03169083156108fc029084906000818181858888f19350505050158015610aa6573d6000803e3d6000fd5b506040516001600160a01b0384169082156108fc029083906000818181858888f19350505050158015610add573d6000803e3d6000fd5b50505050610cd8565b6000610af860a08a0160808b01611ebf565b90508860a00135816001600160a01b03166370a08231336040518263ffffffff1660e01b8152600401610b2b9190612018565b60206040518083038186803b158015610b4357600080fd5b505afa158015610b57573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b7b9190612000565b1015610b995760405162461bcd60e51b815260040161026090612169565b6000610bb46127106103fb60a08d01356101208e0135611e7e565b90506000610bc660a08c013583611e9d565b6003546040516323b872dd60e01b81529192506001600160a01b03808616926323b872dd92610bfe923392911690879060040161202c565b602060405180830381600087803b158015610c1857600080fd5b505af1158015610c2c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c509190611f22565b506040516323b872dd60e01b81526001600160a01b038416906323b872dd90610c819033908a90869060040161202c565b602060405180830381600087803b158015610c9b57600080fd5b505af1158015610caf573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610cd39190611f22565b505050505b6040516340c10f1960e01b81526001600160a01b038216906340c10f199061083e90339060608d0135906004016120b1565b6000610d18858585856115a5565b9050610d276020870187611ebf565b6001600160a01b0316816001600160a01b031614610d575760405162461bcd60e51b81526004016102609061218b565b606086013560009081526020818152604080832080546001600160a01b0319166001600160a01b03868116919091179182905516926001929091610da091908b01908b01611ebf565b6001600160a01b03166001600160a01b0316815260200190815260200160002060008860600135815260200190815260200160002060006101000a8154816001600160a01b0302191690836001600160a01b0316021790555085610100013560026000886020016020810190610e169190611ebf565b6001600160a01b031681526020808201929092526040908101600090812060608b01358252909252902055610e5361016087016101408801611ebf565b600380546001600160a01b0319166001600160a01b03929092169190911790556000610e856040880160208901611ebf565b9050806000610e9a60a08a0160808b01611ebf565b6001600160a01b03161415610f76578760a00135341015610ecd5760405162461bcd60e51b815260040161026090612169565b826000610ee96127106103fb60a08d01356101208e0135611e7e565b90506000610efb60a08c013583611e9d565b6003546040519192506001600160a01b03169083156108fc029084906000818181858888f19350505050158015610f36573d6000803e3d6000fd5b506040516001600160a01b0384169082156108fc029083906000818181858888f19350505050158015610f6d573d6000803e3d6000fd5b50505050611168565b6000610f8860a08a0160808b01611ebf565b90508860a00135816001600160a01b03166370a08231336040518263ffffffff1660e01b8152600401610fbb9190612018565b60206040518083038186803b158015610fd357600080fd5b505afa158015610fe7573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061100b9190612000565b10156110295760405162461bcd60e51b815260040161026090612169565b60006110446127106103fb60a08d01356101208e0135611e7e565b9050600061105660a08c013583611e9d565b6003546040516323b872dd60e01b81529192506001600160a01b03808616926323b872dd9261108e923392911690879060040161202c565b602060405180830381600087803b1580156110a857600080fd5b505af11580156110bc573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906110e09190611f22565b506040516323b872dd60e01b81526001600160a01b038416906323b872dd906111119033908a90869060040161202c565b602060405180830381600087803b15801561112b57600080fd5b505af115801561113f573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111639190611f22565b505050505b604051634f558e7960e01b81526001600160a01b03821690634f558e79906111989060608c01359060040161212b565b60206040518083038186803b1580156111b057600080fd5b505afa1580156111c4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111e89190611f22565b6112f8576001600160a01b0381166361321c148460608b013560e08c01356112146101608e018e6121f7565b6040518663ffffffff1660e01b81526004016112349594939291906120ca565b602060405180830381600087803b15801561124e57600080fd5b505af1158015611262573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906112869190612000565b50604051637921219560e11b81526001600160a01b0382169063f242432a906112c1908690339060608e01359060c08f013590600401612079565b600060405180830381600087803b1580156112db57600080fd5b505af11580156112ef573d6000803e3d6000fd5b50505050611332565b604051637921219560e11b81526001600160a01b0382169063f242432a9061083e908690339060608e01359060c08f013590600401612079565b5050505050505050565b600260209081526000928352604080842090915290825290205481565b6000611367858585856115a5565b90506113766020870187611ebf565b6001600160a01b0316816001600160a01b0316146113a65760405162461bcd60e51b81526004016102609061218b565b606086013560009081526020818152604080832080546001600160a01b0319166001600160a01b038681169190911791829055169260019290916113ef91908b01908b01611ebf565b6001600160a01b03166001600160a01b0316815260200190815260200160002060008860600135815260200190815260200160002060006101000a8154816001600160a01b0302191690836001600160a01b03160217905550856101000135600260008860200160208101906114659190611ebf565b6001600160a01b031681526020808201929092526040908101600090812060608b013582529092529020556114a261016087016101408801611ebf565b600380546001600160a01b0319166001600160a01b039290921691909117905560006114d46040880160208901611ebf565b604051632474521560e21b815290915081906001600160a01b038216906391d1485490611527907f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6908790600401612134565b60206040518083038186803b15801561153f57600080fd5b505afa158015611553573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906115779190611f22565b6115935760405162461bcd60e51b8152600401610260906121b6565b6000610a0a60a08a0160808b01611ebf565b6000600185858585604051600081526020016040526040516115ca949392919061214b565b6020604051602081039080840390855afa1580156115ec573d6000803e3d6000fd5b5050604051601f1901519695505050505050565b600081565b6000611613858585856115a5565b90506116226020870187611ebf565b6001600160a01b0316816001600160a01b0316146116525760405162461bcd60e51b81526004016102609061218b565b606086013560009081526020818152604080832080546001600160a01b0319166001600160a01b0386811691909117918290551692600192909161169b91908b01908b01611ebf565b6001600160a01b03166001600160a01b0316815260200190815260200160002060008860600135815260200190815260200160002060006101000a8154816001600160a01b0302191690836001600160a01b03160217905550856101000135600260008860200160208101906117119190611ebf565b6001600160a01b031681526020808201929092526040908101600090812060608b0135825290925290205561174e61016087016101408801611ebf565b600380546001600160a01b0319166001600160a01b039290921691909117905560006117806040880160208901611ebf565b90506000819050826001600160a01b0316816001600160a01b0316638da5cb5b6040518163ffffffff1660e01b815260040160206040518083038186803b1580156117ca57600080fd5b505afa1580156117de573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906118029190611edb565b6001600160a01b0316146118285760405162461bcd60e51b8152600401610260906121b6565b6000610e9a60a08a0160808b01611ebf565b6000602081905290815260409020546001600160a01b031681565b7f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a681565b6000611887858585856115a5565b90506118966020870187611ebf565b6001600160a01b0316816001600160a01b0316146118c65760405162461bcd60e51b81526004016102609061218b565b6118d861016087016101408801611ebf565b600380546001600160a01b0319166001600160a01b0392909216919091179055600061190a6040880160208901611ebf565b6040516331a9108f60e11b815290915081906001600160a01b038085169190831690636352211e906119449060608d01359060040161212b565b60206040518083038186803b15801561195c57600080fd5b505afa158015611970573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906119949190611edb565b6001600160a01b0316146119ba5760405162461bcd60e51b8152600401610260906121b6565b60006119cc60a08a0160808b01611ebf565b6001600160a01b03161415611b4e578760a001353410156119ff5760405162461bcd60e51b815260040161026090612169565b826000600181611a1560408d0160208e01611ebf565b6001600160a01b0390811682526020808301939093526040918201600090812060608f0135825290935290822054169150611a5f6127106103fb60a08e01356101208f0135611e7e565b90506000611a856127106103fb8e61010001358f60a00135611e7e90919063ffffffff16565b905060a08c0135611a9a8261043f8386611e9d565b6003546040519192506001600160a01b03169084156108fc029085906000818181858888f19350505050158015611ad5573d6000803e3d6000fd5b506040516001600160a01b0385169083156108fc029084906000818181858888f19350505050158015611b0c573d6000803e3d6000fd5b506040516001600160a01b0386169082156108fc029083906000818181858888f19350505050158015611b43573d6000803e3d6000fd5b505050505050611e4a565b6000611b6060a08a0160808b01611ebf565b90508860a00135816001600160a01b03166370a08231336040518263ffffffff1660e01b8152600401611b939190612018565b60206040518083038186803b158015611bab57600080fd5b505afa158015611bbf573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611be39190612000565b1015611c015760405162461bcd60e51b815260040161026090612169565b6000611c1c6127106103fb60a08d01356101208e0135611e7e565b90506000611c396127106103fb60a08e01356101008f0135611e7e565b90506000611c4f8261043f60a08f013586611e9d565b6003546040516323b872dd60e01b81529192506001600160a01b03808716926323b872dd92611c87923392911690889060040161202c565b602060405180830381600087803b158015611ca157600080fd5b505af1158015611cb5573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611cd99190611f22565b506000600160008e6020016020810190611cf39190611ebf565b6001600160a01b03166001600160a01b0316815260200190815260200160002060008e60600135815260200190815260200160002060009054906101000a90046001600160a01b03169050846001600160a01b03166323b872dd3383866040518463ffffffff1660e01b8152600401611d6e9392919061202c565b602060405180830381600087803b158015611d8857600080fd5b505af1158015611d9c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611dc09190611f22565b506040516323b872dd60e01b81526001600160a01b038616906323b872dd90611df19033908c90879060040161202c565b602060405180830381600087803b158015611e0b57600080fd5b505af1158015611e1f573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611e439190611f22565b5050505050505b604051635145dc5760e01b81526001600160a01b03821690635145dc579061083e908690339060608e01359060040161202c565b6000611e8a8284612263565b9392505050565b6000611e8a8284612243565b6000611e8a8284612282565b803560ff81168114611eba57600080fd5b919050565b600060208284031215611ed0578081fd5b8135611e8a816122af565b600060208284031215611eec578081fd5b8151611e8a816122af565b60008060408385031215611f09578081fd5b8235611f14816122af565b946020939093013593505050565b600060208284031215611f33578081fd5b81518015158114611e8a578182fd5b60008060008060808587031215611f57578182fd5b84359350611f6760208601611ea9565b93969395505050506040820135916060013590565b600080600080600060a08688031215611f93578081fd5b853567ffffffffffffffff811115611fa9578182fd5b86016101808189031215611fbb578182fd5b945060208601359350611fd060408701611ea9565b94979396509394606081013594506080013592915050565b600060208284031215611ff9578081fd5b5035919050565b600060208284031215612011578081fd5b5051919050565b6001600160a01b0391909116815260200190565b6001600160a01b039384168152919092166020820152604081019190915260600190565b6001600160a01b0394851681529290931660208301526040820152606081019190915260800190565b6001600160a01b0394851681529290931660208301526040820152606081019190915260a06080820181905260009082015260c00190565b6001600160a01b03929092168252602082015260400190565b600060018060a01b038716825285602083015284604083015260a060608301528260a0830152828460c08401378060c08484010152601f19601f840116820160c08382030160808401528160c082015260e081019150509695505050505050565b90815260200190565b9182526001600160a01b0316602082015260400190565b93845260ff9290921660208401526040830152606082015260800190565b6020808252600890820152674e6f206d6f6e657960c01b604082015260600190565b602080825260119082015270496e76616c6964207369676e617475726560781b604082015260600190565b60208082526021908201527f5369676e617475726520696e76616c6964206f7220756e617574686f72697a656040820152601960fa1b606082015260800190565b6000808335601e1984360301811261220d578283fd5b83018035915067ffffffffffffffff821115612227578283fd5b60200191503681900382131561223c57600080fd5b9250929050565b60008261225e57634e487b7160e01b81526012600452602481fd5b500490565b600081600019048311821515161561227d5761227d612299565b500290565b60008282101561229457612294612299565b500390565b634e487b7160e01b600052601160045260246000fd5b6001600160a01b03811681146122c457600080fd5b5056fea26469706673582212204d544963f58a467c293a895508e8d68efe851ff78b519b05a6a5aae62f36a55964736f6c63430008000033",
}

// MetaRareOperatorABI is the input ABI used to generate the binding from.
// Deprecated: Use MetaRareOperatorMetaData.ABI instead.
var MetaRareOperatorABI = MetaRareOperatorMetaData.ABI

// Deprecated: Use MetaRareOperatorMetaData.Sigs instead.
// MetaRareOperatorFuncSigs maps the 4-byte function signature to its string representation.
var MetaRareOperatorFuncSigs = MetaRareOperatorMetaData.Sigs

// MetaRareOperatorBin is the compiled bytecode used for deploying new contracts.
// Deprecated: Use MetaRareOperatorMetaData.Bin instead.
var MetaRareOperatorBin = MetaRareOperatorMetaData.Bin

// DeployMetaRareOperator deploys a new Ethereum contract, binding an instance of MetaRareOperator to it.
func DeployMetaRareOperator(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MetaRareOperator, error) {
	parsed, err := MetaRareOperatorMetaData.GetAbi()
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	if parsed == nil {
		return common.Address{}, nil, nil, errors.New("GetABI returned nil")
	}

	address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(MetaRareOperatorBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &MetaRareOperator{MetaRareOperatorCaller: MetaRareOperatorCaller{contract: contract}, MetaRareOperatorTransactor: MetaRareOperatorTransactor{contract: contract}, MetaRareOperatorFilterer: MetaRareOperatorFilterer{contract: contract}}, nil
}

// MetaRareOperator is an auto generated Go binding around an Ethereum contract.
type MetaRareOperator struct {
	MetaRareOperatorCaller     // Read-only binding to the contract
	MetaRareOperatorTransactor // Write-only binding to the contract
	MetaRareOperatorFilterer   // Log filterer for contract events
}

// MetaRareOperatorCaller is an auto generated read-only Go binding around an Ethereum contract.
type MetaRareOperatorCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// MetaRareOperatorTransactor is an auto generated write-only Go binding around an Ethereum contract.
type MetaRareOperatorTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// MetaRareOperatorFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type MetaRareOperatorFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// MetaRareOperatorSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type MetaRareOperatorSession struct {
	Contract     *MetaRareOperator // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// MetaRareOperatorCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type MetaRareOperatorCallerSession struct {
	Contract *MetaRareOperatorCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts           // Call options to use throughout this session
}

// MetaRareOperatorTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type MetaRareOperatorTransactorSession struct {
	Contract     *MetaRareOperatorTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts           // Transaction auth options to use throughout this session
}

// MetaRareOperatorRaw is an auto generated low-level Go binding around an Ethereum contract.
type MetaRareOperatorRaw struct {
	Contract *MetaRareOperator // Generic contract binding to access the raw methods on
}

// MetaRareOperatorCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type MetaRareOperatorCallerRaw struct {
	Contract *MetaRareOperatorCaller // Generic read-only contract binding to access the raw methods on
}

// MetaRareOperatorTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type MetaRareOperatorTransactorRaw struct {
	Contract *MetaRareOperatorTransactor // Generic write-only contract binding to access the raw methods on
}

// NewMetaRareOperator creates a new instance of MetaRareOperator, bound to a specific deployed contract.
func NewMetaRareOperator(address common.Address, backend bind.ContractBackend) (*MetaRareOperator, error) {
	contract, err := bindMetaRareOperator(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &MetaRareOperator{MetaRareOperatorCaller: MetaRareOperatorCaller{contract: contract}, MetaRareOperatorTransactor: MetaRareOperatorTransactor{contract: contract}, MetaRareOperatorFilterer: MetaRareOperatorFilterer{contract: contract}}, nil
}

// NewMetaRareOperatorCaller creates a new read-only instance of MetaRareOperator, bound to a specific deployed contract.
func NewMetaRareOperatorCaller(address common.Address, caller bind.ContractCaller) (*MetaRareOperatorCaller, error) {
	contract, err := bindMetaRareOperator(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &MetaRareOperatorCaller{contract: contract}, nil
}

// NewMetaRareOperatorTransactor creates a new write-only instance of MetaRareOperator, bound to a specific deployed contract.
func NewMetaRareOperatorTransactor(address common.Address, transactor bind.ContractTransactor) (*MetaRareOperatorTransactor, error) {
	contract, err := bindMetaRareOperator(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &MetaRareOperatorTransactor{contract: contract}, nil
}

// NewMetaRareOperatorFilterer creates a new log filterer instance of MetaRareOperator, bound to a specific deployed contract.
func NewMetaRareOperatorFilterer(address common.Address, filterer bind.ContractFilterer) (*MetaRareOperatorFilterer, error) {
	contract, err := bindMetaRareOperator(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &MetaRareOperatorFilterer{contract: contract}, nil
}

// bindMetaRareOperator binds a generic wrapper to an already deployed contract.
func bindMetaRareOperator(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(MetaRareOperatorABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_MetaRareOperator *MetaRareOperatorRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _MetaRareOperator.Contract.MetaRareOperatorCaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_MetaRareOperator *MetaRareOperatorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.MetaRareOperatorTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_MetaRareOperator *MetaRareOperatorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.MetaRareOperatorTransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_MetaRareOperator *MetaRareOperatorCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _MetaRareOperator.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_MetaRareOperator *MetaRareOperatorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_MetaRareOperator *MetaRareOperatorTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.contract.Transact(opts, method, params...)
}

// DEFAULTADMINROLE is a free data retrieval call binding the contract method 0xa217fddf.
//
// Solidity: function DEFAULT_ADMIN_ROLE() view returns(bytes32)
func (_MetaRareOperator *MetaRareOperatorCaller) DEFAULTADMINROLE(opts *bind.CallOpts) ([32]byte, error) {
	var out []interface{}
	err := _MetaRareOperator.contract.Call(opts, &out, "DEFAULT_ADMIN_ROLE")

	if err != nil {
		return *new([32]byte), err
	}

	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)

	return out0, err

}

// DEFAULTADMINROLE is a free data retrieval call binding the contract method 0xa217fddf.
//
// Solidity: function DEFAULT_ADMIN_ROLE() view returns(bytes32)
func (_MetaRareOperator *MetaRareOperatorSession) DEFAULTADMINROLE() ([32]byte, error) {
	return _MetaRareOperator.Contract.DEFAULTADMINROLE(&_MetaRareOperator.CallOpts)
}

// DEFAULTADMINROLE is a free data retrieval call binding the contract method 0xa217fddf.
//
// Solidity: function DEFAULT_ADMIN_ROLE() view returns(bytes32)
func (_MetaRareOperator *MetaRareOperatorCallerSession) DEFAULTADMINROLE() ([32]byte, error) {
	return _MetaRareOperator.Contract.DEFAULTADMINROLE(&_MetaRareOperator.CallOpts)
}

// MINTERROLE is a free data retrieval call binding the contract method 0xd5391393.
//
// Solidity: function MINTER_ROLE() view returns(bytes32)
func (_MetaRareOperator *MetaRareOperatorCaller) MINTERROLE(opts *bind.CallOpts) ([32]byte, error) {
	var out []interface{}
	err := _MetaRareOperator.contract.Call(opts, &out, "MINTER_ROLE")

	if err != nil {
		return *new([32]byte), err
	}

	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)

	return out0, err

}

// MINTERROLE is a free data retrieval call binding the contract method 0xd5391393.
//
// Solidity: function MINTER_ROLE() view returns(bytes32)
func (_MetaRareOperator *MetaRareOperatorSession) MINTERROLE() ([32]byte, error) {
	return _MetaRareOperator.Contract.MINTERROLE(&_MetaRareOperator.CallOpts)
}

// MINTERROLE is a free data retrieval call binding the contract method 0xd5391393.
//
// Solidity: function MINTER_ROLE() view returns(bytes32)
func (_MetaRareOperator *MetaRareOperatorCallerSession) MINTERROLE() ([32]byte, error) {
	return _MetaRareOperator.Contract.MINTERROLE(&_MetaRareOperator.CallOpts)
}

// CreationTaxRate is a free data retrieval call binding the contract method 0x5ac3ac45.
//
// Solidity: function creationTaxRate(address , uint256 ) view returns(uint256)
func (_MetaRareOperator *MetaRareOperatorCaller) CreationTaxRate(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int) (*big.Int, error) {
	var out []interface{}
	err := _MetaRareOperator.contract.Call(opts, &out, "creationTaxRate", arg0, arg1)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// CreationTaxRate is a free data retrieval call binding the contract method 0x5ac3ac45.
//
// Solidity: function creationTaxRate(address , uint256 ) view returns(uint256)
func (_MetaRareOperator *MetaRareOperatorSession) CreationTaxRate(arg0 common.Address, arg1 *big.Int) (*big.Int, error) {
	return _MetaRareOperator.Contract.CreationTaxRate(&_MetaRareOperator.CallOpts, arg0, arg1)
}

// CreationTaxRate is a free data retrieval call binding the contract method 0x5ac3ac45.
//
// Solidity: function creationTaxRate(address , uint256 ) view returns(uint256)
func (_MetaRareOperator *MetaRareOperatorCallerSession) CreationTaxRate(arg0 common.Address, arg1 *big.Int) (*big.Int, error) {
	return _MetaRareOperator.Contract.CreationTaxRate(&_MetaRareOperator.CallOpts, arg0, arg1)
}

// Creators is a free data retrieval call binding the contract method 0xcd53d08e.
//
// Solidity: function creators(uint256 ) view returns(address)
func (_MetaRareOperator *MetaRareOperatorCaller) Creators(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error) {
	var out []interface{}
	err := _MetaRareOperator.contract.Call(opts, &out, "creators", arg0)

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// Creators is a free data retrieval call binding the contract method 0xcd53d08e.
//
// Solidity: function creators(uint256 ) view returns(address)
func (_MetaRareOperator *MetaRareOperatorSession) Creators(arg0 *big.Int) (common.Address, error) {
	return _MetaRareOperator.Contract.Creators(&_MetaRareOperator.CallOpts, arg0)
}

// Creators is a free data retrieval call binding the contract method 0xcd53d08e.
//
// Solidity: function creators(uint256 ) view returns(address)
func (_MetaRareOperator *MetaRareOperatorCallerSession) Creators(arg0 *big.Int) (common.Address, error) {
	return _MetaRareOperator.Contract.Creators(&_MetaRareOperator.CallOpts, arg0)
}

// CreatorsWithinCollection is a free data retrieval call binding the contract method 0x0370a7a2.
//
// Solidity: function creatorsWithinCollection(address , uint256 ) view returns(address)
func (_MetaRareOperator *MetaRareOperatorCaller) CreatorsWithinCollection(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int) (common.Address, error) {
	var out []interface{}
	err := _MetaRareOperator.contract.Call(opts, &out, "creatorsWithinCollection", arg0, arg1)

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// CreatorsWithinCollection is a free data retrieval call binding the contract method 0x0370a7a2.
//
// Solidity: function creatorsWithinCollection(address , uint256 ) view returns(address)
func (_MetaRareOperator *MetaRareOperatorSession) CreatorsWithinCollection(arg0 common.Address, arg1 *big.Int) (common.Address, error) {
	return _MetaRareOperator.Contract.CreatorsWithinCollection(&_MetaRareOperator.CallOpts, arg0, arg1)
}

// CreatorsWithinCollection is a free data retrieval call binding the contract method 0x0370a7a2.
//
// Solidity: function creatorsWithinCollection(address , uint256 ) view returns(address)
func (_MetaRareOperator *MetaRareOperatorCallerSession) CreatorsWithinCollection(arg0 common.Address, arg1 *big.Int) (common.Address, error) {
	return _MetaRareOperator.Contract.CreatorsWithinCollection(&_MetaRareOperator.CallOpts, arg0, arg1)
}

// RecoverAddress is a free data retrieval call binding the contract method 0x8428cf83.
//
// Solidity: function recoverAddress(bytes32 msgHash, uint8 v, bytes32 r, bytes32 s) pure returns(address)
func (_MetaRareOperator *MetaRareOperatorCaller) RecoverAddress(opts *bind.CallOpts, msgHash [32]byte, v uint8, r [32]byte, s [32]byte) (common.Address, error) {
	var out []interface{}
	err := _MetaRareOperator.contract.Call(opts, &out, "recoverAddress", msgHash, v, r, s)

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// RecoverAddress is a free data retrieval call binding the contract method 0x8428cf83.
//
// Solidity: function recoverAddress(bytes32 msgHash, uint8 v, bytes32 r, bytes32 s) pure returns(address)
func (_MetaRareOperator *MetaRareOperatorSession) RecoverAddress(msgHash [32]byte, v uint8, r [32]byte, s [32]byte) (common.Address, error) {
	return _MetaRareOperator.Contract.RecoverAddress(&_MetaRareOperator.CallOpts, msgHash, v, r, s)
}

// RecoverAddress is a free data retrieval call binding the contract method 0x8428cf83.
//
// Solidity: function recoverAddress(bytes32 msgHash, uint8 v, bytes32 r, bytes32 s) pure returns(address)
func (_MetaRareOperator *MetaRareOperatorCallerSession) RecoverAddress(msgHash [32]byte, v uint8, r [32]byte, s [32]byte) (common.Address, error) {
	return _MetaRareOperator.Contract.RecoverAddress(&_MetaRareOperator.CallOpts, msgHash, v, r, s)
}

// ExcuteMintingOrderWithERC1155Collection is a paid mutator transaction binding the contract method 0xb2381e3d.
//
// Solidity: function excuteMintingOrderWithERC1155Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorTransactor) ExcuteMintingOrderWithERC1155Collection(opts *bind.TransactOpts, voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.contract.Transact(opts, "excuteMintingOrderWithERC1155Collection", voucher, hash, v, r, s)
}

// ExcuteMintingOrderWithERC1155Collection is a paid mutator transaction binding the contract method 0xb2381e3d.
//
// Solidity: function excuteMintingOrderWithERC1155Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorSession) ExcuteMintingOrderWithERC1155Collection(voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.ExcuteMintingOrderWithERC1155Collection(&_MetaRareOperator.TransactOpts, voucher, hash, v, r, s)
}

// ExcuteMintingOrderWithERC1155Collection is a paid mutator transaction binding the contract method 0xb2381e3d.
//
// Solidity: function excuteMintingOrderWithERC1155Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorTransactorSession) ExcuteMintingOrderWithERC1155Collection(voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.ExcuteMintingOrderWithERC1155Collection(&_MetaRareOperator.TransactOpts, voucher, hash, v, r, s)
}

// ExcuteMintingOrderWithERC1155MetaRareCollection is a paid mutator transaction binding the contract method 0x33bd3379.
//
// Solidity: function excuteMintingOrderWithERC1155MetaRareCollection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorTransactor) ExcuteMintingOrderWithERC1155MetaRareCollection(opts *bind.TransactOpts, voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.contract.Transact(opts, "excuteMintingOrderWithERC1155MetaRareCollection", voucher, hash, v, r, s)
}

// ExcuteMintingOrderWithERC1155MetaRareCollection is a paid mutator transaction binding the contract method 0x33bd3379.
//
// Solidity: function excuteMintingOrderWithERC1155MetaRareCollection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorSession) ExcuteMintingOrderWithERC1155MetaRareCollection(voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.ExcuteMintingOrderWithERC1155MetaRareCollection(&_MetaRareOperator.TransactOpts, voucher, hash, v, r, s)
}

// ExcuteMintingOrderWithERC1155MetaRareCollection is a paid mutator transaction binding the contract method 0x33bd3379.
//
// Solidity: function excuteMintingOrderWithERC1155MetaRareCollection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorTransactorSession) ExcuteMintingOrderWithERC1155MetaRareCollection(voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.ExcuteMintingOrderWithERC1155MetaRareCollection(&_MetaRareOperator.TransactOpts, voucher, hash, v, r, s)
}

// ExcuteMintingOrderWithERC721Collection is a paid mutator transaction binding the contract method 0x6104c09b.
//
// Solidity: function excuteMintingOrderWithERC721Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorTransactor) ExcuteMintingOrderWithERC721Collection(opts *bind.TransactOpts, voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.contract.Transact(opts, "excuteMintingOrderWithERC721Collection", voucher, hash, v, r, s)
}

// ExcuteMintingOrderWithERC721Collection is a paid mutator transaction binding the contract method 0x6104c09b.
//
// Solidity: function excuteMintingOrderWithERC721Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorSession) ExcuteMintingOrderWithERC721Collection(voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.ExcuteMintingOrderWithERC721Collection(&_MetaRareOperator.TransactOpts, voucher, hash, v, r, s)
}

// ExcuteMintingOrderWithERC721Collection is a paid mutator transaction binding the contract method 0x6104c09b.
//
// Solidity: function excuteMintingOrderWithERC721Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorTransactorSession) ExcuteMintingOrderWithERC721Collection(voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.ExcuteMintingOrderWithERC721Collection(&_MetaRareOperator.TransactOpts, voucher, hash, v, r, s)
}

// ExcuteMintingOrderWithERC721MetaRareCollection is a paid mutator transaction binding the contract method 0x1f247a2f.
//
// Solidity: function excuteMintingOrderWithERC721MetaRareCollection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorTransactor) ExcuteMintingOrderWithERC721MetaRareCollection(opts *bind.TransactOpts, voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.contract.Transact(opts, "excuteMintingOrderWithERC721MetaRareCollection", voucher, hash, v, r, s)
}

// ExcuteMintingOrderWithERC721MetaRareCollection is a paid mutator transaction binding the contract method 0x1f247a2f.
//
// Solidity: function excuteMintingOrderWithERC721MetaRareCollection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorSession) ExcuteMintingOrderWithERC721MetaRareCollection(voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.ExcuteMintingOrderWithERC721MetaRareCollection(&_MetaRareOperator.TransactOpts, voucher, hash, v, r, s)
}

// ExcuteMintingOrderWithERC721MetaRareCollection is a paid mutator transaction binding the contract method 0x1f247a2f.
//
// Solidity: function excuteMintingOrderWithERC721MetaRareCollection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorTransactorSession) ExcuteMintingOrderWithERC721MetaRareCollection(voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.ExcuteMintingOrderWithERC721MetaRareCollection(&_MetaRareOperator.TransactOpts, voucher, hash, v, r, s)
}

// ExcuteTransferOrderWithERC1155Collection is a paid mutator transaction binding the contract method 0x03b5b423.
//
// Solidity: function excuteTransferOrderWithERC1155Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorTransactor) ExcuteTransferOrderWithERC1155Collection(opts *bind.TransactOpts, voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.contract.Transact(opts, "excuteTransferOrderWithERC1155Collection", voucher, hash, v, r, s)
}

// ExcuteTransferOrderWithERC1155Collection is a paid mutator transaction binding the contract method 0x03b5b423.
//
// Solidity: function excuteTransferOrderWithERC1155Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorSession) ExcuteTransferOrderWithERC1155Collection(voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.ExcuteTransferOrderWithERC1155Collection(&_MetaRareOperator.TransactOpts, voucher, hash, v, r, s)
}

// ExcuteTransferOrderWithERC1155Collection is a paid mutator transaction binding the contract method 0x03b5b423.
//
// Solidity: function excuteTransferOrderWithERC1155Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorTransactorSession) ExcuteTransferOrderWithERC1155Collection(voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.ExcuteTransferOrderWithERC1155Collection(&_MetaRareOperator.TransactOpts, voucher, hash, v, r, s)
}

// ExcuteTransferOrderWithERC721Collection is a paid mutator transaction binding the contract method 0xec938286.
//
// Solidity: function excuteTransferOrderWithERC721Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorTransactor) ExcuteTransferOrderWithERC721Collection(opts *bind.TransactOpts, voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.contract.Transact(opts, "excuteTransferOrderWithERC721Collection", voucher, hash, v, r, s)
}

// ExcuteTransferOrderWithERC721Collection is a paid mutator transaction binding the contract method 0xec938286.
//
// Solidity: function excuteTransferOrderWithERC721Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorSession) ExcuteTransferOrderWithERC721Collection(voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.ExcuteTransferOrderWithERC721Collection(&_MetaRareOperator.TransactOpts, voucher, hash, v, r, s)
}

// ExcuteTransferOrderWithERC721Collection is a paid mutator transaction binding the contract method 0xec938286.
//
// Solidity: function excuteTransferOrderWithERC721Collection((address,address,uint256,uint256,address,uint256,uint256,uint256,uint256,uint256,address,string) voucher, bytes32 hash, uint8 v, bytes32 r, bytes32 s) payable returns()
func (_MetaRareOperator *MetaRareOperatorTransactorSession) ExcuteTransferOrderWithERC721Collection(voucher MetaRareOperatorNFTVoucher, hash [32]byte, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) {
	return _MetaRareOperator.Contract.ExcuteTransferOrderWithERC721Collection(&_MetaRareOperator.TransactOpts, voucher, hash, v, r, s)
}

// SafeMathMetaData contains all meta data concerning the SafeMath contract.
var SafeMathMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212204173583db44453e2ec033090065c8f937218a7a4d9cd71e88b72d5f40c689bfd64736f6c63430008000033",
}

// SafeMathABI is the input ABI used to generate the binding from.
// Deprecated: Use SafeMathMetaData.ABI instead.
var SafeMathABI = SafeMathMetaData.ABI

// SafeMathBin is the compiled bytecode used for deploying new contracts.
// Deprecated: Use SafeMathMetaData.Bin instead.
var SafeMathBin = SafeMathMetaData.Bin

// DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it.
func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error) {
	parsed, err := SafeMathMetaData.GetAbi()
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	if parsed == nil {
		return common.Address{}, nil, nil, errors.New("GetABI returned nil")
	}

	address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(SafeMathBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil
}

// SafeMath is an auto generated Go binding around an Ethereum contract.
type SafeMath struct {
	SafeMathCaller     // Read-only binding to the contract
	SafeMathTransactor // Write-only binding to the contract
	SafeMathFilterer   // Log filterer for contract events
}

// SafeMathCaller is an auto generated read-only Go binding around an Ethereum contract.
type SafeMathCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// SafeMathTransactor is an auto generated write-only Go binding around an Ethereum contract.
type SafeMathTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// SafeMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type SafeMathFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// SafeMathSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type SafeMathSession struct {
	Contract     *SafeMath         // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// SafeMathCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type SafeMathCallerSession struct {
	Contract *SafeMathCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts   // Call options to use throughout this session
}

// SafeMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type SafeMathTransactorSession struct {
	Contract     *SafeMathTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
}

// SafeMathRaw is an auto generated low-level Go binding around an Ethereum contract.
type SafeMathRaw struct {
	Contract *SafeMath // Generic contract binding to access the raw methods on
}

// SafeMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type SafeMathCallerRaw struct {
	Contract *SafeMathCaller // Generic read-only contract binding to access the raw methods on
}

// SafeMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type SafeMathTransactorRaw struct {
	Contract *SafeMathTransactor // Generic write-only contract binding to access the raw methods on
}

// NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract.
func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error) {
	contract, err := bindSafeMath(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil
}

// NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract.
func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error) {
	contract, err := bindSafeMath(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &SafeMathCaller{contract: contract}, nil
}

// NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract.
func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error) {
	contract, err := bindSafeMath(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &SafeMathTransactor{contract: contract}, nil
}

// NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract.
func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error) {
	contract, err := bindSafeMath(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &SafeMathFilterer{contract: contract}, nil
}

// bindSafeMath binds a generic wrapper to an already deployed contract.
func bindSafeMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(SafeMathABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _SafeMath.Contract.SafeMathCaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SafeMath.Contract.SafeMathTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _SafeMath.Contract.SafeMathTransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _SafeMath.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _SafeMath.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_SafeMath *SafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _SafeMath.Contract.contract.Transact(opts, method, params...)
}

// StringsMetaData contains all meta data concerning the Strings contract.
var StringsMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212207edb8077e74c13cedbc2fb5fd5736eee7e0684a72011c3cf1afca22ef41419e364736f6c63430008000033",
}

// StringsABI is the input ABI used to generate the binding from.
// Deprecated: Use StringsMetaData.ABI instead.
var StringsABI = StringsMetaData.ABI

// StringsBin is the compiled bytecode used for deploying new contracts.
// Deprecated: Use StringsMetaData.Bin instead.
var StringsBin = StringsMetaData.Bin

// DeployStrings deploys a new Ethereum contract, binding an instance of Strings to it.
func DeployStrings(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Strings, error) {
	parsed, err := StringsMetaData.GetAbi()
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	if parsed == nil {
		return common.Address{}, nil, nil, errors.New("GetABI returned nil")
	}

	address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(StringsBin), backend)
	if err != nil {
		return common.Address{}, nil, nil, err
	}
	return address, tx, &Strings{StringsCaller: StringsCaller{contract: contract}, StringsTransactor: StringsTransactor{contract: contract}, StringsFilterer: StringsFilterer{contract: contract}}, nil
}

// Strings is an auto generated Go binding around an Ethereum contract.
type Strings struct {
	StringsCaller     // Read-only binding to the contract
	StringsTransactor // Write-only binding to the contract
	StringsFilterer   // Log filterer for contract events
}

// StringsCaller is an auto generated read-only Go binding around an Ethereum contract.
type StringsCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// StringsTransactor is an auto generated write-only Go binding around an Ethereum contract.
type StringsTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// StringsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type StringsFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// StringsSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type StringsSession struct {
	Contract     *Strings          // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

// StringsCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type StringsCallerSession struct {
	Contract *StringsCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts  // Call options to use throughout this session
}

// StringsTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type StringsTransactorSession struct {
	Contract     *StringsTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
}

// StringsRaw is an auto generated low-level Go binding around an Ethereum contract.
type StringsRaw struct {
	Contract *Strings // Generic contract binding to access the raw methods on
}

// StringsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type StringsCallerRaw struct {
	Contract *StringsCaller // Generic read-only contract binding to access the raw methods on
}

// StringsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type StringsTransactorRaw struct {
	Contract *StringsTransactor // Generic write-only contract binding to access the raw methods on
}

// NewStrings creates a new instance of Strings, bound to a specific deployed contract.
func NewStrings(address common.Address, backend bind.ContractBackend) (*Strings, error) {
	contract, err := bindStrings(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &Strings{StringsCaller: StringsCaller{contract: contract}, StringsTransactor: StringsTransactor{contract: contract}, StringsFilterer: StringsFilterer{contract: contract}}, nil
}

// NewStringsCaller creates a new read-only instance of Strings, bound to a specific deployed contract.
func NewStringsCaller(address common.Address, caller bind.ContractCaller) (*StringsCaller, error) {
	contract, err := bindStrings(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &StringsCaller{contract: contract}, nil
}

// NewStringsTransactor creates a new write-only instance of Strings, bound to a specific deployed contract.
func NewStringsTransactor(address common.Address, transactor bind.ContractTransactor) (*StringsTransactor, error) {
	contract, err := bindStrings(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &StringsTransactor{contract: contract}, nil
}

// NewStringsFilterer creates a new log filterer instance of Strings, bound to a specific deployed contract.
func NewStringsFilterer(address common.Address, filterer bind.ContractFilterer) (*StringsFilterer, error) {
	contract, err := bindStrings(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &StringsFilterer{contract: contract}, nil
}

// bindStrings binds a generic wrapper to an already deployed contract.
func bindStrings(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(StringsABI))
	if err != nil {
		return nil, err
	}
	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_Strings *StringsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _Strings.Contract.StringsCaller.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_Strings *StringsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Strings.Contract.StringsTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_Strings *StringsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _Strings.Contract.StringsTransactor.contract.Transact(opts, method, params...)
}

// Call invokes the (constant) contract method with params as input values and
// sets the output to result. The result type might be a single field for simple
// returns, a slice of interfaces for anonymous returns and a struct for named
// returns.
func (_Strings *StringsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _Strings.Contract.contract.Call(opts, result, method, params...)
}

// Transfer initiates a plain transaction to move funds to the contract, calling
// its default method if one is available.
func (_Strings *StringsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _Strings.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_Strings *StringsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _Strings.Contract.contract.Transact(opts, method, params...)
}