/// <summary>
        /// Creates a notecard in the objects folder and specify an item id.
        /// </summary>
        /// <param name="scene"></param>
        /// <param name="itemName"></param>
        /// <param name="itemId"></param>
        /// <param name="assetId"></param>
        /// <param name="userId"></param>
        /// <param name="type">Type of item to create</param>
        /// <returns></returns>
        public static InventoryItemBase CreateInventoryItem(
            Scene scene, string itemName, UUID itemId, UUID assetId, UUID userId, InventoryType type)
        {
            AssetBase asset = null;

            if (type == InventoryType.Notecard)
                asset = AssetHelpers.CreateAsset(scene, userId);
            else if (type == InventoryType.Object)
                asset = AssetHelpers.CreateAsset(assetId, SceneHelpers.CreateSceneObject(1, userId));
            else
                throw new Exception(string.Format("Inventory type {0} not supported", type));

            scene.AssetService.Store(asset);

            InventoryItemBase item = new InventoryItemBase();
            item.Name = itemName;
            item.AssetID = asset.FullID;
            item.ID = itemId;
            item.Owner = userId;
            item.AssetType = asset.Type;
            item.InvType = (int)type;

            InventoryFolderBase folder = scene.InventoryService.GetFolderForType(userId, AssetType.Notecard);
            
            item.Folder = folder.ID;
            scene.AddInventoryItem(item);
            
            return item;
        }

 internal InventoryPage(InventoryType type, StorageType storage, byte size, Item bag = null)
 {
     _type = type;
                 _storage = storage;
                 Size = size;
                 Bag = bag;
 }

 public static InvPayload Create(InventoryType type, params UInt256[] hashes)
 {
     return new InvPayload
     {
         Inventories = hashes.Select(p => new InventoryVector { Type = type, Hash = p }).ToArray()
     };
 }

 public InventoryPouch(InventoryType type, ushort[] legal, int maxcount, int offset, int size = -1)
 {
     Type = type;
     LegalItems = legal;
     MaxCount = maxcount;
     Offset = offset;
     PouchDataSize = size > -1 ? size : legal.Length;
 }

 public InventoryItem (ushort iD, byte index, uint count, uint flag, uint price, ushort extra, InventoryType loc)
 {
     ID = iD;
     Index = index;
     Count = count;
     Flag = flag;
     Price = price;
     Extra = extra;
     Location = loc;
 }

        public Inventory(Character pOwner, InventoryType invtype, byte slotLimit = 96)
        {
            Items = new Dictionary<byte, Item>(slotLimit);
              Equips = new Dictionary<short, Equip>();

              if ((int)invtype >= 2 || (int)invtype <= 5)
                  ItemAmounts = new Dictionary<int, short>();

              SlotLimit = slotLimit;
              InventoryType = invtype;
              Owner = pOwner;
        }

        public virtual InventoryFolderBase GetFolderForType(UUID principalID, InventoryType invType, AssetType type)
        {
            Dictionary<string,object> ret = MakeRequest("GETFOLDERFORTYPE",
                    new Dictionary<string,object> {
                        { "PRINCIPAL", principalID.ToString() },
                        { "TYPE", ((int)type).ToString() },
                        { "INVTYPE", ((int)invType).ToString() }
                    });

            if (ret == null)
                return null;
            if (ret.Count == 0)
                return null;

            return BuildFolder((Dictionary<string, object>)ret["folder"]);
        }

 public static InventoryItem CreateInventoryItem(InventoryType type, UUID id)
 {
     switch (type)
     {
         case InventoryType.Texture: return new InventoryTexture(id);
         case InventoryType.Sound: return new InventorySound(id);
         case InventoryType.CallingCard: return new InventoryCallingCard(id);
         case InventoryType.Landmark: return new InventoryLandmark(id);
         case InventoryType.Object: return new InventoryObject(id);
         case InventoryType.Notecard: return new InventoryNotecard(id);
         case InventoryType.Category: return new InventoryCategory(id);
         case InventoryType.LSL: return new InventoryLSL(id);
         case InventoryType.Snapshot: return new InventorySnapshot(id);
         case InventoryType.Attachment: return new InventoryAttachment(id);
         case InventoryType.Wearable: return new InventoryWearable(id);
         case InventoryType.Animation: return new InventoryAnimation(id);
         case InventoryType.Gesture: return new InventoryGesture(id);
         default: return new InventoryItem(type, id);
     }
 }

        /// <summary>
        /// Creates a notecard in the objects folder and specify an item id.
        /// </summary>
        /// <param name="scene"></param>
        /// <param name="itemName"></param>
        /// <param name="itemId"></param>
        /// <param name="itemType"></param>
        /// <param name="asset">The serialized asset for this item</param>
        /// <param name="userId"></param>
        /// <returns></returns>
        private static InventoryItemBase AddInventoryItem(
            Scene scene, string itemName, UUID itemId, InventoryType itemType, AssetBase asset, UUID userId)
        {
            scene.AssetService.Store(asset);

            InventoryItemBase item = new InventoryItemBase();
            item.Name = itemName;
            item.AssetID = asset.FullID;
            item.ID = itemId;
            item.Owner = userId;
            item.AssetType = asset.Type;
            item.InvType = (int)itemType;

            InventoryFolderBase folder = scene.InventoryService.GetFolderForType(userId, (AssetType)asset.Type);

            item.Folder = folder.ID;
            scene.AddInventoryItem(item);

            return item;
        }

        public Inventory(Int32 x, Int32 y, Int32 numPages)
        {
            _map = null;
            _gridSpace = null;
            _inventoryType = InventoryType.None;
            _owner = null;
            _doubleCheckBlock = false;
            _dirty = false;
            _x = x;
            _y = y;
            _numPages = numPages;

            if (_x <= 0)
                _x = 1;

            if (_y <= 0)
                _y = 1;

            if (_numPages <= 0)
                _numPages = 1;

            CreateGridSpace();
        }

 public TaskItemReceivedEventArgs(UUID itemID, UUID folderID, UUID creatorID, UUID assetID, InventoryType type)
 {
     this.m_ItemID = itemID;
     this.m_FolderID = folderID;
     this.m_CreatorID = creatorID;
     this.m_AssetID = assetID;
     this.m_Type = type;
 }

        /// <summary>
        /// Creates inventory link to another inventory item or folder
        /// </summary>
        /// <param name="folderID">Put newly created link in folder with this UUID</param>
        /// <param name="itemID">Original item's UUID</param>
        /// <param name="name">Name</param>
        /// <param name="description">Description</param>
        /// <param name="assetType">Asset Type</param>
        /// <param name="invType">Inventory Type</param>
        /// <param name="transactionID">Transaction UUID</param>
        /// <param name="callback">Method to call upon creation of the link</param>
        public void CreateLink(UUID folderID, UUID itemID, string name, string description, AssetType assetType, InventoryType invType, UUID transactionID, ItemCreatedCallback callback)
        {
            LinkInventoryItemPacket create = new LinkInventoryItemPacket();
            create.AgentData.AgentID = Client.Self.AgentID;
            create.AgentData.SessionID = Client.Self.SessionID;

            create.InventoryBlock.CallbackID = RegisterItemCreatedCallback(callback);
            create.InventoryBlock.FolderID = folderID;
            create.InventoryBlock.TransactionID = transactionID;
            create.InventoryBlock.OldItemID = itemID;
            create.InventoryBlock.Type = (sbyte)assetType;
            create.InventoryBlock.InvType = (sbyte)invType;
            create.InventoryBlock.Name = Utils.StringToBytes(name);
            create.InventoryBlock.Description = Utils.StringToBytes(description);
            
            Client.Network.SendPacket(create);
        }

 /// <summary>
 /// 
 /// </summary>
 /// <returns></returns>
 public InventoryItem(SerializationInfo info, StreamingContext ctxt)
     : base(info, ctxt)
 {
     AssetUUID = (UUID)info.GetValue("AssetUUID", typeof(UUID));
     Permissions = (Permissions)info.GetValue("Permissions", typeof(Permissions));
     AssetType = (AssetType)info.GetValue("AssetType", typeof(AssetType));
     InventoryType = (InventoryType)info.GetValue("InventoryType", typeof(InventoryType));
     CreatorID = (UUID)info.GetValue("CreatorID", typeof(UUID));
     Description = (string)info.GetValue("Description", typeof(string));
     GroupID = (UUID)info.GetValue("GroupID", typeof(UUID));
     GroupOwned = (bool)info.GetValue("GroupOwned", typeof(bool));
     SalePrice = (int)info.GetValue("SalePrice", typeof(int));
     SaleType = (SaleType)info.GetValue("SaleType", typeof(SaleType));
     Flags = (uint)info.GetValue("Flags", typeof(uint));
     CreationDate = (DateTime)info.GetValue("CreationDate", typeof(DateTime));
     LastOwnerID = (UUID)info.GetValue("LastOwnerID", typeof(UUID));
 }

        /// <summary>
        /// Create an inventory item and upload asset data
        /// </summary>
        /// <param name="data">Asset data</param>
        /// <param name="name">Inventory item name</param>
        /// <param name="description">Inventory item description</param>
        /// <param name="assetType">Asset type</param>
        /// <param name="invType">Inventory type</param>
        /// <param name="folderID">Put newly created inventory in this folder</param>
        /// <param name="callback">Delegate that will receive feedback on success or failure</param>
        public void RequestCreateItemFromAsset(byte[] data, string name, string description, AssetType assetType,
            InventoryType invType, UUID folderID, ItemCreatedFromAssetCallback callback)
        {
            Permissions permissions = new Permissions();
            permissions.EveryoneMask = PermissionMask.None;
            permissions.GroupMask = PermissionMask.None;
            permissions.NextOwnerMask = PermissionMask.All;

            RequestCreateItemFromAsset(data, name, description, assetType, invType, folderID, permissions, callback);
        }

 public override InventoryFolderBase GetFolderForType(UUID principalID, InventoryType invType, AssetType type)
 {
     InventoryFolderBase invFolder = GetRootFolder (principalID);
     switch (type)
     {
         case AssetType.Object:
             InventoryFolderBase objFolder = GetFolderType (principalID, invFolder.ID, type);
             if (objFolder == null)
                 objFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Object, "Foreign Objects");
             return objFolder;
         case AssetType.LSLText:
             InventoryFolderBase lslFolder = GetFolderType (principalID, invFolder.ID, type);
             if (lslFolder == null)
                 lslFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.LSLText, "Foreign Scripts");
             return lslFolder;
         case AssetType.Notecard:
             InventoryFolderBase ncFolder = GetFolderType (principalID, invFolder.ID, type);
             if (ncFolder == null)
                 ncFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Notecard, "Foreign Notecards");
             return ncFolder;
         case AssetType.Animation:
             InventoryFolderBase aniFolder = GetFolderType (principalID, invFolder.ID, type);
             if (aniFolder == null)
                 aniFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Notecard, "Foreign Animiations");
             return aniFolder;
         case AssetType.Bodypart:
         case AssetType.Clothing:
             InventoryFolderBase clothingFolder = GetFolderType (principalID, invFolder.ID, AssetType.Clothing);
             if (clothingFolder == null)
                 clothingFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Clothing, "Foreign Clothing");
             return clothingFolder;
         case AssetType.Gesture:
             InventoryFolderBase gestureFolder = GetFolderType (principalID, invFolder.ID, type);
             if (gestureFolder == null)
                 gestureFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Gesture, "Foreign Gestures");
             return gestureFolder;
         case AssetType.Landmark:
             InventoryFolderBase lmFolder = GetFolderType (principalID, invFolder.ID, type);
             if (lmFolder == null)
                 lmFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Landmark, "Foreign Landmarks");
             return lmFolder;
         case AssetType.SnapshotFolder:
         case AssetType.Texture:
             InventoryFolderBase textureFolder = GetFolderType (principalID, invFolder.ID, type);
             if (textureFolder == null)
                 textureFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Landmark, "Foreign Textures");
             return textureFolder;
         case AssetType.Sound:
             InventoryFolderBase soundFolder = GetFolderType (principalID, invFolder.ID, type);
             if (soundFolder == null)
                 soundFolder = CreateFolder (principalID, invFolder.ID, (int)AssetType.Landmark, "Foreign Sounds");
             return soundFolder;
         default:
             return invFolder;
     }
 }

		public InventoryVector(InventoryType type, uint256 hash)
		{
			Type = type;
			Hash = hash;
		}

            } // @ public uint GetItemCountByIndex(byte index, InventoryType location)

            /// <summary>
            /// Will get an item ID by index in the passed location
            /// </summary>
            /// <param name="index">Index of the item in your inventory</param>
            /// <param name="location">InventoryType of the location to search (SINGLE LOCATION)</param>
            public int GetItemIDByIndex (int index, InventoryType location)
            {
                if (IsSet(location, InventoryType.None))
                    return 0;

                DoRangeChecks(index, location);
                InventoryItem item = GetItem(index, location);
                if (item != null)
                    return item.ID;
                return 0;
            } // @ public int GetItemIDByIndex(byte index, InventoryType location)

 public static IEnumerable<EquipSlot> GetInventorySlotsByEquipSlot(InventoryType type)
 {
     switch (type)
     {
         case InventoryType.Head:
             yield return EquipSlot.Head;
             break;
         case InventoryType.Neck:
             yield return EquipSlot.Neck;
             break;
         case InventoryType.Shoulders:
             yield return EquipSlot.Shoulders;
             break;
         case InventoryType.Body:
             yield return EquipSlot.Body;
             break;
         case InventoryType.Chest:
         case InventoryType.Robe:
             yield return EquipSlot.Chest;
             break;
         case InventoryType.Waist:
             yield return EquipSlot.Waist;
             break;
         case InventoryType.Legs:
             yield return EquipSlot.Legs;
             break;
         case InventoryType.Feet:
             yield return EquipSlot.Feet;
             break;
         case InventoryType.Wrists:
             yield return EquipSlot.Wrists;
             break;
         case InventoryType.Hands:
             yield return EquipSlot.Hands;
             break;
         case InventoryType.Finger:
             yield return EquipSlot.Finger1;
             yield return EquipSlot.Finger2;
             break;
         case InventoryType.Trinket:
             yield return EquipSlot.Trinket1;
             yield return EquipSlot.Trinket2;
             break;
         case InventoryType.Weapon:
             yield return EquipSlot.MainHand;
             yield return EquipSlot.OffHand;
             break;
         case InventoryType.Shield:
         case InventoryType.WeaponOffHand:
         case InventoryType.Holdable:
             yield return EquipSlot.OffHand;
             break;
         case InventoryType.Ranged:
         case InventoryType.Thrown:
         case InventoryType.RangedRight:
         case InventoryType.Relic:
             yield return EquipSlot.Ranged;
             break;
         case InventoryType.Cloak:
             yield return EquipSlot.Back;
             break;
         case InventoryType.TwoHandedWeapon:
             {
                 yield return EquipSlot.MainHand;
                 // TODO: Check for titan's grip
                 //bool flag = Manager.LocalPlayer.Class == WoWClass.Warrior && WoWScript.Execute<int>(InventoryManager.#a(61464), 4u) > 0;
                 //var mainHand = Manager.LocalPlayer.GetEquippedItem(EquipSlot.MainHand);
                 //if (flag && mainHand != null && mainHand.ItemInfo.InventoryType == InventoryType.TwoHandedWeapon)
                 //{
                 //    yield return EquipSlot.OffHand;
                 //}
                 break;
             }
         case InventoryType.Bag:
         case InventoryType.Quiver:
             yield return EquipSlot.Bag1;
             yield return EquipSlot.Bag2;
             yield return EquipSlot.Bag3;
             yield return EquipSlot.Bag4;
             break;
         case InventoryType.Tabard:
             yield return EquipSlot.Tabard;
             break;
         case InventoryType.WeaponMainHand:
             yield return EquipSlot.MainHand;
             break;
     }
 }

 public static string InventoryTypeToString(InventoryType type)
 {
     return _InventoryTypeNames[(int)type];
 }

        public void RequestCreateItemFromAsset(byte[] data, string name, string description, AssetType assetType,
            InventoryType invType, LLUUID folderID, ItemCreatedFromAssetCallback callback)
        {
            if (_Client.Network.CurrentSim == null || _Client.Network.CurrentSim.Caps == null)
                throw new Exception("NewFileAgentInventory capability is not currently available");

            Uri url = _Client.Network.CurrentSim.Caps.CapabilityURI("NewFileAgentInventory");

            if (url != null)
            {
                LLSDMap query = new LLSDMap();
                query.Add("folder_id", LLSD.FromUUID(folderID));
                query.Add("asset_type", LLSD.FromString(AssetTypeToString(assetType)));
                query.Add("inventory_type", LLSD.FromString(InventoryTypeToString(invType)));
                query.Add("name", LLSD.FromString(name));
                query.Add("description", LLSD.FromString(description));

                byte[] postData = StructuredData.LLSDParser.SerializeXmlBytes(query);

                // Make the request
                CapsClient request = new CapsClient(url);
                request.OnComplete += new CapsClient.CompleteCallback(CreateItemFromAssetResponse);
                request.UserData = new KeyValuePair<ItemCreatedFromAssetCallback, byte[]>(callback, data);
                request.StartRequest(postData);
            }
            else
            {
                throw new Exception("NewFileAgentInventory capability is not currently available");
            }
        }