/// <summary>
/// Initializes a new instance of the <see cref="DestinyDefinitionsDestinyInventoryBucketDefinition" /> class.
/// </summary>
/// <param name="DisplayProperties">DisplayProperties.</param>
/// <param name="Scope">Where the bucket is found. 0 = Character, 1 = Account.</param>
/// <param name="Category">An enum value for what items can be found in the bucket. See the BucketCategory enum for more details..</param>
/// <param name="BucketOrder">Use this property to provide a quick-and-dirty recommended ordering for buckets in the UI. Most UIs will likely want to forsake this for something more custom and manual..</param>
/// <param name="ItemCount">The maximum # of item \"slots\" in a bucket. A slot is a given combination of item + quantity. For instance, a Weapon will always take up a single slot, and always have a quantity of 1. But a material could take up only a single slot with hundreds of quantity..</param>
/// <param name="Location">Sometimes, inventory buckets represent conceptual \"locations\" in the game that might not be expected. This value indicates the conceptual location of the bucket, regardless of where it is actually contained on the character/account. See ItemLocation for details. Note that location includes the Vault and the Postmaster (both of whom being just inventory buckets with additional actions that can be performed on them through a Vendor).</param>
/// <param name="HasTransferDestination">If TRUE, there is at least one Vendor that can transfer items to/from this bucket. See the DestinyVendorDefinition's acceptedItems property for more information on how transferring works..</param>
/// <param name="Enabled">If True, this bucket is enabled. Disabled buckets may include buckets that were included for test purposes, or that were going to be used but then were abandoned but never removed from content *cough*..</param>
/// <param name="Fifo">if a FIFO bucket fills up, it will delete the oldest item from said bucket when a new item tries to be added to it. If this is FALSE, the bucket will not allow new items to be placed in it until room is made by the user manually deleting items from it. You can see an example of this with the Postmaster's bucket..</param>
/// <param name="Hash">The unique identifier for this entity. Guaranteed to be unique for the type of entity, but not globally. When entities refer to each other in Destiny content, it is this hash that they are referring to..</param>
/// <param name="Index">The index of the entity as it was found in the investment tables..</param>
/// <param name="Redacted">If this is true, then there is an entity with this identifier/type combination, but BNet is not yet allowed to show it. Sorry!.</param>
public DestinyDefinitionsDestinyInventoryBucketDefinition(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition DisplayProperties = default(DestinyDefinitionsCommonDestinyDisplayPropertiesDefinition), DestinyBucketScope Scope = default(DestinyBucketScope), DestinyBucketCategory Category = default(DestinyBucketCategory), int? BucketOrder = default(int?), int? ItemCount = default(int?), DestinyItemLocation Location = default(DestinyItemLocation), bool? HasTransferDestination = default(bool?), bool? Enabled = default(bool?), bool? Fifo = default(bool?), uint? Hash = default(uint?), int? Index = default(int?), bool? Redacted = default(bool?))
{
this.DisplayProperties = DisplayProperties;
this.Scope = Scope;
this.Category = Category;
this.BucketOrder = BucketOrder;
this.ItemCount = ItemCount;
this.Location = Location;
this.HasTransferDestination = HasTransferDestination;
this.Enabled = Enabled;
this.Fifo = Fifo;
this.Hash = Hash;
this.Index = Index;
this.Redacted = Redacted;
}
/// <summary>
/// Initializes a new instance of the <see cref="DestinyEntitiesItemsDestinyItemComponent" /> class.
/// </summary>
/// <param name="ItemHash">The identifier for the item's definition, which is where most of the useful static information for the item can be found..</param>
/// <param name="ItemInstanceId">If the item is instanced, it will have an instance ID. Lack of an instance ID implies that the item has no distinct local qualities aside from stack size..</param>
/// <param name="Quantity">The quantity of the item in this stack. Note that Instanced items cannot stack. If an instanced item, this value will always be 1 (as the stack has exactly one item in it).</param>
/// <param name="BindStatus">If the item is bound to a location, it will be specified in this enum..</param>
/// <param name="Location">An easy reference for where the item is located. Redundant if you got the item from an Inventory, but useful when making detail calls on specific items..</param>
/// <param name="BucketHash">The hash identifier for the specific inventory bucket in which the item is located..</param>
/// <param name="TransferStatus">If there is a known error state that would cause this item to not be transferable, this Flags enum will indicate all of those error states. Otherwise, it will be 0 (CanTransfer)..</param>
/// <param name="Lockable">If the item can be locked, this will indicate that state..</param>
/// <param name="State">A flags enumeration indicating the states of the item: whether it's tracked or locked for example..</param>
public DestinyEntitiesItemsDestinyItemComponent(uint?ItemHash = default(uint?), long?ItemInstanceId = default(long?), int?Quantity = default(int?), DestinyItemBindStatus BindStatus = default(DestinyItemBindStatus), DestinyItemLocation Location = default(DestinyItemLocation), uint?BucketHash = default(uint?), DestinyTransferStatuses TransferStatus = default(DestinyTransferStatuses), bool?Lockable = default(bool?), DestinyItemState State = default(DestinyItemState))
{
this.ItemHash = ItemHash;
this.ItemInstanceId = ItemInstanceId;
this.Quantity = Quantity;
this.BindStatus = BindStatus;
this.Location = Location;
this.BucketHash = BucketHash;
this.TransferStatus = TransferStatus;
this.Lockable = Lockable;
this.State = State;
}