private void AddEditableText(ItemDefinition definition, string title, string name, int sortOrder, int maxLength)
 {
     EditableTextBoxAttribute titleEditor = new EditableTextBoxAttribute(title, sortOrder, maxLength);
     titleEditor.Name = name;
     titleEditor.ContainerName = "seo";
     definition.Add(titleEditor);
 }

        public override void Refine(ItemDefinition currentDefinition)
        {
			if (InstallerVisibility != InstallerHint.Default)
				currentDefinition.Installer = InstallerVisibility;

            base.Refine(currentDefinition);
        }

 // Methods
 public PrefetchData(ItemDefinition itemDefinition, ID parentId)
 {
     Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
     Assert.ArgumentNotNull(parentId, "parentId");
     this._itemDefinition = itemDefinition;
     this._parentId = parentId;
 }

 public void Refine(ItemDefinition currentDefinition, IList<ItemDefinition> allDefinitions)
 {
     if (currentDefinition.ItemType.IsAssignableFrom(typeof (BlogContainer)))
     {
         currentDefinition.AllowedChildFilters.Add(this);
     }
 }

        public DraggableToolbar(ContentItem item, ItemDefinition definition)
        {
            if (definition == null) throw new ArgumentNullException("definition");

            this.currentItem = item;
            this.definition = definition;
        }

		public bool IsUnfiltered(ItemDefinition d)
		{
			if(RemovedTypes == null)
				return true;

			return !RemovedTypes.Any(rt => rt.IsAssignableFrom(d.ItemType));
		}

        public override IDictionary<string, System.Web.UI.Control> AddDefinedEditors(ItemDefinition definition, N2.ContentItem item, System.Web.UI.Control container, System.Security.Principal.IPrincipal user, Type containerTypeFilter, IEnumerable<string> editableNameFilter)
        {
            ItemDefinition cloned = null;

            // add a "wrap in container" checkbox to all parts that are within zones that are not wrapped in a container (BeforeMain, AfterMain).
            if (!definition.IsPage)
            {
                if (!(Defaults.IsContainerWrappable(item.ZoneName) ||
                      Defaults.IsContainerWrappable(System.Web.HttpContext.Current.Request["zoneName"])))
                {
                    cloned = definition.Clone();
                    var isWrappable = cloned.Editables.FirstOrDefault(x => x.Name == "UseContainer");
                    if (isWrappable != null)
                    {
                        cloned.Editables.Remove(isWrappable);
                    }
                }
            }

            if (item is IItemAdapter)
            {
                var result = (item as IItemAdapter).AddDefinedEditors(cloned ?? definition, container, user, containerTypeFilter, editableNameFilter);
                if (result != null)
                    return result;
            }
            return base.AddDefinedEditors(cloned ?? definition, item, container, user, containerTypeFilter, editableNameFilter);
        }

    public void ChangeTemplateThrowsIfNoDbItemFound([Greedy]FakeDataProvider sut, ItemDefinition def, TemplateChangeList changes)
    {
      Action action = () => sut.ChangeTemplate(def, changes, null);

      action.ShouldThrow<InvalidOperationException>()
            .WithMessage("Unable to change item template. The item '{0}' is not found.".FormatWith(def.ID));
    }

        protected virtual void AddChildIDsForContactFacetItem(IDList ids, ItemDefinition itemDefinition, CallContext context)
        {
            var facetName = IDTableHelper.GetFacetName(itemDefinition.ID);
            var contractType = ContactFacetHelper.GetContractTypeForFacet(facetName);
            
            foreach (string memberName in FacetReflectionUtil.NonFacetMemberNames(contractType))
            {
                var id = IDTableHelper.GenerateIdForFacetMember(memberName, itemDefinition.ID,
                            Sitecore.Strategy.Contacts.DataProviders.TemplateIDs.ContactFacetMemberTemplate);

                ids.Add(id);
            }

            foreach (string memberName in FacetReflectionUtil.FacetMemberNames(contractType))
            {
                foreach (
                    string subMemberName in
                        FacetReflectionUtil.NonFacetMemberNames(contractType.GetProperty(memberName).PropertyType))
                {
                    string key = $"{memberName}{NestedFacets.Delimeter}{subMemberName}";

                    var id = IDTableHelper.GenerateIdForFacetMember(key, itemDefinition.ID,
                        Sitecore.Strategy.Contacts.DataProviders.TemplateIDs.ContactFacetMemberTemplate);

                    ids.Add(id);
                }
            }
        }

 public IEnumerable<TemplateDefinition> GetTemplates(ItemDefinition definition)
 {
     return Definitions.GetTemplates(definition.ItemType)
         .AllowedBelow(Definitions.GetDefinition(Selection.SelectedItem), Selection.SelectedItem, Engine.Definitions)
         .Where(t => t.Definition.IsAllowed(ZoneName, User))
         .OrderBy(t => (t.Definition.TemplateKey ?? "Index") == "Index" ? 0 : 1)
         .ThenBy(t => t.Definition.SortOrder);
 }

 public static IEnumerable<TemplateDefinition> AllowedBelow(this IEnumerable<TemplateDefinition> allTemplates, ItemDefinition parentDefinition, ContentItem parentItem, IDefinitionManager definitions)
 {
     foreach (var template in allTemplates)
     {
         if (IsAllowed(template.Definition, parentItem, parentDefinition, definitions))
             yield return template;
     }
 }

 /// <summary>Changes allowed parents on the item definition.</summary>
 /// <param name="currentDefinition">The definition to alter.</param>
 /// <param name="allDefinitions">All definitions.</param>
 public override void Refine(ItemDefinition currentDefinition, IList<ItemDefinition> allDefinitions)
 {
     foreach (ItemDefinition definition in allDefinitions)
     {
         if (IsAssignable(definition.ItemType))
             definition.AddAllowedChild(currentDefinition);
     }
 }

 public override IDList GetChildIDs(ItemDefinition itemDefinition, CallContext context)
 {
     if (itemDefinition != null && itemDefinition.ID == JoinParentId)
     {
         Log.Info(string.Format("GetChildIDs called with itemDefinition id = {0}, name = {1} (BasicDataProvider)", itemDefinition.ID, itemDefinition.Name), this);
     }
     return null;
 }

		public override void Refine(ItemDefinition currentDefinition, IList<ItemDefinition> allDefinitions)
		{
			if (AffectedType != null && !AffectedType.IsAssignableFrom(currentDefinition.ItemType))
				return;

			var containable = currentDefinition.GetNamed(Name);
			currentDefinition.RemoveRange(containable);
		}

        public void SetUp()
        {
            parentDefinition = new ItemDefinition(typeof(DefinitionControllingParent)) { TemplateKey = "List" };
            childDefinition = new ItemDefinition(typeof(DefinitionOppressedChild)) { TemplateKey = "Wide" };

            definitions = MockRepository.GenerateStub<IDefinitionManager>();
            definitions.Expect(d => d.GetDefinitions()).Return(new[] { parentDefinition, childDefinition }).Repeat.Any();
        }

        public void AddVersion(ItemDefinition itemDefinition, VersionUri baseVersion, CallContext context)
        {
            if (DisableSerialization) return;

            Assert.ArgumentNotNull(itemDefinition, "itemDefinition");

            SerializeItemIfIncluded(itemDefinition, "Version Added");
        }

 private static void WriteTitle(TextWriter writer, ItemDefinition definition)
 {
     writer.Write("<span class='title' style='background-image:url(");
     writer.Write(Url.ResolveTokens(definition.IconUrl));
     writer.Write(");'>");
     writer.Write(definition.Title);
     writer.Write("</span>");
 }

		public NotAllowedParentException(ItemDefinition itemDefinition, Type parentType)
			: base("The item '{0}' isn't allowed below a destination of type '{1}'.", 
				itemDefinition.Title,
				parentType.AssemblyQualifiedName)
		{
			this.itemDefinition = itemDefinition;
			this.parentType = parentType;
		}

 public override VersionUriList GetItemVersions(ItemDefinition itemDefinition, CallContext context)
 {
     if (Items.Contains(itemDefinition.ID))
     {
         Log.Info(string.Format("GetItemVersions called with itemDefinition id = {0}, name = {1} (BasicDataProvider)", itemDefinition.ID, itemDefinition.Name), this);
     }
     return null;
 }

 public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
 {
     if (Items.Contains(itemDefinition.ID))
     {
         Log.Info(string.Format("GetItemFields called with itemDefinition id = {0}, name = {1}, version = {2}, language = {3} (BasicDataProvider)", itemDefinition.ID, itemDefinition.Name, versionUri.Version, versionUri.Language.Name), this);
     }
     return null;
 }