collection

type AgentBox struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type AgentBoxBSONPacker struct {
	CL extensioncurrency.ContractID `bson:"collection"`
	AG []base.Address               `bson:"agents"`
}

type AgentBoxBSONUnpacker struct {
	CL string                `bson:"collection"`
	AG []base.AddressDecoder `bson:"agents"`
}

type AgentBoxJSONPacker struct {
	jsonenc.HintedHead
	CL extensioncurrency.ContractID `json:"collection"`
	AG []base.Address               `json:"agents"`
}

type AgentBoxJSONUnpacker struct {
	CL string                `json:"collection"`
	AG []base.AddressDecoder `json:"agents"`
}

type Approve struct {
	currency.BaseOperation
}

type ApproveFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type ApproveFactBSONUnpacker struct {
	H  valuehash.Bytes     `bson:"hash"`
	TK []byte              `bson:"token"`
	SD base.AddressDecoder `bson:"sender"`
	IT bson.Raw            `bson:"items"`
}

type ApproveFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash `json:"hash"`
	TK []byte         `json:"token"`
	SD base.Address   `json:"sender"`
	IT []ApproveItem  `json:"items"`
}

type ApproveFactJSONUnpacker struct {
	H  valuehash.Bytes     `json:"hash"`
	TK []byte              `json:"token"`
	SD base.AddressDecoder `json:"sender"`
	IT json.RawMessage     `json:"items"`
}

type ApproveItem struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type ApproveItemBSONUnpacker struct {
	AP base.AddressDecoder `bson:"approved"`
	NF bson.Raw            `bson:"nft"`
	CR string              `bson:"currency"`
}

type ApproveItemJSONPacker struct {
	jsonenc.HintedHead
	AP base.Address        `json:"approved"`
	NF nft.NFTID           `json:"nft"`
	CR currency.CurrencyID `json:"currency"`
}

type ApproveItemJSONUnpacker struct {
	AP base.AddressDecoder `json:"approved"`
	NF json.RawMessage     `json:"nft"`
	CR string              `json:"currency"`
}

type ApproveItemProcessor struct {
	// contains filtered or unexported fields
}

type ApproveProcessor struct {
	Approve
	// contains filtered or unexported fields
}

type Burn struct {
	currency.BaseOperation
}

type BurnFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type BurnFactBSONUnpacker struct {
	H  valuehash.Bytes     `bson:"hash"`
	TK []byte              `bson:"token"`
	SD base.AddressDecoder `bson:"sender"`
	IT bson.Raw            `bson:"items"`
}

type BurnFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash `json:"hash"`
	TK []byte         `json:"token"`
	SD base.Address   `json:"sender"`
	IT []BurnItem     `json:"items"`
}

type BurnFactJSONUnpacker struct {
	H  valuehash.Bytes     `json:"hash"`
	TK []byte              `json:"token"`
	SD base.AddressDecoder `json:"sender"`
	IT json.RawMessage     `json:"items"`
}

type BurnItem struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type BurnItemBSONUnpacker struct {
	NF bson.Raw `bson:"nft"`
	CR string   `bson:"currency"`
}

type BurnItemJSONPacker struct {
	jsonenc.HintedHead
	NF nft.NFTID           `json:"nft"`
	CR currency.CurrencyID `json:"currency"`
}

type BurnItemJSONUnpacker struct {
	NF json.RawMessage `json:"nft"`
	CR string          `json:"currency"`
}

type BurnItemProcessor struct {
	// contains filtered or unexported fields
}

type BurnProcessor struct {
	Burn
	// contains filtered or unexported fields
}

type CollectionName string

type CollectionPolicy struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type CollectionPolicyJSONPacker struct {
	jsonenc.HintedHead
	NM CollectionName       `json:"name"`
	RY nft.PaymentParameter `json:"royalty"`
	UR nft.URI              `json:"uri"`
	WH []base.Address       `json:"whites"`
}

type CollectionPolicyJSONUnpacker struct {
	NM string                `json:"name"`
	RY uint                  `json:"royalty"`
	UR string                `json:"uri"`
	WH []base.AddressDecoder `json:"whites"`
}

type CollectionPolicyUpdater struct {
	currency.BaseOperation
}

type CollectionPolicyUpdaterFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type CollectionPolicyUpdaterFactBSONUnpacker struct {
	H  valuehash.Bytes     `bson:"hash"`
	TK []byte              `bson:"token"`
	SD base.AddressDecoder `bson:"sender"`
	CL string              `bson:"collection"`
	PO bson.Raw            `bson:"policy"`
	CR string              `bson:"currency"`
}

type CollectionPolicyUpdaterFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash               `json:"hash"`
	TK []byte                       `json:"token"`
	SD base.Address                 `json:"sender"`
	CL extensioncurrency.ContractID `json:"collection"`
	PO CollectionPolicy             `json:"policy"`
	CR currency.CurrencyID          `json:"currency"`
}

type CollectionPolicyUpdaterFactJSONUnpacker struct {
	H  valuehash.Bytes     `json:"hash"`
	TK []byte              `json:"token"`
	SD base.AddressDecoder `json:"sender"`
	CL string              `json:"collection"`
	PO json.RawMessage     `json:"policy"`
	CR string              `json:"currency"`
}

type CollectionPolicyUpdaterProcessor struct {
	CollectionPolicyUpdater
	// contains filtered or unexported fields
}

type CollectionRegister struct {
	currency.BaseOperation
}

type CollectionRegisterFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type CollectionRegisterFactBSONUnpacker struct {
	H  valuehash.Bytes     `bson:"hash"`
	TK []byte              `bson:"token"`
	SD base.AddressDecoder `bson:"sender"`
	FO bson.Raw            `bson:"form"`
	CR string              `bson:"currency"`
}

type CollectionRegisterFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash         `json:"hash"`
	TK []byte                 `json:"token"`
	SD base.Address           `json:"sender"`
	FO CollectionRegisterForm `json:"form"`
	CR currency.CurrencyID    `json:"currency"`
}

type CollectionRegisterFactJSONUnpacker struct {
	H  valuehash.Bytes     `json:"hash"`
	TK []byte              `json:"token"`
	SD base.AddressDecoder `json:"sender"`
	FO json.RawMessage     `json:"form"`
	CR string              `json:"currency"`
}

type CollectionRegisterForm struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type CollectionRegisterFormBSONUnpacker struct {
	TG base.AddressDecoder   `bson:"target"`
	SB string                `bson:"symbol"`
	NM string                `bson:"name"`
	RY uint                  `bson:"royalty"`
	UR string                `bson:"uri"`
	WH []base.AddressDecoder `bson:"whites"`
}

type CollectionRegisterFormJSONPacker struct {
	jsonenc.HintedHead
	TG base.Address                 `json:"target"`
	SB extensioncurrency.ContractID `json:"symbol"`
	NM CollectionName               `json:"name"`
	RY nft.PaymentParameter         `json:"royalty"`
	UR nft.URI                      `json:"uri"`
	WH []base.Address               `json:"whites"`
}

type CollectionRegisterFormJSONUnpacker struct {
	TG base.AddressDecoder   `json:"target"`
	SB string                `json:"symbol"`
	NM string                `json:"name"`
	RY uint                  `json:"royalty"`
	UR string                `json:"uri"`
	WH []base.AddressDecoder `json:"whites"`
}

type CollectionRegisterProcessor struct {
	CollectionRegister

	DesignState state.State
	// contains filtered or unexported fields
}

type Delegate struct {
	currency.BaseOperation
}

type DelegateFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type DelegateFactBSONUnpacker struct {
	H  valuehash.Bytes     `bson:"hash"`
	TK []byte              `bson:"token"`
	SD base.AddressDecoder `bson:"sender"`
	IT bson.Raw            `bson:"items"`
}

type DelegateFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash `json:"hash"`
	TK []byte         `json:"token"`
	SD base.Address   `json:"sender"`
	IT []DelegateItem `json:"items"`
}

type DelegateFactJSONUnpacker struct {
	H  valuehash.Bytes     `json:"hash"`
	TK []byte              `json:"token"`
	SD base.AddressDecoder `json:"sender"`
	IT json.RawMessage     `json:"items"`
}

type DelegateItem struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type DelegateItemBSONUnpacker struct {
	CL string              `bson:"collection"`
	AG base.AddressDecoder `bson:"agent"`
	MD string              `bson:"mode"`
	CR string              `bson:"currency"`
}

type DelegateItemJSONPacker struct {
	jsonenc.HintedHead
	CL extensioncurrency.ContractID `json:"collection"`
	AG base.Address                 `json:"agent"`
	MD DelegateMode                 `json:"mode"`
	CR currency.CurrencyID          `json:"currency"`
}

type DelegateItemJSONUnpacker struct {
	CL string              `json:"collection"`
	AG base.AddressDecoder `json:"agent"`
	MD string              `json:"mode"`
	CR string              `json:"currency"`
}

type DelegateItemProcessor struct {
	// contains filtered or unexported fields
}

type DelegateMode string

type DelegateProcessor struct {
	Delegate
	// contains filtered or unexported fields
}

type DuplicationType string

type Mint struct {
	currency.BaseOperation
}

type MintFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type MintFactBSONUnpacker struct {
	H  valuehash.Bytes     `bson:"hash"`
	TK []byte              `bson:"token"`
	SD base.AddressDecoder `bson:"sender"`
	IT bson.Raw            `bson:"items"`
}

type MintFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash `json:"hash"`
	TK []byte         `json:"token"`
	SD base.Address   `json:"sender"`
	IT []MintItem     `json:"items"`
}

type MintFactJSONUnpacker struct {
	H  valuehash.Bytes     `json:"hash"`
	TK []byte              `json:"token"`
	SD base.AddressDecoder `json:"sender"`
	IT json.RawMessage     `json:"items"`
}

type MintForm struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type MintFormBSONUnpacker struct {
	HS string   `bson:"hash"`
	UR string   `bson:"uri"`
	CR bson.Raw `bson:"creators"`
	CP bson.Raw `bson:"copyrighters"`
}

type MintFormJSONPacker struct {
	jsonenc.HintedHead
	HS nft.NFTHash `json:"hash"`
	UR nft.URI     `json:"uri"`
	CR nft.Signers `json:"creators"`
	CP nft.Signers `json:"copyrighters"`
}

type MintFormJSONUnpacker struct {
	HS string          `json:"hash"`
	UR string          `json:"uri"`
	CR json.RawMessage `json:"creators"`
	CP json.RawMessage `json:"copyrighters"`
}

type MintItem struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type MintItemBSONUnpacker struct {
	CL string   `bson:"collection"`
	FO bson.Raw `bson:"form"`
	CR string   `bson:"currency"`
}

type MintItemJSONPacker struct {
	jsonenc.HintedHead
	CL extensioncurrency.ContractID `json:"collection"`
	FO MintForm                     `json:"form"`
	CR currency.CurrencyID          `json:"currency"`
}

type MintItemJSONUnpacker struct {
	CL string          `json:"collection"`
	FO json.RawMessage `json:"form"`
	CR string          `json:"currency"`
}

type MintItemProcessor struct {
	// contains filtered or unexported fields
}

type MintProcessor struct {
	Mint
	// contains filtered or unexported fields
}

type NFTBox struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type NFTBoxBSONPacker struct {
	AG []nft.NFTID `bson:"nfts"`
}

type NFTBoxBSONUnpacker struct {
	NS bson.Raw `bson:"nfts"`
}

type NFTBoxJSONPacker struct {
	jsonenc.HintedHead
	NS []nft.NFTID `json:"nfts"`
}

type NFTBoxJSONUnpacker struct {
	NS json.RawMessage `json:"nfts"`
}

type OperationProcessor struct {
	sync.RWMutex
	*logging.Logging
	// contains filtered or unexported fields
}

type PolicyBSONUnpacker struct {
	NM string                `bson:"name"`
	RY uint                  `bson:"royalty"`
	UR string                `bson:"uri"`
	WH []base.AddressDecoder `bson:"whites"`
}

type Qualification string

type Sign struct {
	currency.BaseOperation
}

type SignFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type SignFactBSONUnpacker struct {
	H  valuehash.Bytes     `bson:"hash"`
	TK []byte              `bson:"token"`
	SD base.AddressDecoder `bson:"sender"`
	IT bson.Raw            `bson:"items"`
}

type SignFactJSONPacker struct {
	jsonenc.HintedHead
	H  valuehash.Hash `json:"hash"`
	TK []byte         `json:"token"`
	SD base.Address   `json:"sender"`
	IT []SignItem     `json:"items"`
}

type SignFactJSONUnpacker struct {
	H  valuehash.Bytes     `json:"hash"`
	TK []byte              `json:"token"`
	SD base.AddressDecoder `json:"sender"`
	IT json.RawMessage     `json:"items"`
}

type SignItem struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type SignItemBSONUnpacker struct {
	QU string   `bson:"qualification"`
	NF bson.Raw `bson:"nft"`
	CR string   `bson:"currency"`
}

type SignItemJSONPacker struct {
	jsonenc.HintedHead
	QU Qualification       `json:"qualification"`
	NF nft.NFTID           `json:"nft"`
	CR currency.CurrencyID `json:"currency"`
}

type SignItemJSONUnpacker struct {
	QU string          `json:"qualification"`
	NF json.RawMessage `json:"nft"`
	CR string          `json:"currency"`
}

type SignItemProcessor struct {
	// contains filtered or unexported fields
}

type SignProcessor struct {
	Sign
	// contains filtered or unexported fields
}

type Transfer struct {
	currency.BaseOperation
}

type TransferFact struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}