destiny2

type ActivityChallenge struct {
	// ObjectiveHash is the hash of a related ObjectiveEntity.
	ObjectiveHash uint32
	// DummyRewards are the rewards for this challenge as shown in the UI.
	DummyRewards []ItemQuantity
}

type ActivityDefinition map[uint32]ActivityEntity

type ActivityDifficultyTier int32

type ActivityEntity struct {
	// DisplayProperties are the post-processed display properties for this activity.
	DisplayProperties DisplayProperties
	// OriginalDisplayProperties are the unprocessed display properties for this activity.
	OriginalDisplayProperties DisplayProperties
	// SelectionScreenDisplayProperties are the display properties shown in the selection screen for this activity.
	SelectionScreenDisplayProperties DisplayProperties
	// ReleaseIcon is an icon associated with this activity for a specific content release.
	ReleaseIcon string
	// ReleaseTime is when this activity is visible, in seconds.
	ReleaseTime int32
	// ActivityLightLevel is the recommended light level for this activity.
	ActivityLightLevel int32
	// DestinationHash is the hash for a related DestinationEntity.
	DestinationHash uint32
	// PlaceHash is the hash for a related PlaceEntity.
	PlaceHash uint32
	// ActivityTypeHash is the hash for related ActivityTypeEntity.
	ActivityTypeHash uint32
	// Tier is the difficulty of this activity.
	Tier ActivityDifficultyTier
	// PGCRImage is the image that shows the Post-Game Carnage Report for this activity.
	PgcrImage string
	// Rewards are the possible rewards for this activity.
	Rewards []ActivityReward
	// Modifiers are the modifiers that can be applied to this activity.
	Modifiers []ActivityModifierReference
	// IsPlaylist determines if this activity is in a activity mode's playlist.
	IsPlaylist bool
	// Challenges are the challenges applied to this activity.
	Challenges []ActivityChallenge
	// OptionalUnlockStrings are the statuses related to this activity.
	OptionalUnlockStrings []ActivityUnlockString
	// PlaylistItems represent all the this activity in this playlist activity.
	PlaylistItems []ActivityPlaylistItem
	// ActivityGraphList are the maps to show in the director during this activity.
	ActivityGraphList []ActivityGraphListEntry
	// Matchmaking describes how many people can join an activity and if matchmaking is enabled.
	Matchmaking ActivityMatchmakingBlock
	// GuidedGame provides information about the guided game experience for this activity.
	GuidedGame ActivityGuidedBlock
	// DirectActivityModeHash is the hash of a related ActivityModeEntity.
	DirectActivityModeHash uint32
	// DirectActivityModeType is the mode of this activity.
	DirectActivityModeType ActivityModeType
	// Loadouts are all the possible loadout requirements that could be active for this activity.
	Loadouts []ActivityLoadoutRequirementSet
	// ActivityModeHashes are all ActivityModeEntity structs related to this activity.
	ActivityModeHashes []uint32
	// ActivityModeTypes are all modes related to this activity.
	ActivityModeTypes []ActivityModeType
	// IsPvP determines if this activity is PVP-related.
	IsPvP bool
	// InsertionPoints is a list of phases or points of entry into this activity.
	InsertionPoints []ActivityInsertionPoint
	// ActivityLocationMappings are list of locations affected by this activity.
	ActivityLocationMappings []EnvironmentLocationMapping
	EntityMetadata
}

type ActivityGraphArtElement struct {
	// Position is the position on the map of this art element.
	Position Position
}

type ActivityGraphConnection struct {
	// SourceNodeHash is the hash of the source node.
	SourceNodeHash uint32
	// DestNodeHash is the hash of the destination node.
	DestNodeHash uint32
}

type ActivityGraphDefinition map[uint32]ActivityGraphEntity

type ActivityGraphDisplayObjective struct {
	// ID is the identifier of this objective in the UI.
	Id uint32
	// ObjectiveHash is the hash of a related ObjectiveEntity.
	ObjectiveHash uint32
}

type ActivityGraphDisplayProgression struct {
	// ID is the identifier of this progression in the UI.
	Id uint32
	// ProgressionHash is the hash of a related ProgressionEntity.
	ProgressionHash uint32
}

type ActivityGraphEntity struct {
	// Nodes are the visual nodes on this map's view which correspond to activities that can be clicked on.
	Nodes []ActivityGraphNode
	// ArtElements are special UI elements that appear on this map.
	ArtElements []ActivityGraphArtElement
	// Connections represent connections between Nodes.
	Connections []ActivityGraphConnection
	// DisplayObjectives are objectives that can be displayed on this map.
	DisplayObjectives []ActivityGraphDisplayObjective
	// DisplayProgressions are progressions that can be displayed on this map.
	DisplayProgressions []ActivityGraphDisplayProgression
	// LinkedGraphs links this Activity Graph to others.
	LinkedGraphs []LinkedGraph
	EntityMetadata
}

type ActivityGraphListEntry struct {
	// ActivityGraphHash is the hash of a related ActivityGraphEntity.
	ActivityGraphHash uint32
}

type ActivityGraphNode struct {
	// NodeID is a unique identifier for this node within its parent activity graph.
	NodeId uint32
	// OverrideDisplay is a display property that override the active activity's display properties.
	OverrideDisplay DisplayProperties
	// Position is the position on the map for this node.
	Position Position
	// FeaturingStates are a list of possible styles that this node can have.
	FeaturingStates []ActivityGraphNodeFeaturingState
	// Activities are a list possibly active activities for this node.
	Activities []ActivityGraphNodeActivity
	// States are the possible states that this node can be in.
	States []ActivityGraphNodeStateEntry
}

type ActivityGraphNodeActivity struct {
	// NodeActivityID is an identifier for this activity within the activity graph.
	NodeActivityId uint32
	// ActivityHash is the hash for a related ActivityEntity.
	ActivityHash uint32
}

type ActivityGraphNodeFeaturingState struct {
	// HighlightType is a classification of different ways this node feature can be highlighted.
	HighlightType ActivityGraphNodeHighlightType
}

type ActivityGraphNodeHighlightType int32

type ActivityGraphNodeStateEntry struct {
	State GraphNodeState
}

type ActivityGuidedBlock struct {
	// GuidedMaxLobbySize is the maximum amount of players allowed in the waiting lobby.
	GuidedMaxLobbySize int32
	// GuidedMinLobbySize is the minimum amount of players allowed in the waiting lobby.
	GuidedMinLobbySize int32
	// GuidedDisbandCount is the total number of votes needed for the guided group to disband.
	GuidedDisbandCount int32
}

type ActivityInsertionPoint struct {
	// PhaseHash is the unique hash representing the phase.
	PhaseHash uint32
}

type ActivityLoadout struct {
	// EquipmentSlotHash is the hash of a related EquipmentSlotEntity.
	EquipmentSlotHash uint32
	// AllowedEquippedItemHashes are a list of all related InventoryItemEntity structs.
	AllowedEquippedItemHashes []uint32
	// AllowedWeaponSubTypes are a list of all allowed weapon subtypes in activity loadouts.
	AllowedWeaponSubTypes []ItemSubType
}

type ActivityLoadoutRequirementSet struct {
	// Requirements are the set of requirements that will be applied on the activity if this set is active.
	Requirements []ActivityLoadout
}

type ActivityMatchmakingBlock struct {
	// IsMatchmade determines if matchmaking is available for this activity.
	IsMatchmade bool
	// MinParty is the minimum number of players in a fireteam for this activity to launch.
	MinParty int32
	// MaxParty is the maximum number of players in a fireteam for this activity.
	MaxParty int32
	// MaxPlayers is the maximum number of players across all teams in an activity.
	MaxPlayers int32
	// RequiresGuardianOath determines if players are punished for leaving this activity before completion.
	RequiresGuardianOath bool
}

type ActivityModeCategory int32

type ActivityModeDefinition map[uint32]ActivityModeEntity

type ActivityModeEntity struct {
	DisplayProperties DisplayProperties
	// PGCRImage is the Post-Game Carnage Report for this activity mode.
	PgcrImage string
	// ModeType is this activity mode's type.
	ModeType ActivityModeType
	// ActivityModeCategory is the category of this activity mode.
	ActivityModeCategory ActivityModeCategory
	// IsTeamBased determines if this activity mode is team-based, co-op or free-for-all.
	IsTeamBased bool
	// IsAggregateMode determines if this activity mode is an aggregate of other specific modes.
	IsAggregateMode bool
	// ParentHashes are the hashes all ActivityModeEntity structs related this activity mode.
	ParentHashes []uint32
	// FriendlyName is an identifier used for referring to this activity mode.
	FriendlyName string
	// ActivityModeMappings are the ActivityEntity structs and the mode type for this activity mode.
	ActivityModeMappings map[uint32]ActivityModeType
	// Display determines if this activity mode is shown in a given UI.
	Display bool
	// Order is the relative ordering of activity modes.
	Order int32
	EntityMetadata
}

type ActivityModeType int32

type ActivityModifierDefinition map[uint32]ActivityModifierEntity

type ActivityModifierEntity struct {
	DisplayProperties DisplayProperties
	EntityMetadata
}

type ActivityModifierReference struct {
	// ActivityModifierHash is the hash of a related ActivityModifierEntity.
	ActivityModifierHash uint32
}

type ActivityNavPointType int32

type ActivityPlaylistItem struct {
	// ActivityHash is the hash of a related ActivityEntity.
	ActivityHash uint32
	// DirectActivityModeHash is the hash of a related ActivityModeEntity.
	DirectActivityModeHash uint32
	// DirectActivityModeType is a classification of the mode related to this activity.
	DirectActivityModeType ActivityModeType
	// ActivityModeHashes are the hash identifiers for all related ActivitymodeEntity structs.
	ActivityModeHashes []uint32
	// ActivityModeTypes are all activity mode's that apply to this activity.
	ActivityModeTypes []ActivityModeType
}

type ActivityReward struct {
	// RewardText is the localized header for this reward set.
	RewardText string
	// RewardItems are the items provided in this reward.
	RewardItems []ItemQuantity
}

type ActivityTypeDefinition map[uint32]ActivityTypeEntity

type ActivityTypeEntity struct {
	DisplayProperties DisplayProperties
	EntityMetadata
}

type ActivityUnlockString struct {
	// DisplayString is the localized string to display if certain conditions are met.
	DisplayString string
}

type AmmunitionType int32

type AnimationReference struct {
	AnimName, AnimIdentifier, Path string
}

type ArtDyeReference struct {
	ArtDyeChannelHash uint32
}

type ArtifactDefinition map[uint32]ArtifactEntity

type ArtifactEntity struct {
	DisplayProperties DisplayProperties
	// TranslationBlock is rendering information for this artifact.
	TranslationBlock ItemTranslationBlock
	// Tiers are tier/rank data related to this artifact.
	Tiers []ArtifactTier
	EntityMetadata
}

type ArtifactTier struct {
	// TierHash is an unique identifer for this tier within the artifact.
	TierHash uint32
	// DisplayTitle is the localized title of this tier.
	DisplayTitle string
	// ProgressRequirementMessage represents the localized minimum requirement for this tier.
	ProgressRequirementMessage string
	// Items are the items that can earned within this tier.
	Items []ArtifactTierItem
	// MinimumUnlockPointsUsedRequirement is the minimum number of unlock points needed to unlock this artifact tier.
	MinimumUnlockPointsUsedRequirement int32
}

type ArtifactTierItem struct {
	// ItemHash is the hash for a related InventoryItemEntity.
	ItemHash uint32
}

type BreakerTypeDefinition map[uint32]BreakerTypeEntity

type BreakerTypeEntity struct {
	DisplayProperties DisplayProperties
	// EnumValue refers to the breaker classification for this breaker type.
	EnumValue BreakerTypeEnum
	EntityMetadata
}

type BreakerTypeEnum int32

type Bubble struct {
	// Hash is the unique identifier for this bubble within a destination.
	Hash              uint32
	DisplayProperties DisplayProperties
}

type BucketCategory int32

type BucketScope int32

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

type BungieMembershipType int32

type ChecklistDefinition map[uint32]ChecklistEntity

type ChecklistEntity struct {
	DisplayProperties DisplayProperties
	// ViewActionString is a localized string prompt for viewing this checklist.
	ViewActionString string
	// Scope determines if this checklist if per-character or account-wide.
	Scope Scope
	// Entries are the individual checklist items.
	Entries []ChecklistEntry
	EntityMetadata
}

type ChecklistEntry struct {
	// Hash is the unique identifier of this entry within the checklist.
	Hash              uint32
	DisplayProperties DisplayProperties
	// DestinationHash is the hash of a related DestinationEntity.
	DestinationHash uint32
	// LocationHash is the hash of a related LocationEntity.
	LocationHash uint32
	// BubbleHash is the hash of an activity bubble in LocationEntity.LocationReleases.
	BubbleHash uint32
	// ActivityHash is the hash of a related ActivityEntity.
	ActivityHash uint32
	// ItemHash is the hash of a related InventoryItemEntity.
	ItemHash uint32
	// VendorHash is the hash of a related VendorEntity.
	VendorHash uint32
	// VendorInteractionIndex is this entry's index in VendorEntity.Interactions.
	VendorInteractionIndex int32
	// Scope is the scope at which this specific entry can be completed.
	Scope Scope
}

type Class int32

type ClassDefinition map[uint32]ClassEntity

type ClassEntity struct {
	// ClassType is the classification of this character class.
	ClassType         Class
	DisplayProperties DisplayProperties
	// GenderedClassNames are the names of this class by gender name.
	GenderedClassNames map[GenderName]string
	// GenderedClassNamesByGenderHash are the names of this class by the hash of a GenderEntity.
	GenderedClassNamesByGenderHash map[uint32]string
	// MentorVendorHash is the hash of a related VendorEntity.
	MentorVendorHash uint32
	EntityMetadata
}

type CollectibleAcquisitionBlock struct {
	// AcquireMaterialRequirementHash is the hash of a related MaterialRequirementSetEntity.
	AcquireMaterialRequirementHash uint32
	// AcquireTimestampUnlockValueHash is the hash of a related UnlockValueEntity.
	AcquireTimestampUnlockValueHash uint32
}

type CollectibleDefinition map[uint32]CollectibleEntity

type CollectibleEntity struct {
	DisplayProperties DisplayProperties
	// Scope indicates if this collectible is per-character or account-wide.
	Scope Scope
	// SourceString is a hint about how to acquire the item.
	SourceString string
	// SourceHash is supposed to be the hash of a given source. This is meant to be used to group collectibles by source.
	SourceHash uint32
	// ItemHash is the hash for a related InventoryItemEntity.
	ItemHash             uint32
	AcquisitionInfo      CollectibleAcquisitionBlock
	StateInfo            CollectibleStateBlock
	PresentationInfo     PresentationChildBlock
	PresentationNodeType PresentationNodeType
	TraitIds             []string
	TraitHashes          []uint32
	// ParentNodeHashes are the hashes of presentation nodes that have this collectible as a child.
	ParentNodeHashes []uint32
	EntityMetadata
}

type CollectibleStateBlock struct {
	// ObscuredOverrideItemHash is the hash of a related InventoryItemEntity.
	ObscuredOverrideItemHash uint32
	// Requirements are to show this collectible's state.
	Requirements PresentationNodeRequirementsBlock
}

type Color struct {
	Red, Green, Blue, Alpha byte
}

type Contract interface {
	// Name is the name of this contract in the Bungie.Net API.
	Name() string
	// Reference is a link to the Bungie.Net API which describes this contract.
	Reference() string
	// Entity returns a specific entity from this contract with a given hash.
	Entity(hash uint32) interface{}
	// Unmarshal unmarshals the JSON for a contract when calling Manifest.FulfillContract.
	// Each contract uses a custom unmarshaller function for convenience.
	Unmarshal([]byte) error
}

type ContractReader interface {
	// ReadContract returns the marshalled contract with a given path.
	ReadContract(contract Contract, path string, useMobile bool) ([]byte, error)
	// Close closes this reader and all associated resources.
	Close() error
}

type DamageType int32

type DamageTypeDefinition map[uint32]DamageTypeEntity

type DamageTypeEntity struct {
	DisplayProperties DisplayProperties
	// TransparentIconPath is a variant of the icon that is transparent and colorless
	TransparentIconPath string
	// ShowIcon determines if the UI shows this damage type's icon.
	ShowIcon bool
	// EnumValue is the this damage type's defined value.
	EnumValue DamageType
	EntityMetadata
}

type DateRange struct {
	Start, End time.Time
}

type DerivedItem struct {
	// ItemHash is the hash of a related InventoryItemEntity.
	ItemHash uint32
	// ItemName is the name of this derived item.
	ItemName string
	// ItemDetail is an additional detail about this derived item to be added to the description.
	ItemDetail string
	// ItemDescription is a brief description of this item.
	ItemDescription string
	// IconPath is an icon for this item.
	IconPath string
	// VendorItemIndex is the index of this item in the "Preview Vendor" UI.
	VendorItemIndex int32
}

type DerivedItemCategory struct {
	// CategoryDescription is a localized string for the category title.
	CategoryDescription string
	// Items is the list of all items of this category.
	Items []DerivedItem
}

type DestinationBubbleSetting struct {
	DisplayProperties DisplayProperties
}

type DestinationDefinition map[uint32]DestinationEntity

type DestinationEntity struct {
	DisplayProperties DisplayProperties
	// PlaceHash is the hash of a related PlaceEntity.
	PlaceHash uint32
	// DefaultFreeroamActivityHash is the hash of a related ActivityEntity.
	DefaultFreeroamActivityHash uint32
	// ActivityGraphEntries are the list of maps that are shown in the director for this destination.
	ActivityGraphEntries []ActivityGraphListEntry
	// BubbleSettings are zones within this destination. Deprecated: use Bubbles.
	BubbleSettings []DestinationBubbleSetting
	// Bubbles are unique identifiers for every bubble zone in this destination.
	Bubbles []Bubble
	EntityMetadata
}

type DisplayCategory struct {
	// Index is the position of this display category in the vendor.
	Index int32
	// Identifier is the identifier for this display category.
	Identifier string
	// DisplayCategoryHash is the hash of this display category; meant for grouping.
	DisplayCategoryHash uint32
	DisplayProperties   DisplayProperties
	// DisplayInBanner determines if this display category should be displayed in the banner section of the vendor's UI.
	DisplayInBanner bool
	// ProgressionHash is the hash of a related ProgressionEntity.
	ProgressionHash uint32
	// SortOrder is the sort order of items within this display category.
	SortOrder int32
	// DisplayStyleHash indicates how this display category will be displayed in the UI.
	DisplayStyleHash uint32
	// DisplayStyleIdentifier is the identifier for this display category.
	DisplayStyleIdentifier string
}

type DisplayProperties struct {
	Description   string
	Name          string
	Icon          string
	IconSequences []IconSequence
	HighResIcon   string
	HasIcon       bool
}

type DyeReference struct {
	ChannelHash, DyeHash uint32
}

type EnergyCapacityEntry struct {
	// CapacityValue is the amount of energy capacity this plug provides.
	CapacityValue int32
	// EnergyTypeHash is the hash of a related EnergyTypeEntity.
	EnergyTypeHash uint32
	// EnergyType is a classification of the type of energy capacity granted.
	EnergyType EnergyType
}

type EnergyCostEntry struct {
	// EnergyCost is the cost of inserting this plug.
	EnergyCost int32
	// EnergyTypeHash is the hash of a related EnergyTypeEntity.
	EnergyTypeHash uint32
	// EnergyType is a classification of the type of energy that the plug costs.
	EnergyType EnergyType
}

type EnergyType int32

type EnergyTypeDefinition map[uint32]EnergyTypeEntity

type EnergyTypeEntity struct {
	DisplayProperties DisplayProperties
	// TransparentIconPath is a variant of the icon that is transparent and colorless.
	TransparentIconPath string
	// ShowIcon determines if the energy type's icon should be shown.
	ShowIcon bool
	// EnumValue is the energy type.
	EnumValue EnergyType
	// CapacityStatHash is the hash for a related InvestmentStatEntity for the capacity.
	CapacityStatHash uint32
	// CostStatHash is the hash for a related InvestmentStatEntity for the cost.
	CostStatHash uint32
	EntityMetadata
}

type EntityMetadata struct {
	// Hash is the unique identifier for a given entity; guaranteed to be unique within a contract.
	Hash uint32
	// Index is the identifier for a given entity found within the mobile contract tables.
	Index int32
	// Redacted is true if there is an entity, but the Bungie API is not allowed to show it.
	Redacted bool
}

type EnvironmentLocationMapping struct {
	// LocationHash is the hash of a related LocationEntity.
	LocationHash uint32
	// ActivationSource is a hint a given UI uses to figure out how this location is activated.
	ActivationSource string
	// ItemHash is the hash of a related InventoryItemEntity.
	ItemHash uint32
	// ObjectiveHash is the hash of a related ObjectiveEntity.
	ObjectiveHash uint32
	// ActivityHash is the hash of a related ActivityEntity.
	ActivityHash uint32
}

type EquipmentSlotDefinition map[uint32]EquipmentSlotEntity

type EquipmentSlotEntity struct {
	// EquipmentCategoryHash is supposed to be a related EquipmentCategoryEntity which has not been exposed in the Bungie.net API.
	// The specification suggests using this hash as a general way to group equipment by common functionality.
	EquipmentCategoryHash uint32
	// BucketTypeHash is the hash of a related InventoryBucketEntity.
	BucketTypeHash uint32
	// ApplyCustomArtDays determines if equipped items should have custom art dyes applied during rendering.
	ApplyCustomArtDyes bool
	// ArtDyeChannels are all art dyes that apply this equipment slot.
	ArtDyeChannels []ArtDyeReference
	EntityMetadata
}

type EquippingBlock struct {
	// GearsetItemHash is the hash of a InventoryItemEntity.
	GearsetItemHash uint32
	// UniqueLabel is the label used to check if the item has other items of matching types already equipped.
	UniqueLabel string
	// UniqueLabelHash is the hash of the unique label. This does not point to specific entity.
	UniqueLabelHash uint32
	// EquipmentSlotTypeHash is the hash of a related EquipmentSlotEntity.
	EquipmentSlotTypeHash uint32
	// Attributes are the custom attributes on the equippability of the item.
	Attributes EquippingItemBlockAttributes
	// AmmoType is the classification of ammo a weapon uses.
	AmmoType AmmunitionType
	// DisplayStrings represent the state failure conditions that can occur when trying to equip the item.
	// These match up 1:1 with RequiredUnlockExpressions.
	DisplayStrings []string
}

type EquippingItemBlockAttributes int32

type FactionDefinition map[uint32]FactionEntity

type FactionEntity struct {
	DisplayProperties DisplayProperties
	// ProgressionHash is the hash of a related ProgressionEntity.
	ProgressionHash uint32
	// TokenValues are the hashes of InventoryItemEntity structs and their progression value for this faction.
	TokenValues map[uint32]uint32
	// RewardItemHash is the hash of a related InventoryItemEntity.
	RewardItemHash uint32
	// RewardVendorHash is the hash of a related VendorEntity.
	RewardVendorHash uint32
	// Vendors are a list of vendors associated with this faction.
	Vendors []FactionVendor
	EntityMetadata
}

type FactionVendor struct {
	// VendorHash is the hash of a related VendorEntity.
	VendorHash uint32
	// DestinationHash is the hash of a related DestinationEntity.
	DestinationHash uint32
	// BackgroundImagePath is the relative path to the background image representing this vendor.
	BackgroundImagePath string
}

type FulfillmentOption func(o *fulfillmentOptions) error

type GatingScope int32

type GearArtArrangementReference struct {
	ClassHash, ArtArrangementHash uint32
}

type Gender int32

type GenderDefinition map[uint32]GenderEntity

type GenderEntity struct {
	// GenderType is one of the currently defined genders.
	GenderType        Gender
	DisplayProperties DisplayProperties
	EntityMetadata
}

type GenderName string

type GraphNodeState int32

type HyperlinkReference struct {
	Title, Url string
}

type IconSequence struct {
	Frames []string
}

type InsertPlugAction struct {
	// ActionExecuteSeconds is how much time, in seconds, it takes for this plug to be inserted.
	ActionExecuteSeconds int32
	// ActionType is a classification of the type of action being performed on this socket.
	ActionType SocketTypeActionType
}

type InterpolationPoint struct {
	Value, Weight int32
}

type InterpolationPointFloat struct {
	Value, Weight float32
}

type InventoryBucketDefinition map[uint32]InventoryBucketEntity

type InventoryBucketEntity struct {
	DisplayProperties DisplayProperties
	// Scope is where this bucket can be found.
	Scope BucketScope
	// Category describes what items can be found in this bucket.
	Category BucketCategory
	// BucketOrder is a recommended ordering for this bucket in a given UI.
	BucketOrder int32
	// ItemCount is the maximum number of item slots in a bucket.
	ItemCount int32
	// Location is the conceptual location of this bucket, such as the vault or postmaster inventory.
	Location ItemLocation
	// HasTransferDestination indicates if items can be transferred to/from this bucket.
	HasTransferDestination bool
	// Enabled determines if this bucket is being used in-game.
	Enabled bool
	// Fifo determines if the bucket will delete the oldest item in a bucket when adding a new one (FIFO)
	// or if this bucket disallows new items until there is space.
	Fifo bool
	EntityMetadata
}

type InventoryItemDefinition map[uint32]InventoryItemEntity

type InventoryItemEntity struct {
	DisplayProperties DisplayProperties
	// TooltipNotifications are tooltips that come up conditionally for the item.
	TooltipNotifications []ItemTooltipNotification
	// CollectibleHash is the hash of a related CollectibleEntity.
	CollectibleHash uint32
	// IconWatermark is the original release watermark overlay for the icon.
	// If the item has different versions, it can be overriden by the watermark in the quality block or the IconWatermarkShelved field.
	IconWatermark string
	// IconWatermarkShelved is the "shelved" release watermark overlay for the icon.
	// If the item version has a power cap below the season power cap, it should show the "shelved" watermark.
	IconWatermarkShelved string
	// SecondaryIcon is a secondary icon associated with the item; used in places such as emblem nameplates.
	SecondaryIcon string
	// SecondaryOverlay is the background overlay for SecondaryIcon.
	SecondaryOverlay string
	// BackgroundColor is the color used for the icon background of an item.
	BackgroundColor Color
	// Screenshot is the path to an in-game screenshot for this item.
	Screenshot string
	// ItemTypeDisplayName is the localized title/name of the item's type.
	ItemTypeDisplayName string
	// FlavorText is the quote or description of a given item.
	FlavorText string
	// UiItemDisplayStyle is how a UI should render this item in an inventory screen.
	UiItemDisplayStyle string
	// ItemTypeAndTierDisplayName is the localized string that combines the item type and tier description.
	ItemTypeAndTierDisplayName string
	// DisplaySource is the localized string describing how to find this item.
	DisplaySource string
	// TooltipStyle determines what tooltip a UI should show for this item.
	TooltipStyle string
	// Action is an action performed when using the item.
	Action ItemActionBlock
	// Inventory describes this item's relationship with its inventory.
	Inventory ItemInventoryBlock
	// SetData contains data about the steps and mechanics if this item is quest-related.
	SetData ItemSetBlock
	// Stats are the statistics related to equippable items.
	Stats ItemStatBlock
	// EmblemObjectiveHash is the hash of a related ObjectiveEntity.
	EmblemObjectiveHash uint32
	// EquippingBlock describes the conditions under which this item can be equipped.
	EquippingBlock EquippingBlock
	// TranslationBlock contains rendering information for this item.
	TranslationBlock ItemTranslationBlock
	// Preview summarizes items that can be acquired from using this item.
	Preview ItemPreviewBlock
	// Quality describes the item's quality.
	Quality ItemQualityBlock
	// Value describes an item's value; i.e. sale price for a vendor item and dismantle reward.
	Value ItemValueBlock
	// SourceData describes how to acquire this item.
	SourceData ItemSourceBlock
	// Objectives are extra tasks related to this item if it is part of a quest step.
	Objectives ItemObjectiveBlock
	// Metrics are all available metrics for this item.
	Metrics ItemMetricBlock
	// Plug is the information about how to insert a socket-type item.
	Plug ItemPlug
	// GearSet is the set of equipment associated with this item.
	Gearset ItemGearsetBlock
	// Sack describes what items can be obtained by opening this item.
	Sack ItemSackBlock
	// Sockets describes any sockets available on this item.
	Sockets ItemSocketBlock
	// Summary is this item's reward summary.
	Summary ItemSummaryBlock
	// TalentGrid is the information of the talents in a subclass-type item.
	TalentGrid ItemTalentGridBlock
	// InvestmentStats are the raw stats for this item, before any adjustments.
	InvestmentStats []ItemInvestmentStat
	// Perks are intrisic perks of an item.
	Perks []ItemPerkEntry
	// LoreHash is the hash of a related LoreEntity.
	LoreHash uint32
	// SummaryItemHash is the hash of a related InventoryItemEntity.
	SummaryItemHash uint32
	// Animations defines are animations in the game content for this item.
	Animations []AnimationReference
	// AllowActions determines whether or not the API is allowed to take actions which effect this item.
	AllowActions bool
	// Links are any help or informational URLs about this item.
	Links []HyperlinkReference
	// DoesPostmaterPullHaveSideEffects indicates whether something could happen when transferring this item from the postmaster.
	DoesPostmasterPullHaveSideEffects bool
	// NonTransferrable determines whether an item cannot be transferred
	NonTransferrable bool
	// ItemCategoryHashes are hashes of all related ItemCategoryEntity structs.
	ItemCategoryHashes []uint32
	// SpecialItemType is a internal item category from Destiny 1. Use ItemCategoryHashes instead.
	SpecialItemType SpecialItemType
	// ItemType is the base type of this item. Use ItemCategoryHashes instead.
	ItemType ItemType
	// ItemSubType is the sub-type of this item. Use ItemCategoryHashes instead.
	ItemSubType ItemSubType
	// ClassType is the specific class this item is restricted to.
	ClassType Class
	// BreakerType is the type of anti-champion ability granted by using this item.
	BreakerType BreakerTypeEnum
	// BreakerTypeHash is the hash of a related BreakerTypeEntity.
	BreakerTypeHash uint32
	// Equippable indicates whether an item can be equipped.
	Equippable bool
	// DamageTypeHashes are hashes of all related DamageTypeEntity structs.
	DamageTypeHashes []uint32
	// DamageTypes lists all damage types this item can have.
	DamageTypes []DamageType
	// DefaultDamageType is the default damage type of this item.
	DefaultDamageType DamageType
	// DefaultDamageTypeHash is the hash of a related DamageTypeEntity.
	DefaultDamageTypeHash uint32
	// SeasonHash is the hash of a related SeasonEntity.
	SeasonHash uint32
	// IsWrapper determines if this item is a vendor-wrapper that can be refunded before it is unwrapped.
	IsWrapper bool
	// TraidIds are metadata tags applied to this item.
	TraitIds []string
	// TraitHashes are hashes of all related TraitEntity structs.
	TraitHashes []uint32
	EntityMetadata
}

type InventoryItemStat struct {
	// StatHash is the hash of a related StatEntity.
	StatHash uint32
	// Value represents that stat value assuming the minimum roll and factoring in mandatory bonuses.
	Value int32
	// Minimum is the minimum possible value for this stat an item can roll.
	Minimum int32
	// Maximum is the maximum possible value for this stat an item can roll.
	Maximum int32
	// DisplayMaximum is the maximum possible value for this stat that is shown in a given UI.
	DisplayMaximum int32
}

type ItemActionBlock struct {
	// VerbName is localized text for the verb of this action.
	VerbName string
	// VerbDescription is a localized text describing this action.
	VerbDescription string
	// IsPositive determines if the given item has this action.
	IsPositive bool
	// OverlayScreenName is the name of the overlay screen associated with this action.
	OverlayScreenName string
	// OverlayIcon is the icon of the overlay screen associated with this action.
	OverlayIcon string
	// RequiredCooldownSeconds is the number of seconds to delay before allowing this action to be performed again.
	RequiredCooldownSeconds int32
	// RequiredItems are other items that must exist or be destroyed to perform this action.
	RequiredItems []ItemActionRequiredItem
	// ProgressionRewards are the progressions and rewards earned by performing this action.
	ProgressionRewards []ProgressionReward
	// ActionTypeLabel is the internal identifier for this action.
	ActionTypeLabel string
	// RequiredLocation is a localized string for a hint about the location where this action can be performed.
	RequiredLocation string
	// RequiredCooldownHash is the hash of related Cooldown associated with this action.
	// Cooldown data is not currently available in the Bungie.net API.
	RequiredCooldownHash uint32
	// DeleteOnAction determines the item is deleted when this action is performed.
	DeleteOnAction bool
	// ConsumeEntireStack determines if the entire stack of items is deleted when this action is performed.
	ConsumeEntireStack bool
	// UseOnAcquire determines if this action is performed when the associated item if acquired.
	UseOnAcquire bool
}

type ItemActionRequiredItem struct {
	// Count is the minimum quantity of the item required.
	Count int32
	// ItemHash is the hash of a related InventoryItemEntity.
	ItemHash uint32
	// DeleteOnAction determines if the quantity of items will be deleted when the action is performed.
	DeleteOnAction bool
}

type ItemCategoryDefinition map[uint32]ItemCategoryEntity

type ItemCategoryEntity struct {
	DisplayProperties DisplayProperties
	// Visible determines if this item category should be visible in a given UI.
	Visible bool
	// Deprecated determines if this item category is deprecated.
	Deprecated bool
	// ShortTitle is a shorted version of the title of this item category.
	ShortTitle string
	// ItemTypeRegex is a regular expression used against the item type to determine membership in this item category.
	ItemTypeRegex string
	// GrantDestinyBreakerType is the breaker type granted by items in this category.
	GrantDestinyBreakerType BreakerTypeEnum
	// PlugCategoryIdentifier is the identifier of the plug in this item category.
	PlugCategoryIdentifier string
	// ItemTypeRegexNot is a regular expression used against the item type to determine non-membership in this item category.
	ItemTypeRegexNot string
	// OriginBucketIdentifier is the name of the bucket for this item category.
	OriginBucketIdentifier string
	// GrantDestinyItemType is the item type for items in this category.
	GrantDestinyItemType ItemType
	// GrantDestinySubType is the item subtype for items in this category.
	GrantDestinySubType ItemSubType
	// GrantDestinyClass is the class restriction for this item category.
	GrantDestinyClass Class
	// Trait is the identifier of the item trait found in this category.
	TraitId string
	// GroupedCategoryHashes are the hashes of children categories contained within this item category.
	GroupedCategoryHashes []uint32
	// ParentCategoryHashes are the hashes of parent categories which contain this item category.
	ParentCategoryHashes []uint32
	// GroupCategoryOnly determines if this item category is only used for grouping other item categories.
	GroupCategoryOnly bool
	EntityMetadata
}

type ItemCreationEntryLevel struct {
	// Level is the minimum character level the item spawns at.
	Level int32
}

type ItemGearsetBlock struct {
	// TrackingValueMax is the maximum number of items that can be collected.
	TrackingValueMax int32
	// ItemList is a list of hashes of all related InventoryItemEntity structs.
	ItemList []uint32
}

type ItemIntrinsicSocketEntry struct {
	// PlugItemHash is the hash of a related InventoryItemEntity.
	PlugItemHash uint32
	// SocketTypeHash is the hash of a related SocketTypeEntity.
	SocketTypeHash uint32
	// DefaultVisible determines if this socket is visible in the item's default state.
	DefaultVisible bool
}

type ItemInventoryBlock struct {
	// StackUniqueLabel is a unique label for a single stack in a given inventory.
	StackUniqueLabel string
	// MaxStackSize is the maximum quantity of this item that can exist in a stack.
	MaxStackSize int32
	// BucketTypeHash is the hash of a related InventoryBucketEntity.
	BucketTypeHash uint32
	// RecoveryBucketTypeHash is the hash of a related InventoryBucketEntity used for items in the lost loot queue.
	RecoveryBucketTypeHash uint32
	// TierTypeHash is the hash of a related ItemTierTypeEntity.
	TierTypeHash uint32
	// IsInstanceItem determines if this item is instanced.
	IsInstanceItem bool
	// TierTypeName is the localized name of this item's tier type.
	TierTypeName string
	// TierType is the classification of this item's tier type.
	TierType ItemTier
	// ExpirationTooltip is the tooltip to show when this item expires.
	ExpirationTooltip string
	// ExpiredInActivityMessage is the message shown if this item expires while playing in an activity.
	ExpiredInActivityMessage string
	// ExpiredInOrbitMessage is the message shown if this item expires while in orbit.
	ExpiredInOrbitMessage string
	// SuppressExpirationWhenObjectivesComplete determines if expiration messages should be suppressed.
	SuppressExpirationWhenObjectivesComplete bool
}

type ItemInvestmentStat struct {
	// StatTypeHash is the hash of a related StatEntity.
	StatTypeHash uint32
	// Value is the raw investment value for this stat.
	Value int32
	// IsCondtionallyActive determines if the stat will only be applied on an item in certain game conditions.
	IsConditionallyActive bool
}

type ItemLocation int32

type ItemMetricBlock struct {
	// AvailableMetricCategoryNodeHashes are the hashes of all related PresentationNodeEntity structs.
	AvailableMetricCategoryNodeHashes []uint32
}

type ItemObjectiveBlock struct {
	// ObjectiveHashes are the hashes of all related ObjectiveEntity structs.
	ObjectiveHashes []uint32
	// DisplayActivityHashes are the hashes of all related ActivityEntity structs.
	DisplayActivityHashes []uint32
	// RequireFullObjectiveCompletion determines if all objectives must be completed for the step to be completed.
	RequireFullObjectiveCompletion bool
	// QuestlineItemHash is the hash of a related InventoryItemEntity.
	QuestlineItemHash uint32
	// Narrative is the localized string for narrative text related to this quest step.
	Narrative string
	// ObjectiveVerbName is a localized string describing an action to be performed for this objective.
	ObjectiveVerbName string
	// QuestTypeIdentifier identifies the type of quest being performed.
	QuestTypeIdentifier string
	// QuestTypeHash is a unique hash this quest type.
	QuestTypeHash uint32
	// PerObjectiveDisplayProperties are related display information per objective.
	PerObjectiveDisplayProperties []ObjectiveDisplayProperties
	DisplayAsStatTracker          bool
}

type ItemPerkEntry struct {
	// RequirementDisplayString is the localized string to show if this perk is not active.
	RequirementDisplayString string
	// PerkHash is the hash of a related SandboxPerkDefinition.
	PerkHash uint32
	// PerkVisibility indicates if this perk should be shown.
	PerkVisibility ItemPerkVisibility
}

type ItemPerkVisibility int32

type ItemPlug struct {
	// InsertionRules are the rules around when this plug can be inserted.
	InsertionRules []PlugRule
	// PlugCategoryIdentifier is localized identifier for this plug's category.
	PlugCategoryIdentifier string
	// PlugCategoryHash is a unique hash for this plug's category.
	PlugCategoryHash uint32
	// OnActionRecreateSelf determines if this plug is refunded when socketed.
	OnActionRecreateSelf bool
	// InsertionMaterialRequirementHash is the hash of a related MaterialRequirementSetEntity for inserting this plug.
	InsertionMaterialRequirementHash uint32
	// PreviewItemOverrideHash is the hash of a related InventoryItemEntity.
	PreviewItemOverrideHash uint32
	// EnabledMaterialRequirementHash is the hash of a related MaterialRequirementSetEntity for enabling this plug.
	EnabledMaterialRequirementHash uint32
	// EnabledRules are the rules around this plug is enabled after being socketed.
	EnabledRules []PlugRule
	// UIPlugLabels is a label that describes the style of this plug in a given UI.
	UiPlugLabels string
	// PlugStyle is a classification of the style of this plug in a given UI.
	PlugStyle PlugUIStyles
	// PlugAvailable indicates the rules about when this plug can be used.
	PlugAvailable PlugAvailabilityMode
	// AlternateUIPlugLabel is a label applied to a plug if it meets certain state requirements.
	AlternateUiPlugLabel string
	// AlternatePlugStyle is a classification of the style of this plug in a given UI under certain conditions.
	AlternatePlugStyle PlugUIStyles
	// IsDummyPlug determines if this plug is used for UI display purposes only, with no other effects.
	IsDummyPlug bool
	// ParentItemOverride describes how this plug overrides properties of the item it is inserted in.
	ParentItemOverride ParentItemOverride
	// EnergyCapacity is the energy capacity provided to the item in which this plug is socketed.
	EnergyCapacity EnergyCapacityEntry
	// EnergyCost is the energy cost of this plug.
	EnergyCost EnergyCostEntry
}

type ItemPreviewBlock struct {
	// ScreenStyle is a hint for which detail screen to show for this item preview in a given UI.
	ScreenStyle string
	// PreviewVendorHash is the hash related to a VendorEntity.
	PreviewVendorHash uint32
	// ArtifactHash is the hash related to an ArtifactEntity.
	ArtifactHash uint32
	// PreviewActionString is the localized string for the action associated with this preview.
	PreviewActionString string
	// DerivedItemCategories is the list of items being previewed, categorized in the same way as they presented in the preview UI.
	DerivedItemCategories []DerivedItemCategory
}

type ItemQualityBlock struct {
	// ItemLevels are the base levels of an item as defined by a season.
	ItemLevels []int32
	// QualityLevel is used in combination with the item's level to calculate stats.
	QualityLevel int32
	// InfusionCategoryName is an identifier for this item's infusability. Deprecated.
	InfusionCategoryName string
	// InfusionCategoryHash is the hash identifier for the infusion. Deprecated.
	InfusionCategoryHash uint32
	// InfusionCategoryHashes are a set of infusion category hashes. If any of these hashes match an entry in
	// InventoryItemEntity.InfusionCategoryHashes, the two can infuse with each other.
	InfusionCategoryHashes []uint32
	// ProgressionLevelRequirementHash is the hash of a related ProgressionLevelRequirementEntity.
	ProgressionLevelRequirementHash uint32
	// CurrentVersion is the latest version available for this item.
	CurrentVersion uint32
	// Versions are the list of versions available for this item.
	Versions []ItemVersion
	// DisplayVersionWatermarkIcons are icon overlays that show the item version and power cap.
	DisplayVersionWatermarkicons []string
}

type ItemQuantity struct {
	// ItemHash is the hash of a related InventoryItemEntity.
	ItemHash uint32
	// ItemInstanceID refers to a specific instance of an item.
	ItemInstanceId int64
	// Quantity is the amount of the item.
	Quantity int32
	// HasCondtionalVisibility determines if the item quantity may be condtionally shown or hideen.
	HasConditionalVisibility bool
}

type ItemSackBlock struct {
	// DetailAction is a localized description of what happens when this sack is opened.
	DetailAction string
	// OpenAction is localized name of the action being performed when this sack is opened.
	OpenAction string
	// SelectItemCount is the amount of the selected item produced by this sack.
	SelectItemCount int32
	// VendorSackType identifies the type of sack being sold by a vendor.
	VendorSackType string
	// OpenOnAcquire determines if this item sack is opened when it is acquired.
	OpenOnAcquire bool
}

type ItemSetBlock struct {
	// ItemList is a collection of hashes of items in this set.
	ItemList []ItemSetBlockEntry
	// RequiredOrderedSetItemAdd determines if items in this set can only be added in increasing order and if adding an item will remove previous items.
	RequireOrderedSetItemAdd bool
	// SetIsFeatured determines if this quest shows up as featured in a given UI.
	SetIsFeatured bool
	// SetType is an identifier of the category of this quest.
	SetType string
	// QuestLineName is the name of the quest line of this quest.
	QuestLineName string
	// QuestLineDescription is the description of the quest line of this quest.
	QuestLineDescription string
	// QuestStepSummary is an additional summary of this step in the quest line.
	QuestStepSummary string
}

type ItemSetBlockEntry struct {
	// TrackingValue tracks which step has been reached in this quest.
	TrackingValue int32
	// ItemHash is the hash of a related InventoryItemEntity.
	ItemHash uint32
}

type ItemSocketBlock struct {
	// Detail is a localized description about sockets on this item.
	Detail string
	// SocketEntries are all mutable sockets on an item.
	SocketEntries []ItemSocketEntry
	// IntrinsicSockets are the permanent sockets on an item.
	IntrinsicSockets []ItemIntrinsicSocketEntry
	// SocketCategories are the categories that sockets are grouped into.
	SocketCategories []ItemSocketCategory
}

type ItemSocketCategory struct {
	// SocketCategoryHash is the hash of a related SocketCategoryEntity.
	SocketCategoryHash uint32
	// SocketIndexes are the indexes of sockets in InventoryItemEntity.Sockets.SocketEntries.
	SocketIndexes []int32
}

type ItemSocketEntry struct {
	// SocketTypeHash is the hash of a related SocketTypeEntity.
	SocketTypeHash uint32
	// SingleInitialItemHash is the hash of a related InventoryItemEntity.
	SingleInitialItemHash uint32
	// ReusablePlugItems is a list of pre-determined that can always be plugged into this socket
	// even if the character does not have the plug item in their inventory.
	ReusablePlugItems []ItemSocketEntryPlugItem
	// PreventInitializationOnVendorPurchase determines if a socket will not be intialized with
	// a plug if the item is purchased from a vendor.
	PreventInitializationOnVendorPurchase bool
	// HidePerksInItemTooltip determines is perks provided by this socket should not be shown in the item's tooltip.
	HidePerksInItemTooltip bool
	// PlugSources indicates where plugs for this socket can be obtained.
	PlugSources SocketPlugSources
	// ReusablePlugSetHash is the hash of a related PlugSetEntity that is reusable.
	ReusablePlugSetHash uint32
	// RandomizedPlugSetHash is the hash of a related PlugSetEntity that is randomized.
	RandomizedPlugSetHash uint32
	// DefaultVisible determines if this socket is visible in the item's default state.
	DefaultVisible bool
}

type ItemSocketEntryPlugItem struct {
	// PlugItemHash is the hash of a related InventoryItemEntity.
	PlugItemHash uint32
}

type ItemSocketEntryPlugItemRandomized struct {
	// CurrentlyCanRoll determines if this plug can be rolled on the current version of the item.
	CurrentlyCanRoll bool
	// PlugItemHash is the hash of a InventoryItemEntity.
	PlugItemHash uint32
}

type ItemSource struct {
	// Level is the level this item spawns at.
	Level int32
	// MinQuality is the minimum quality this item spawns at.
	MinQuality int32
	// MaxQuality is the maximum quality this item spawns at.
	MaxQuality int32
	// MinLevelRequired is the minimum character level required for equipping the item.
	MinLevelRequired int32
	// MaxLevelRequired is the maximum character level required for equipping the item.
	MaxLevelRequired int32
	// ComputedStats are the stats computed for this level/quality range.
	ComputedStats map[uint32]InventoryItemStat
	// SourceHashes are the hashes for all related RewardSourceEntity structs.
	SourceHashes []uint32
}

type ItemSourceBlock struct {
	// SourceHashes are the hashes for all related RewardSourceEntity structs.
	SourceHashes []uint32
	// Sources are a collection of details about ways the item can be spawned.
	Sources []ItemSource
	// Exclusive is a classification of the platforms this item is exclusive to.
	Exclusive BungieMembershipType
	// VendorSources reference vendors that potentially sell this item.
	VendorSources []ItemVendorSourceReference
}

type ItemStatBlock struct {
	// DisablePrimaryStatDisplay determines if the primary stat on this item isn't shown on inspection.
	DisablePrimaryStatDisplay bool
	// StatGroupHash is the hash of a related StatGroupEntity.
	StatGroupHash uint32
	// Stats are precomputed stats on an item by the hash of a the related InventoryItemEntity.
	Stats map[uint32]InventoryItemStat
	// HasDisplayableStats determines if any stat on the item is visible.
	HasDisplayableStats bool
	// PrimaryBaseStatHash is the hash of a related StatEntity.
	PrimaryBaseStatHash uint32
}

type ItemSubType int32

type ItemSummaryBlock struct {
	// SortPriority is used as the sort priority when rendering an item.
	SortPriority int32
}

type ItemTalentGridBlock struct {
	// TalentGridHash is the hash of a related TalentGridEntity.
	TalentGridHash uint32
	// ItemDetailString is the localized subtitle for looking at a talent in the item's grid.
	ItemDetailString string
	// BuildName is a shortcut for the build, if this talent grid has an associated build.
	BuildName string
	// HUDDamageType is the damage type used in this talent grid.
	HudDamageType DamageType
	// HUDIcon is the icon to show for this talent grid in a given UI.
	HudIcon string
}

type ItemTier int32

type ItemTierTypeDefinition map[uint32]ItemTierTypeEntity

type ItemTierTypeEntity struct {
	DisplayProperties DisplayProperties
	// InfusionProcess defines the process of infusing items of this tier.
	InfusionProcess ItemTierTypeInfusionBlock
	EntityMetadata
}

type ItemTierTypeInfusionBlock struct {
	// BaseQualityTransferRatio is the default portion of quality that will transfer from the infuser to the infusee.
	// (InfuserQuality - InfuseeQuality) * BaseQualityTransferRatio = base quality transferred.
	BaseQualityTransferRatio float32
	// MinimumQualityIncrement is the minimum amount of quality given if InfuserQuality > InfuseeQuality.
	MinimumQualityIncrement int32
}

type ItemTooltipNotification struct {
	// DisplayString is a localized tooltip to display.
	DisplayString string
	// DisplayStyle identifies the style used to show this display in a given UI.
	DisplayStyle string
}

type ItemTranslationBlock struct {
	WeaponPatternIdentifier string
	WeaponPatternHash       uint32
	DefaultDyes             []DyeReference
	LockedDyes              []DyeReference
	CustomDyes              []DyeReference
	Arrangements            []GearArtArrangementReference
	HasGeometry             bool
}

type ItemType int32

type ItemValueBlock struct {
	// ItemValue refers to items that make up this item's value and the quantity.
	ItemValue []ItemQuantity
	// ValueDescription is a localized text description of the value.
	ValueDescription string
}

type ItemVendorSourceReference struct {
	// VendorHash is the hash of a related VendorEntity.
	VendorHash uint32
	// VendorItemIndexes are the indexes at which this item is sold at this vendor.
	VendorItemIndexes []int32
}

type ItemVersion struct {
	// PowerCapHash is the hash for a related PowerCapEntity.
	PowerCapHash uint32
}

type LinkedGraph struct {
	Description      string
	Name             string
	UnlockExpression UnlockExpression
	LinkedGraphId    uint32
	// LinkedGraphs are a list of all entries in this linked graph.
	LinkedGraphs []LinkedGraphEntry
	Overview     string
}

type LinkedGraphEntry struct {
	// ActivityGraphHash is the hash of a related ActivityGraphEntity.
	ActivityGraphHash uint32
}

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

type LocationDefinition map[uint32]LocationEntity

type LocationEntity struct {
	// VendorHash is the hash for a related VendorEntity.
	VendorHash uint32
	// LocationReleases refer to different spots in the world for this location and which location is valid.
	LocationReleases []LocationRelease
	EntityMetadata
}

type LocationRelease struct {
	DisplayProperties    DisplayProperties
	SmallTransparentIcon string
	MapIcon              string
	LargeTransparentIcon string
	SpawnPoint           uint32
	// DestinationHash is the hash of a related DestinationEntity.
	DestinationHash uint32
	// ActivityHash is the hash of a related ActivityEntity.
	ActivityHash uint32
	// ActivityGraphNodeHash is the activity graph node pointed to by this location.
	ActivityGraphNodeHash uint32
	// ActivityBubbleName is the activity bubble within the Destination.
	ActivityBubbleName      uint32
	ActivityPathBundle      uint32
	ActivityPathDestination uint32
	// NavPointType is a classification of navigation points to this location.
	NavPointType  ActivityNavPointType
	WorldPosition []int32
}

type LoreDefinition map[uint32]LoreEntity

type LoreEntity struct {
	DisplayProperties DisplayProperties
	Subtitle          string
	EntityMetadata
}

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

type MaterialRequirement struct {
	// ItemHash is the hash of a related InventoryItemEntity.
	ItemHash uint32
	// DeleteOnAction determines if the material will be removed from the inventory when the action is performed.
	DeleteOnAction bool
	// Count is the amount of the material required.
	Count int32
	// OmitFromRequirements determines if this material requirement is shown in a given UI.
	OmitFromRequirements bool
}

type MaterialRequirementSetDefinition map[uint32]MaterialRequirementSetEntity

type MaterialRequirementSetEntity struct {
	// Materials are a list of all required materials.
	Materials []MaterialRequirement
	EntityMetadata
}

type MetricDefinition map[uint32]MetricEntity

type MetricEntity struct {
	DisplayProperties DisplayProperties
	// TrackingObjectiveHash is the hash of a related ObjectiveEntity.
	TrackingObjectiveHash uint32
	LowerValueIsBetter    bool
	PresentationNodeType  PresentationNodeType
	TraitIds              []string
	TraitHashes           []uint32
	// ParentNodeHashes are the hashes of presentation nodes that this metric as a child.
	ParentNodeHashes []uint32
	EntityMetadata
}

type MilestoneActivity struct {
	// ConceptualActivityHash is the hash of a related ActivityEntity.
	ConceptualActivityHash uint32
	// Variants are the variants of this milestone-related activity by the hash of a related ActivityEntity.
	Variants map[uint32]MilestoneActivityVariant
}

type MilestoneActivityVariant struct {
	// ActivityHash is the hash of a related ActivityEntity.
	ActivityHash uint32
	// Order is the order to arrange this variant by when displaying a milestone-related activity.
	Order int32
}

type MilestoneChallenge struct {
	// ChallengeObjectiveHash is the hash of a related ObjectiveEntity.
	ChallengeObjectiveHash uint32
}

type MilestoneChallengeActivity struct {
	// ActivityHash is the hash of a related ActivityEntity.
	ActivityHash uint32
	// Challenges are the challenges related to this activity.
	Challenges []MilestoneChallenge
	// ActivityGraphNodes are the nodes this challenge is visible on.
	ActivityGraphNodes []MilestoneChallengeActivityGraphNodeEntry
	// Phases are the phases related to this activity.
	Phases []MilestoneChallengeActivityPhase
}

type MilestoneChallengeActivityGraphNodeEntry struct {
	// ActivityGraphHash is the hash of a related ActivityGraphEntity.
	ActivityGraphHash uint32
	// ActivityGraphNodeHash is hash of this milestone-related challenge within a map.
	ActivityGraphNodeHash uint32
}

type MilestoneChallengeActivityPhase struct {
	// PhaseHash is the unique hash representing the phase.
	PhaseHash uint32
}

type MilestoneDefinition map[uint32]MilestoneEntity

type MilestoneDisplayPreference int32

type MilestoneEntity struct {
	DisplayProperties DisplayProperties
	// DisplayPreference is a hint to a given UI about what DisplayProperties to show when viewing this milestone's live data.
	DisplayPreference MilestoneDisplayPreference
	// Image is a custom image for this milestone.
	Image string
	// MilestoneType is the classification of this milestone.
	MilestoneType MilestoneType
	// Recruitable determines if this milestone is integrated with the API's recruiting feature.
	Recruitable bool
	// FriendlyName is the friendly identifier for this milestone.
	FriendlyName string
	// ShowInMilestones determines if this milestone is shown in the user's personal milestones list.
	ShowInMilestones bool
	// ExplorePrioritizesActivityImage determines if the "Explore Destiny" page prioritizes using the activity image for this milestone.
	ExplorePrioritizesActivityImage bool
	// HashPredictableDates determines if the start and end date of this milestone can be predicted.
	HasPredictableDates bool
	// Quests are the set of all quests related to this milestone.
	Quests map[uint32]MilestoneQuest
	// Rewards are the categories which individual rewards are placed in by the hash of the MilestoneRewordCategory.
	Rewards map[uint32]MilestoneRewardCategory
	// VendorsDisplayTitle is the localized header for vendors related to this milestone.
	VendorsDisplayTitle string
	// Vendors are the vendors which have rewards for this milestone.
	Vendors []MilestoneVendor
	// Values are arbitrary values associated with a given identifier in this milestone.
	Values map[string]MilestoneValue
	// IsInGameMilestone determines if this milestone is an objective that can interacted with in the game.
	IsInGameMilestone bool
	// Activities are the challenge and modifiers related to this milestone.
	Activities   []MilestoneChallengeActivity
	DefaultOrder int32
	EntityMetadata
}

type MilestoneQuest struct {
	// QuestItemHash is the hash of a related InventoryItemEntity.
	QuestItemHash     uint32
	DisplayProperties DisplayProperties
	// OverrideImage is the image to show instead of the milestone's image.
	OverrideImage string
	// QuestRewards are rewards for completing this quest.
	QuestRewards MilestoneQuestRewards
	// Activities are milestone-related activities by the hash of a related ActivityEntity.
	Activities map[uint32]MilestoneActivity
	// DestinationHash is the hash of a related DestinationEntity.
	DestinationHash uint32
}

type MilestoneQuestRewardItem struct {
	// VendorHash is the hash of a related VendorEntity.
	VendorHash uint32
	// VendorItemIndex is the index of item being sold in the vendor.
	VendorItemIndex int32
	// ItemHash is the hash of a related InventoryItemEntity.
	ItemHash uint32
	// ItemInstanceID refers to a specific instance of an item.
	ItemInstanceId int64
	// Quantity is the amount of the item.
	Quantity int32
	// HasCondtionalVisibility determines if the item quantity may be condtionally shown or hideen.
	HasConditionalVisibility bool
}

type MilestoneQuestRewards struct {
	// Items are the items rewarded for completing the quest.
	Items []MilestoneQuestRewardItem
}

type MilestoneRewardCategory struct {
	// CategoryHash is the unique hash of this reward category.
	CategoryHash uint32
	// CategoryIdentifier is unique identifier of this category.
	CategoryIdentifier string
	DisplayProperties  DisplayProperties
	// RewardEntries are milestone-related rewards by the reward category hash.
	RewardEntries map[uint32]MilestoneRewardEntry
	// Order is the recommended order for rendering this category.
	Order int32
}

type MilestoneRewardEntry struct {
	// RewardEntryHash is the unique hash of this reward entry within the milestone.
	RewardEntryHash uint32
	// RewardEntryIdentifier is the unique identifier of this reward entry within the milestone.
	RewardEntryIdentifier string
	// Items are the items and the quantity rewarded.
	Items []ItemQuantity
	// VendorHash is the hash of a related VendorEntity.
	VendorHash        uint32
	DisplayProperties DisplayProperties
	// Order is the ordering of this reward in a given UI.
	Order int32
}

type MilestoneType int32

type MilestoneValue struct {
	// Key is the for the specific milestone or milestone step.
	Key               string
	DisplayProperties DisplayProperties
}

type MilestoneVendor struct {
	// VendorHash is the hash of a related VendorEntity.
	VendorHash uint32
}

type NodeActivationRequirement struct {
	// GridLevel is progression level on the talent grid required to activate this node.
	GridLevel int32
	// MaterialRequirementHashes are the hashes of all related MaterialRequirementSetEntity structs.
	MaterialRequirementHashes []uint32
}

type NodeSocketReplaceResponse struct {
	// SocketTypeHash is the hash of a related SocketTypeEntity.
	SocketTypeHash uint32
	// PlugItemHash is the hash of a related InventoryItemEntity.
	PlugItemHash uint32
}

type NodeStep struct {
	DisplayProperties DisplayProperties
	// StepIndex is the index of this step in the list of steps on TalentNode.
	StepIndex int32
	// NodeStepHash is the hash of this node step, used to uniquely identify this step within a node.
	NodeStepHash uint32
	// InteractionDescription is a localized description of how this step can be interacted with.
	InteractionDescription string
	// DamageType is a classification of the damage type granted by activating this step.
	DamageType DamageType
	// DamageTypeHash is the hash of a related DamageTypeEntity.
	DamageTypeHash uint32
	// NodeActivationRequirement is the requirement for activating this step.
	ActivationRequirement NodeActivationRequirement
	// CanActivateNextStep determines if activating this step also activates the next step.
	CanActivateNextStep bool
	// NextStepIndex is the index of the next step in the list of steps on TalentNode.
	NextStepIndex int32
	// IsNextStepRandom determines if the next chosen step is random.
	IsNextStepRandom bool
	// PerkHashes are the hashes of all related SandboxPerkEntity structs.
	PerkHashes []uint32
	// StartProgressionBarAtProgress is lower bound of the progress bar for this step.
	StartProgressionBarAtProgress int32
	// StatHashes are the hashes of all related StatEntity structs.
	StatHashes []uint32
	// AffectsQuality determines if this node step affects the item's quality.
	AffectsQuality bool
	// StepGroups is the group of talent node steps this step belongs to based on its functionality.
	StepGroups TalentNodeStepGroups
	// AffectsLevel determines if this node step affects the level of the item.
	AffectsLevel bool
	// SocketReplacements is a list of information used to replace socket items with new plugs when this step is activated.
	SocketReplacements []NodeSocketReplaceResponse
}

type ObjectiveDefinition map[uint32]ObjectiveEntity

type ObjectiveDisplayProperties struct {
	// ActivityHash is the hash for a related ActivityEntity.
	ActivityHash uint32
	// DisplayOnItemPreviewScreen determines whether this objective is shown on item preview screens.
	DisplayOnItemPreviewScreen bool
}

type ObjectiveEntity struct {
	DisplayProperties DisplayProperties
	// CompletionValue is the value that must be reached in order for this objective be completed.
	CompletionValue int32
	// Scope determines the most restrictive gating this objective is set to use.
	Scope GatingScope
	// LocationHash is the hash of a related LocationEntity.
	LocationHash uint32
	// AllowNegativeValue determines if the CompletionValue is allowed to go negative.
	AllowNegativeValue bool
	// AllowValueChangeWhenCompleted determines whether this objective can be uncompleted by losing progress.
	AllowValueChangeWhenCompleted bool
	// IsCountingDownward determines if completion of this objective means having a value less than or equal to CompletionValue.
	IsCountingDownward bool
	// ValueStyle is the UI style applied to this objective.
	ValueStyle UnlockValueUIStyle
	// ProgressDescription is the description on this objective's progress bar.
	ProgressDescription string
	// Perks are the conditions for enabling this objective's perks.
	Perks ObjectivePerkEntry
	// Stats are the condtions for modifying a player's stats in this objective.
	Stats ObjectiveStatEntry
	// MinimumVisibilityThreshold is the minimum value that this objective's progression should be shown.
	MinimumVisibilityThreshold int32
	// AllowOvercompletion determines if this objective's progress will continue beyond completion requirements.
	AllowOvercompletion bool
	// ShowValueOnComplete determines if the progression value should be shown in the UI after it's complete.
	ShowValueOnComplete bool
	// CompletedValueStyle is the style to use when the objective is completed.
	CompletedValueStyle UnlockValueUIStyle
	// InProgressValueStyle is the style to use when the objective is still in progress.
	InProgressValueStyle UnlockValueUIStyle
	EntityMetadata
}

type ObjectiveGrantStyle int32

type ObjectivePerkEntry struct {
	// PerkHash is the hash of a related SandboxPerkEntity.
	PerkHash uint32
	// Style is the classification of when this perk is granted in relation to an objective's progress.
	Style ObjectiveGrantStyle
}

type ObjectiveProgress struct {
	// ObjectiveHash is the hash of a related ObjectiveEntity.
	ObjectiveHash uint32
	// DestinationHash is the hash of a related DestinationEntity.
	DestinationHash uint32
	// ActivityHash is the hash of a related ActivityEntity.
	ActivityHash uint32
	// Progress is the numeric value of progress on this objective.
	Progress int32
	// CompletionValue is the numeric value of progress needed to complete this objective.
	CompletionValue int32
	// Complete determines if this objective is completed.
	Complete bool
	// Visible determines if this objective is visible in-game.
	Visible bool
}

type ObjectiveStatEntry struct {
	// Stat is the stat being modified the value used.
	Stat ItemInvestmentStat
	// Style is the classification of when this stat is granted in relation to an objective's progress.
	Style ObjectiveGrantStyle
}

type ParentItemOverride struct {
	// AdditionalEquipRequirementsDisplayStrings are localized strings
	// that describe additional requirements for equipping the parent item.
	AdditionalEquipRequirementsDisplayStrings []string
	// PIPIcon is the icon to show when viewing an item that has this plug socketed.
	PipIcon string
}

type PlaceDefinition map[uint32]PlaceEntity

type PlaceEntity struct {
	DisplayProperties DisplayProperties
	EntityMetadata
}

type PlugAvailabilityMode int32

type PlugRule struct {
	// FailureMessage is the localized string to show if this rule fails.
	FailureMessage string
}

type PlugSetDefinition map[uint32]PlugSetEntity

type PlugSetEntity struct {
	DisplayProperties DisplayProperties
	// ReusuablePlugItems are the list of pre-determined plugs that be inserted in this socket.
	ReusablePlugItems []ItemSocketEntryPlugItemRandomized
	// IsFakePlugSet determines if this plug set if for debugging.
	IsFakePlugSet bool
	EntityMetadata
}

type PlugUIStyles int32

type PlugWhitelistEntry struct {
	// CategoryHash is the hash of this plug's category. Meant to be compared to PlugEntity.PlugCategoryHash.
	CategoryHash uint32
	// CategoryIdentifier is the identifier for this category.
	CategoryIdentifier string
	// ReinitializationPossiblePlugHashes is a list of hashes of InventoryItemEntity structs that describe plug items.
	ReinitializationPossiblePlugHashes []uint32
}

type Position struct {
	X, Y, Z int32
}

type PowerCapDefinition map[uint32]PowerCapEntity

type PowerCapEntity struct {
	// PowerCap is the raw value for a power cap.
	PowerCap int32
	EntityMetadata
}

type PresentationChildBlock struct {
	// PresentationNodeType is a classification of this presentation node.
	PresentationNodeType PresentationNodeType
	// ParentPresentationNodeHashes are the hashes for all related PresentationNodeEntity structs.
	ParentPresentationNodeHashes []uint32
	// DisplayStyle is a classification of the display style of this presentation node.
	DisplayStyle PresentationDisplayStyle
}

type PresentationDisplayStyle int32

type PresentationNodeChildEntry struct {
	// PresentationNodeHash is the hash of a related PresentationNodeEntity.
	PresentationNodeHash uint32
}

type PresentationNodeChildrenBlock struct {
	PresentationNodes []PresentationNodeChildEntry
	Collectibles      []PresentationNodeCollectibleChildEntry
	Records           []PresentationNodeRecordChildEntry
	Metrics           []PresentationNodeMetricChildEntry
}

type PresentationNodeCollectibleChildEntry struct {
	// CollectibleHash is the hash of a related CollectibleEntity.
	CollectibleHash uint32
}

type PresentationNodeComponent struct {
	// State is the state of this component.
	State PresentationNodeState
	// Objective is the progress for an objective in the presentation node.
	Objective ObjectiveProgress
	// ProgressValue is how much of the presentation node is completed so far.
	ProgressValue int32
	// CompletionValue is the value at which the presentation node is considered complete.
	CompletionValue int32
	// RecordCategoryScore is the current score of the record category the presentation node represents.
	RecordCategoryScore int32
}

type PresentationNodeDefinition map[uint32]PresentationNodeEntity

type PresentationNodeEntity struct {
	DisplayProperties DisplayProperties
	// OriginalIcon is the original icon for this presentation node.
	OriginalIcon string
	// RootViewIcon is the icon meant to be shown on the entry screen for this presentation node.
	RootViewIcon string
	NodeType     PresentationNodeType
	// Scope indicates the scope of this presentation node's state.
	Scope Scope
	// ObjectiveHash is the hash of a related ObjectiveEntity.
	ObjectiveHash uint32
	// CompletionRecordHash is the hash of a related RecordEntity.
	CompletionRecordHash uint32
	// Children are presentation nodes contained in this presentation node.
	Children PresentationNodeChildrenBlock
	// DisplayStyle is a hint for how to display this presentation node when it's shown in a list.
	DisplayStyle PresentationDisplayStyle
	// ScreenStyle is a hint for how to display this presentation node when it's shown in its own detail screen.
	ScreenStyle PresentationScreenStyle
	// Requirements are the requirements for being able to interact with this presentation node.
	Requirements PresentationNodeRequirementsBlock
	// DisableChildSubscreenNavigation determines if this presentation node's children cannot be inspected.
	DisableChildSubscreenNavigation bool
	MaxCategoryRecordScore          int32
	PresentationNodeType            PresentationNodeType
	TraitIds                        []string
	TraitHashes                     []uint32
	// ParentNodeHashes are the hashes of presentation nodes that this presentation node as a child.
	ParentNodeHashes []uint32
	EntityMetadata
}

type PresentationNodeMetricChildEntry struct {
	// MetricHash is the hash of a related MetricEntity.
	MetricHash uint32
}

type PresentationNodeRecordChildEntry struct {
	// RecordHash is the hash of a related RecordEntity.
	RecordHash uint32
}

type PresentationNodeRequirementsBlock struct {
	// EntitlementUnavailableMessage is the localized string to show if this node is inaccessible due to entitlements.
	EntitlementUnavailableMessage string
}

type PresentationNodeState int32

type PresentationNodeType int32

type PresentationNodesComponent struct {
	// Nodes are presentation components by the hash of a related PresentationNodeEntity.
	Nodes map[uint32]PresentationNodeComponent
}

type PresentationScreenStyle int32

type ProgressionDefinition map[uint32]ProgressionEntity

type ProgressionDisplayProperties struct {
	// DisplayUnitsName is a localized string that display how experience is gained.
	DisplayUnitsName string
	DisplayProperties
}

type ProgressionEntity struct {
	DisplayProperties ProgressionDisplayProperties
	// Scope indicates the source of the progression's live data.
	Scope ProgressionScope
	// RepeatLastStep indicates if the last step of a progression can be indefinitely repeated.
	RepeatLastStep bool
	// Source is the localized description of how to earn this progression.
	Source string
	// Steps are the individual steps to complete this progression.
	Steps []ProgressionStep
	// Visible determines if the progression should be shown to users.
	Visible bool
	// FactionHash is the hash of a related FactionEntity.
	FactionHash uint32
	// Color is the RGB-valued related to this progression.
	Color Color
	// RankIcon is the icon used in the Companion app to display a progression's rank value.
	RankIcon string
	// RewardItems are the items rewarded for completing are steps.
	RewardItems []ProgressionRewardItemQuantity
	EntityMetadata
}

type ProgressionLevelRequirementDefinition map[uint32]ProgressionLevelRequirementEntity

type ProgressionLevelRequirementEntity struct {
	// RequirementCurve is the curve of level requirements, weighted by this progression level.
	RequirementCurve []InterpolationPointFloat
	// ProgressionHash is the hash for a related ProgressionEntity.
	ProgressionHash uint32
	EntityMetadata
}

type ProgressionReward struct {
	// ProgressionMappingHash is the hash of a related ProgressionMapping.
	// TODO(paranoiacblack): It is unclear how to obtain a ProgressionMapping through the Bungie.net API.
	ProgressionMappingHash uint32
	// Amount is the amount of experience to give to each of the mapped progressions.
	Amount int32
	// ApplyThrottles determines if the internal mechanisms to throttle progression should be applied.
	ApplyThrottles bool
}

type ProgressionRewardItemAcquisitionBehavior int32

type ProgressionRewardItemQuantity struct {
	RewardAtProgressionLevel  int32
	AcquisitionBehavior       ProgressionRewardItemAcquisitionBehavior
	UiDisplayStyle            string
	ClaimUnlockDisplayStrings []string
	// ItemHash is the hash of a related InventoryItemEntity.
	ItemHash                 uint32
	ItemInstanceId           int64
	Quantity                 int32
	HasConditionalVisibility bool
}

type ProgressionScope int32

type ProgressionStep struct {
	// StepName is the localized text describing this step of the progression.
	StepName string
	// DisplayEffectType is a classification of effects to show when this progression goes to the next step.
	DisplayEffectType ProgressionStepDisplayEffect
	// ProgressTotal is the total amount of progression needed to reach this step.
	ProgressTotal int32
	// RewardItems is a list of items rewarded for reaching this step.
	RewardItems []ItemQuantity
	// Icon is a specific icon for this step.
	Icon string
}

type ProgressionStepDisplayEffect int32

type Race int32

type RaceDefinition map[uint32]RaceEntity

type RaceEntity struct {
	DisplayProperties DisplayProperties
	// RaceType is the classification of this race.
	RaceType Race
	// GenderedRaceNames are the names of this race by gender name.
	GenderedRaceNames map[GenderName]string
	// GenderedRaceNames are the name of this race by the hash of a GenderEntity.
	GenderedRaceNamesByGenderHash map[uint32]string
	EntityMetadata
}

type RecordCompletionBlock struct {
	// PartialCompletionObjectiveCountThreshold is the numbers of objectives that must be completed before the record is completed.
	PartialCompletionObjectiveCountThreshold int32
	// ScoreValue is the amount of triumph points awarded for completing this record.
	ScoreValue int32
	// ShouldFireToast determines if completing this record shows a toast-style pop-up in a given UI.
	ShouldFireToast bool
	// ToastStyle is a classification of record-related toast-style pop-ups.
	ToastStyle RecordToastStyle
}

type RecordDefinition map[uint32]RecordEntity

type RecordEntity struct {
	DisplayProperties DisplayProperties
	// Scope indicates if this record's state is per-character or account-wide.
	Scope            Scope
	PresentationInfo PresentationChildBlock
	// LoreHash is the hash of a related LoreEntity.
	LoreHash uint32
	// ObjectiveHashes are the hashes of all related ObjectiveEntity structs.
	ObjectiveHashes  []uint32
	RecordValueStyle RecordValueStyle
	ForTitleGilding  bool
	TitleInfo        RecordTitleBlock
	CompletionInfo   RecordCompletionBlock
	StateInfo        RecordStateBlock
	Requirements     PresentationNodeRequirementsBlock
	ExpirationInfo   RecordExpirationBlock
	// IntervalInfo is the set of interval objectives for this record.
	IntervalInfo RecordIntervalBlock
	// RewardItems are the list of items earned for achieving this record.
	RewardItems          []ItemQuantity
	PresentationNodeType PresentationNodeType
	TraitIds             []string
	TraitHashes          []uint32
	// ParentNodeHashes are the hashes of presentation nodes that this record as a child.
	ParentNodeHashes []uint32
	EntityMetadata
}

type RecordExpirationBlock struct {
	// HasExpiration determines if the record expires.
	HasExpiration bool
	// Description is the localized description of the expiration time of a record.
	Description string
	// Icon is the path to an icon to show when this record expires.
	Icon string
}

type RecordIntervalBlock struct {
	// IntervalObjectives are a list of objectives per interval.
	IntervalObjectives []RecordIntervalObjective
	// IntervalRewards are a list of rewards per interval.
	IntervalRewards                      []RecordIntervalRewards
	OriginalObjectiveArrayInsertionIndex int32
}

type RecordIntervalObjective struct {
	// IntervalObjectiveHash is the hash of a related ObjectiveEntity.
	IntervalObjectiveHash uint32
	// IntervalScoreValue is the triumph score awarded for completing this interval objective.
	IntervalScoreValue int32
}

type RecordIntervalRewards struct {
	// IntervalRewardItems are a list of items and their quantities rewarded for completing this record interval.
	IntervalRewardItems []ItemQuantity
}

type RecordStateBlock struct {
	FeaturedPriority int32
	// ObscuredString is the localized string to show if this record is in an obscured state.
	ObscuredString string
}