text:
``` diff
+namespace System.Web.UI.Design {
+    public class AppSettingsExpressionEditor : ExpressionEditor {
+        public AppSettingsExpressionEditor();
+        public override object EvaluateExpression(string expression, object parseTimeData, Type propertyType, IServiceProvider serviceProvider);
+        public override ExpressionEditorSheet GetExpressionEditorSheet(string expression, IServiceProvider serviceProvider);
+    }
+    public class AsyncPostBackTriggerControlIDConverter : StringConverter {
+        public AsyncPostBackTriggerControlIDConverter();
+        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
+        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context);
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
+    }
+    public class AsyncPostBackTriggerEventNameConverter : StringConverter {
+        public AsyncPostBackTriggerEventNameConverter();
+        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
+        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context);
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
+    }
+    public class CalendarDataBindingHandler : DataBindingHandler {
+        public CalendarDataBindingHandler();
+        public override void DataBindControl(IDesignerHost designerHost, Control control);
+    }
+    public sealed class ClientScriptItem {
+        public ClientScriptItem(string text, string source, string language, string type, string id);
+        public string Id { get; }
+        public string Language { get; }
+        public string Source { get; }
+        public string Text { get; }
+        public string Type { get; }
+    }
+    public sealed class ClientScriptItemCollection : ReadOnlyCollectionBase {
+        public ClientScriptItemCollection(ClientScriptItem[] clientScriptItems);
+    }
+    public class CollectionEditorBase : CollectionEditor {
+        public CollectionEditorBase(Type type);
+        protected override CollectionEditor.CollectionForm CreateCollectionForm();
+    }
+    public sealed class ColorBuilder {
+        public static string BuildColor(IComponent component, Control owner, string initialColor);
+    }
+    public class ConnectionStringEditor : UITypeEditor {
+        public ConnectionStringEditor();
+        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value);
+        public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context);
+        protected virtual string GetProviderName(object instance);
+        protected virtual void SetProviderName(object instance, DesignerDataConnection connection);
+    }
+    public class ConnectionStringsExpressionEditor : ExpressionEditor {
+        public ConnectionStringsExpressionEditor();
+        public override object EvaluateExpression(string expression, object parseTimeData, Type propertyType, IServiceProvider serviceProvider);
+        public override ExpressionEditorSheet GetExpressionEditorSheet(string expression, IServiceProvider serviceProvider);
+    }
+    public class ContainerControlDesigner : ControlDesigner {
+        public ContainerControlDesigner();
+        public override bool AllowResize { get; }
+        public virtual string FrameCaption { get; }
+        public virtual Style FrameStyle { get; }
+        protected virtual bool NoWrap { get; }
+        protected virtual void AddDesignTimeCssAttributes(IDictionary styleAttributes);
+        public virtual IDictionary GetDesignTimeCssAttributes();
+        public override string GetDesignTimeHtml(DesignerRegionCollection regions);
+        public override string GetEditableDesignerRegionContent(EditableDesignerRegion region);
+        public override string GetPersistenceContent();
+        public override void SetEditableDesignerRegionContent(EditableDesignerRegion region, string content);
+    }
+    public class ContentDefinition {
+        public ContentDefinition(string id, string content, string designTimeHtml);
+        public string ContentPlaceHolderID { get; }
+        public string DefaultContent { get; }
+        public string DefaultDesignTimeHtml { get; }
+    }
+    public enum ContentDesignerState {
+        ShowDefaultContent = 0,
+        ShowUserContent = 1,
+    }
+    public class ControlDesigner : HtmlControlDesigner {
+        public ControlDesigner();
+        public override DesignerActionListCollection ActionLists { get; }
+        public virtual bool AllowResize { get; }
+        public virtual DesignerAutoFormatCollection AutoFormats { get; }
+        protected virtual bool DataBindingsEnabled { get; }
+        protected ControlDesignerState DesignerState { get; }
+        protected object DesignTimeElementView { get; }
+        public virtual bool DesignTimeHtmlRequiresLoadComplete { get; }
+        protected internal virtual bool HidePropertiesInTemplateMode { get; }
+        public virtual string ID { get; set; }
+        protected bool InTemplateMode { get; }
+        public bool IsDirty { get; set; }
+        public bool ReadOnly { get; set; }
+        protected WebFormsRootDesigner RootDesigner { get; }
+        protected IControlDesignerTag Tag { get; }
+        public virtual TemplateGroupCollection TemplateGroups { get; }
+        protected virtual bool UsePreviewControl { get; }
+        public Control ViewControl { get; set; }
+        public virtual bool ViewControlCreated { get; set; }
+        protected virtual bool Visible { get; }
+        protected string CreateErrorDesignTimeHtml(string errorMessage);
+        protected string CreateErrorDesignTimeHtml(string errorMessage, Exception e);
+        protected string CreatePlaceHolderDesignTimeHtml();
+        protected string CreatePlaceHolderDesignTimeHtml(string instruction);
+        protected virtual Control CreateViewControl();
+        public Rectangle GetBounds();
+        public virtual string GetDesignTimeHtml();
+        public virtual string GetDesignTimeHtml(DesignerRegionCollection regions);
+        public static DesignTimeResourceProviderFactory GetDesignTimeResourceProviderFactory(IServiceProvider serviceProvider);
+        public virtual string GetEditableDesignerRegionContent(EditableDesignerRegion region);
+        protected virtual string GetEmptyDesignTimeHtml();
+        protected virtual string GetErrorDesignTimeHtml(Exception e);
+        public virtual string GetPersistenceContent();
+        public virtual string GetPersistInnerHtml();
+        public ViewRendering GetViewRendering();
+        public static ViewRendering GetViewRendering(Control control);
+        public static ViewRendering GetViewRendering(ControlDesigner designer);
+        public override void Initialize(IComponent component);
+        public void Invalidate();
+        public void Invalidate(Rectangle rectangle);
+        public static void InvokeTransactedChange(IComponent component, TransactedChangeCallback callback, object context, string description);
+        public static void InvokeTransactedChange(IComponent component, TransactedChangeCallback callback, object context, string description, MemberDescriptor member);
+        public static void InvokeTransactedChange(IServiceProvider serviceProvider, IComponent component, TransactedChangeCallback callback, object context, string description, MemberDescriptor member);
+        public bool IsPropertyBound(string propName);
+        public void Localize(IDesignTimeResourceWriter resourceWriter);
+        public virtual void OnAutoFormatApplied(DesignerAutoFormat appliedAutoFormat);
+        protected override void OnBindingsCollectionChanged(string propName);
+        protected virtual void OnClick(DesignerRegionMouseEventArgs e);
+        public virtual void OnComponentChanged(object sender, ComponentChangedEventArgs ce);
+        public virtual void OnComponentChanging(object sender, ComponentChangingEventArgs ce);
+        protected virtual void OnControlResize();
+        protected virtual void OnPaint(PaintEventArgs e);
+        protected override void PreFilterProperties(IDictionary properties);
+        public void RaiseResizeEvent();
+        public void RegisterClone(object original, object clone);
+        public virtual void SetEditableDesignerRegionContent(EditableDesignerRegion region, string content);
+        protected void SetRegionContent(EditableDesignerRegion region, string content);
+        protected void SetViewFlags(ViewFlags viewFlags, bool setFlag);
+        public virtual void UpdateDesignTimeHtml();
+    }
+    public sealed class ControlDesignerState {
+        public object this[string key] { get; set; }
+    }
+    public enum ControlLocation {
+        After = 1,
+        Before = 0,
+        First = 2,
+        FirstChild = 4,
+        Last = 3,
+        LastChild = 5,
+    }
+    public sealed class ControlParser {
+        public static Control ParseControl(IDesignerHost designerHost, string controlText);
+        public static Control ParseControl(IDesignerHost designerHost, string controlText, string directives);
+        public static Control[] ParseControls(IDesignerHost designerHost, string controlText);
+        public static ITemplate ParseTemplate(IDesignerHost designerHost, string templateText);
+        public static ITemplate ParseTemplate(IDesignerHost designerHost, string templateText, string directives);
+    }
+    public sealed class ControlPersister {
+        public static void PersistControl(TextWriter sw, Control control);
+        public static void PersistControl(TextWriter sw, Control control, IDesignerHost host);
+        public static string PersistControl(Control control);
+        public static string PersistControl(Control control, IDesignerHost host);
+        public static void PersistInnerProperties(TextWriter sw, object component, IDesignerHost host);
+        public static string PersistInnerProperties(object component, IDesignerHost host);
+        public static void PersistTemplate(TextWriter writer, ITemplate template, IDesignerHost host);
+        public static string PersistTemplate(ITemplate template, IDesignerHost host);
+    }
+    public class DataBindingCollectionConverter : TypeConverter {
+        public DataBindingCollectionConverter();
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
+    }
+    public class DataBindingCollectionEditor : UITypeEditor {
+        public DataBindingCollectionEditor();
+        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value);
+        public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context);
+    }
+    public abstract class DataBindingHandler {
+        protected DataBindingHandler();
+        public abstract void DataBindControl(IDesignerHost designerHost, Control control);
+    }
+    public class DataBindingValueUIHandler {
+        public DataBindingValueUIHandler();
+        public void OnGetUIValueItem(ITypeDescriptorContext context, PropertyDescriptor propDesc, ArrayList valueUIItemList);
+    }
+    public class DataColumnSelectionConverter : TypeConverter {
+        public DataColumnSelectionConverter();
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
+        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
+        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context);
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
+    }
+    public class DataFieldConverter : TypeConverter {
+        public DataFieldConverter();
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
+        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
+        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context);
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
+    }
+    public class DataMemberConverter : TypeConverter {
+        public DataMemberConverter();
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
+        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
+        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context);
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
+    }
+    public sealed class DataSetFieldSchema : IDataSourceFieldSchema {
+        public DataSetFieldSchema(DataColumn column);
+        public Type DataType { get; }
+        public bool Identity { get; }
+        public bool IsReadOnly { get; }
+        public bool IsUnique { get; }
+        public int Length { get; }
+        public string Name { get; }
+        public bool Nullable { get; }
+        public int Precision { get; }
+        public bool PrimaryKey { get; }
+        public int Scale { get; }
+    }
+    public sealed class DataSetSchema : IDataSourceSchema {
+        public DataSetSchema(DataSet dataSet);
+        public IDataSourceViewSchema[] GetViews();
+    }
+    public sealed class DataSetViewSchema : IDataSourceViewSchema {
+        public DataSetViewSchema(DataTable dataTable);
+        public string Name { get; }
+        public IDataSourceViewSchema[] GetChildren();
+        public IDataSourceFieldSchema[] GetFields();
+    }
+    public class DataSourceBooleanViewSchemaConverter : DataSourceViewSchemaConverter {
+        public DataSourceBooleanViewSchemaConverter();
+        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
+    }
+    public class DataSourceConverter : TypeConverter {
+        public DataSourceConverter();
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
+        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
+        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context);
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
+        protected virtual bool IsValidDataSource(IComponent component);
+    }
+    public class DataSourceDesigner : ControlDesigner, IDataSourceDesigner {
+        public DataSourceDesigner();
+        public override DesignerActionListCollection ActionLists { get; }
+        public virtual bool CanConfigure { get; }
+        public virtual bool CanRefreshSchema { get; }
+        protected bool SuppressingDataSourceEvents { get; }
+        public event EventHandler DataSourceChanged;
+        public event EventHandler SchemaRefreshed;
+        public virtual void Configure();
+        public override string GetDesignTimeHtml();
+        public virtual DesignerDataSourceView GetView(string viewName);
+        public virtual string[] GetViewNames();
+        protected virtual void OnDataSourceChanged(EventArgs e);
+        protected virtual void OnSchemaRefreshed(EventArgs e);
+        public virtual void RefreshSchema(bool preferSilent);
+        public virtual void ResumeDataSourceEvents();
+        public static bool SchemasEquivalent(IDataSourceSchema schema1, IDataSourceSchema schema2);
+        public virtual void SuppressDataSourceEvents();
+        public static bool ViewSchemasEquivalent(IDataSourceViewSchema viewSchema1, IDataSourceViewSchema viewSchema2);
+    }
+    public class DataSourceViewSchemaConverter : TypeConverter {
+        public DataSourceViewSchemaConverter();
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
+        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
+        public virtual TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context, Type typeFilter);
+        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context);
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
+    }
+    public abstract class DesignerAutoFormat {
+        protected DesignerAutoFormat(string name);
+        public string Name { get; }
+        public DesignerAutoFormatStyle Style { get; }
+        public abstract void Apply(Control control);
+        public virtual Control GetPreviewControl(Control runtimeControl);
+        public override string ToString();
+    }
+    public sealed class DesignerAutoFormatCollection : ICollection, IEnumerable, IList {
+        public DesignerAutoFormatCollection();
+        public int Count { get; }
+        public Size PreviewSize { get; }
+        public object SyncRoot { get; }
+        int System.Collections.ICollection.Count { get; }
+        bool System.Collections.ICollection.IsSynchronized { get; }
+        bool System.Collections.IList.IsFixedSize { get; }
+        bool System.Collections.IList.IsReadOnly { get; }
+        object System.Collections.IList.this[int index] { get; set; }
+        public DesignerAutoFormat this[int index] { get; }
+        public int Add(DesignerAutoFormat format);
+        public void Clear();
+        public bool Contains(DesignerAutoFormat format);
+        public int IndexOf(DesignerAutoFormat format);
+        public void Insert(int index, DesignerAutoFormat format);
+        public void Remove(DesignerAutoFormat format);
+        public void RemoveAt(int index);
+        void System.Collections.ICollection.CopyTo(Array array, int index);
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+        int System.Collections.IList.Add(object value);
+        bool System.Collections.IList.Contains(object value);
+        int System.Collections.IList.IndexOf(object value);
+        void System.Collections.IList.Insert(int index, object value);
+        void System.Collections.IList.Remove(object value);
+        void System.Collections.IList.RemoveAt(int index);
+    }
+    public class DesignerAutoFormatStyle : Style {
+        public DesignerAutoFormatStyle();
+        public VerticalAlign VerticalAlign { get; set; }
+    }
+    public abstract class DesignerDataSourceView {
+        protected DesignerDataSourceView(IDataSourceDesigner owner, string viewName);
+        public virtual bool CanDelete { get; }
+        public virtual bool CanInsert { get; }
+        public virtual bool CanPage { get; }
+        public virtual bool CanRetrieveTotalRowCount { get; }
+        public virtual bool CanSort { get; }
+        public virtual bool CanUpdate { get; }
+        public IDataSourceDesigner DataSourceDesigner { get; }
+        public string Name { get; }
+        public virtual IDataSourceViewSchema Schema { get; }
+        public virtual IEnumerable GetDesignTimeData(int minimumRows, out bool isSampleData);
+    }
+    public abstract class DesignerHierarchicalDataSourceView {
+        protected DesignerHierarchicalDataSourceView(IHierarchicalDataSourceDesigner owner, string viewPath);
+        public IHierarchicalDataSourceDesigner DataSourceDesigner { get; }
+        public string Path { get; }
+        public virtual IDataSourceSchema Schema { get; }
+        public virtual IHierarchicalEnumerable GetDesignTimeData(out bool isSampleData);
+    }
+    public abstract class DesignerObject : IServiceProvider {
+        protected DesignerObject(ControlDesigner designer, string name);
+        public ControlDesigner Designer { get; }
+        public string Name { get; }
+        public IDictionary Properties { get; }
+        protected object GetService(Type serviceType);
+        object System.IServiceProvider.GetService(Type serviceType);
+    }
+    public class DesignerRegion : DesignerObject {
+        public static readonly string DesignerRegionAttributeName;
+        public DesignerRegion(ControlDesigner designer, string name);
+        public DesignerRegion(ControlDesigner designer, string name, bool selectable);
+        public virtual string Description { get; set; }
+        public virtual string DisplayName { get; set; }
+        public bool EnsureSize { get; set; }
+        public virtual bool Highlight { get; set; }
+        public virtual bool Selectable { get; set; }
+        public virtual bool Selected { get; set; }
+        public object UserData { get; set; }
+        public Rectangle GetBounds();
+    }
+    public class DesignerRegionCollection : ICollection, IEnumerable, IList {
+        public DesignerRegionCollection();
+        public DesignerRegionCollection(ControlDesigner owner);
+        public int Count { get; }
+        public bool IsFixedSize { get; }
+        public bool IsReadOnly { get; }
+        public bool IsSynchronized { get; }
+        public ControlDesigner Owner { get; }
+        public object SyncRoot { get; }
+        int System.Collections.ICollection.Count { get; }
+        bool System.Collections.ICollection.IsSynchronized { get; }
+        object System.Collections.ICollection.SyncRoot { get; }
+        bool System.Collections.IList.IsFixedSize { get; }
+        bool System.Collections.IList.IsReadOnly { get; }
+        object System.Collections.IList.this[int index] { get; set; }
+        public DesignerRegion this[int index] { get; set; }
+        public int Add(DesignerRegion region);
+        public void Clear();
+        public bool Contains(DesignerRegion region);
+        public void CopyTo(Array array, int index);
+        public IEnumerator GetEnumerator();
+        public int IndexOf(DesignerRegion region);
+        public void Insert(int index, DesignerRegion region);
+        public void Remove(DesignerRegion region);
+        public void RemoveAt(int index);
+        void System.Collections.ICollection.CopyTo(Array array, int index);
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+        int System.Collections.IList.Add(object o);
+        void System.Collections.IList.Clear();
+        bool System.Collections.IList.Contains(object o);
+        int System.Collections.IList.IndexOf(object o);
+        void System.Collections.IList.Insert(int index, object o);
+        void System.Collections.IList.Remove(object o);
+        void System.Collections.IList.RemoveAt(int index);
+    }
+    public sealed class DesignerRegionMouseEventArgs : EventArgs {
+        public DesignerRegionMouseEventArgs(DesignerRegion region, Point location);
+        public Point Location { get; }
+        public DesignerRegion Region { get; }
+    }
+    public sealed class DesignTimeData {
+        public static readonly EventHandler DataBindingHandler;
+        public static DataTable CreateDummyDataBoundDataTable();
+        public static DataTable CreateDummyDataTable();
+        public static DataTable CreateSampleDataTable(IEnumerable referenceData);
+        public static DataTable CreateSampleDataTable(IEnumerable referenceData, bool useDataBoundData);
+        public static PropertyDescriptorCollection GetDataFields(IEnumerable dataSource);
+        public static IEnumerable GetDataMember(IListSource dataSource, string dataMember);
+        public static string[] GetDataMembers(object dataSource);
+        public static IEnumerable GetDesignTimeDataSource(DataTable dataTable, int minimumRows);
+        public static object GetSelectedDataSource(IComponent component, string dataSource);
+        public static IEnumerable GetSelectedDataSource(IComponent component, string dataSource, string dataMember);
+    }
+    public abstract class DesignTimeResourceProviderFactory {
+        protected DesignTimeResourceProviderFactory();
+        public abstract IResourceProvider CreateDesignTimeGlobalResourceProvider(IServiceProvider serviceProvider, string classKey);
+        public abstract IResourceProvider CreateDesignTimeLocalResourceProvider(IServiceProvider serviceProvider);
+        public abstract IDesignTimeResourceWriter CreateDesignTimeLocalResourceWriter(IServiceProvider serviceProvider);
+    }
+    public class EditableDesignerRegion : DesignerRegion {
+        public EditableDesignerRegion(ControlDesigner owner, string name);
+        public EditableDesignerRegion(ControlDesigner owner, string name, bool serverControlsOnly);
+        public virtual string Content { get; set; }
+        public bool ServerControlsOnly { get; set; }
+        public virtual bool SupportsDataBinding { get; set; }
+        public virtual ViewRendering GetChildViewRendering(Control control);
+    }
+    public abstract class ExpressionEditor {
+        protected ExpressionEditor();
+        public string ExpressionPrefix { get; }
+        public abstract object EvaluateExpression(string expression, object parseTimeData, Type propertyType, IServiceProvider serviceProvider);
+        public static ExpressionEditor GetExpressionEditor(string expressionPrefix, IServiceProvider serviceProvider);
+        public static ExpressionEditor GetExpressionEditor(Type expressionBuilderType, IServiceProvider serviceProvider);
+        public virtual ExpressionEditorSheet GetExpressionEditorSheet(string expression, IServiceProvider serviceProvider);
+    }
+    public abstract class ExpressionEditorSheet {
+        protected ExpressionEditorSheet(IServiceProvider serviceProvider);
+        public virtual bool IsValid { get; }
+        public IServiceProvider ServiceProvider { get; }
+        public abstract string GetExpression();
+    }
+    public class ExpressionsCollectionConverter : TypeConverter {
+        public ExpressionsCollectionConverter();
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
+    }
+    public class ExpressionsCollectionEditor : UITypeEditor {
+        public ExpressionsCollectionEditor();
+        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value);
+        public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context);
+    }
+    public class ExtenderControlDesigner : ControlDesigner, IControlDesigner {
+        public ExtenderControlDesigner();
+        protected override bool Visible { get; }
+        protected override void Dispose(bool disposing);
+        public override string GetDesignTimeHtml();
+        public override void Initialize(IComponent component);
+        protected override void PreFilterProperties(IDictionary properties);
+    }
+    public class ExtenderControlToolboxItem : WebControlToolboxItem {
+        public ExtenderControlToolboxItem();
+        protected ExtenderControlToolboxItem(SerializationInfo info, StreamingContext context);
+        public ExtenderControlToolboxItem(Type type);
+        public ReadOnlyCollection<Type> GetTargetControlTypes(IDesignerHost host);
+        public override void Initialize(Type type);
+    }
+    public class HierarchicalDataSourceConverter : DataSourceConverter {
+        public HierarchicalDataSourceConverter();
+        protected override bool IsValidDataSource(IComponent component);
+    }
+    public class HierarchicalDataSourceDesigner : ControlDesigner, IHierarchicalDataSourceDesigner {
+        public HierarchicalDataSourceDesigner();
+        public override DesignerActionListCollection ActionLists { get; }
+        public virtual bool CanConfigure { get; }
+        public virtual bool CanRefreshSchema { get; }
+        protected bool SuppressingDataSourceEvents { get; }
+        public event EventHandler DataSourceChanged;
+        public event EventHandler SchemaRefreshed;
+        public virtual void Configure();
+        public override string GetDesignTimeHtml();
+        public virtual DesignerHierarchicalDataSourceView GetView(string viewPath);
+        protected virtual void OnDataSourceChanged(EventArgs e);
+        protected virtual void OnSchemaRefreshed(EventArgs e);
+        public virtual void RefreshSchema(bool preferSilent);
+        public virtual void ResumeDataSourceEvents();
+        public virtual void SuppressDataSourceEvents();
+    }
+    public class HtmlControlDesigner : ComponentDesigner {
+        public HtmlControlDesigner();
+        public IHtmlControlDesignerBehavior Behavior { get; set; }
+        public DataBindingCollection DataBindings { get; }
+        protected object DesignTimeElement { get; }
+        public ExpressionBindingCollection Expressions { get; }
+        public virtual bool ShouldCodeSerialize { get; set; }
+        protected override void Dispose(bool disposing);
+        public override void Initialize(IComponent component);
+        protected virtual void OnBehaviorAttached();
+        protected virtual void OnBehaviorDetaching();
+        protected virtual void OnBindingsCollectionChanged(string propName);
+        public virtual void OnSetParent();
+        protected override void PreFilterEvents(IDictionary events);
+        protected override void PreFilterProperties(IDictionary properties);
+    }
+    public class HtmlIntrinsicControlDesigner : HtmlControlDesigner {
+        public HtmlIntrinsicControlDesigner();
+    }
+    public class HyperLinkDataBindingHandler : DataBindingHandler {
+        public HyperLinkDataBindingHandler();
+        public override void DataBindControl(IDesignerHost designerHost, Control control);
+    }
+    public interface IContentResolutionService {
+        IDictionary ContentDefinitions { get; }
+        ContentDesignerState GetContentDesignerState(string identifier);
+        void SetContentDesignerState(string identifier, ContentDesignerState state);
+    }
+    public interface IControlDesignerBehavior {
+        object DesignTimeElementView { get; }
+        string DesignTimeHtml { get; set; }
+        void OnTemplateModeChanged();
+    }
+    public interface IControlDesignerTag {
+        bool IsDirty { get; }
+        string GetAttribute(string name);
+        string GetContent();
+        string GetOuterContent();
+        void RemoveAttribute(string name);
+        void SetAttribute(string name, string value);
+        void SetContent(string content);
+        void SetDirty(bool dirty);
+    }
+    public interface IControlDesignerView {
+        DesignerRegion ContainingRegion { get; }
+        IDesigner NamingContainerDesigner { get; }
+        bool SupportsRegions { get; }
+        event ViewEventHandler ViewEvent;
+        Rectangle GetBounds(DesignerRegion region);
+        void Invalidate(Rectangle rectangle);
+        void SetFlags(ViewFlags viewFlags, bool setFlag);
+        void SetRegionContent(EditableDesignerRegion region, string content);
+        void Update();
+    }
+    public interface IDataBindingSchemaProvider {
+        bool CanRefreshSchema { get; }
+        IDataSourceViewSchema Schema { get; }
+        void RefreshSchema(bool preferSilent);
+    }
+    public interface IDataSourceDesigner {
+        bool CanConfigure { get; }
+        bool CanRefreshSchema { get; }
+        event EventHandler DataSourceChanged;
+        event EventHandler SchemaRefreshed;
+        void Configure();
+        DesignerDataSourceView GetView(string viewName);
+        string[] GetViewNames();
+        void RefreshSchema(bool preferSilent);
+        void ResumeDataSourceEvents();
+        void SuppressDataSourceEvents();
+    }
+    public interface IDataSourceFieldSchema {
+        Type DataType { get; }
+        bool Identity { get; }
+        bool IsReadOnly { get; }
+        bool IsUnique { get; }
+        int Length { get; }
+        string Name { get; }
+        bool Nullable { get; }
+        int Precision { get; }
+        bool PrimaryKey { get; }
+        int Scale { get; }
+    }
+    public interface IDataSourceProvider {
+        IEnumerable GetResolvedSelectedDataSource();
+        object GetSelectedDataSource();
+    }
+    public interface IDataSourceSchema {
+        IDataSourceViewSchema[] GetViews();
+    }
+    public interface IDataSourceViewSchema {
+        string Name { get; }
+        IDataSourceViewSchema[] GetChildren();
+        IDataSourceFieldSchema[] GetFields();
+    }
+    public interface IDesignTimeResourceProviderFactoryService {
+        DesignTimeResourceProviderFactory GetFactory();
+    }
+    public interface IDesignTimeResourceWriter : IDisposable, IResourceWriter {
+        string CreateResourceKey(string resourceName, object obj);
+    }
+    public interface IDocumentProjectItem {
+        Stream GetContents();
+        void Open();
+    }
+    public interface IFolderProjectItem {
+        ICollection Children { get; }
+        IDocumentProjectItem AddDocument(string name, byte[] content);
+        IFolderProjectItem AddFolder(string name);
+    }
+    public interface IHierarchicalDataSourceDesigner {
+        bool CanConfigure { get; }
+        bool CanRefreshSchema { get; }
+        event EventHandler DataSourceChanged;
+        event EventHandler SchemaRefreshed;
+        void Configure();
+        DesignerHierarchicalDataSourceView GetView(string viewPath);
+        void RefreshSchema(bool preferSilent);
+        void ResumeDataSourceEvents();
+        void SuppressDataSourceEvents();
+    }
+    public interface IHtmlControlDesignerBehavior {
+        HtmlControlDesigner Designer { get; set; }
+        object DesignTimeElement { get; }
+        object GetAttribute(string attribute, bool ignoreCase);
+        object GetStyleAttribute(string attribute, bool designTimeOnly, bool ignoreCase);
+        void RemoveAttribute(string attribute, bool ignoreCase);
+        void RemoveStyleAttribute(string attribute, bool designTimeOnly, bool ignoreCase);
+        void SetAttribute(string attribute, object value, bool ignoreCase);
+        void SetStyleAttribute(string attribute, bool designTimeOnly, object value, bool ignoreCase);
+    }
+    public class ImageUrlEditor : UrlEditor {
+        public ImageUrlEditor();
+        protected override string Caption { get; }
+        protected override string Filter { get; }
+    }
+    public interface IProjectItem {
+        string AppRelativeUrl { get; }
+        string Name { get; }
+        IProjectItem Parent { get; }
+        string PhysicalPath { get; }
+    }
+    public interface ITemplateEditingFrame : IDisposable {
+        Style ControlStyle { get; }
+        int InitialHeight { get; set; }
+        int InitialWidth { get; set; }
+        string Name { get; }
+        string[] TemplateNames { get; }
+        Style[] TemplateStyles { get; }
+        TemplateEditingVerb Verb { get; set; }
+        void Close(bool saveChanges);
+        void Open();
+        void Resize(int width, int height);
+        void Save();
+        void UpdateControlName(string newName);
+    }
+    public interface ITemplateEditingService {
+        bool SupportsNestedTemplateEditing { get; }
+        ITemplateEditingFrame CreateFrame(TemplatedControlDesigner designer, string frameName, string[] templateNames);
+        ITemplateEditingFrame CreateFrame(TemplatedControlDesigner designer, string frameName, string[] templateNames, Style controlStyle, Style[] templateStyles);
+        string GetContainingTemplateName(Control control);
+    }
+    public interface IWebAdministrationService {
+        void Start(IDictionary arguments);
+    }
+    public interface IWebApplication : IServiceProvider {
+        IProjectItem RootProjectItem { get; }
+        IProjectItem GetProjectItemFromUrl(string appRelativeUrl);
+        Configuration OpenWebConfiguration(bool isReadOnly);
+    }
+    public interface IWebFormReferenceManager {
+        Type GetObjectType(string tagPrefix, string typeName);
+        string GetRegisterDirectives();
+        string GetTagPrefix(Type objectType);
+    }
+    public interface IWebFormsBuilderUIService {
+        string BuildColor(Control owner, string initialColor);
+        string BuildUrl(Control owner, string initialUrl, string baseUrl, string caption, string filter, UrlBuilderOptions options);
+    }
+    public interface IWebFormsDocumentService {
+        string DocumentUrl { get; }
+        bool IsLoading { get; }
+        event EventHandler LoadComplete;
+        object CreateDiscardableUndoUnit();
+        void DiscardUndoUnit(object discardableUndoUnit);
+        void EnableUndo(bool enable);
+        void UpdateSelection();
+    }
+    public class MailFileEditor : UrlEditor {
+        public MailFileEditor();
+        protected override string Caption { get; }
+        protected override string Filter { get; }
+    }
+    public class MdbDataFileEditor : UrlEditor {
+        public MdbDataFileEditor();
+        protected override string Caption { get; }
+        protected override string Filter { get; }
+    }
+    public class PostBackTriggerControlIDConverter : StringConverter {
+        public PostBackTriggerControlIDConverter();
+        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
+        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context);
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
+    }
+    public class QueryExtenderDesigner : ControlDesigner, IControlDesigner {
+        public QueryExtenderDesigner();
+        public override string GetDesignTimeHtml();
+    }
+    public class ReadWriteControlDesigner : ControlDesigner {
+        public ReadWriteControlDesigner();
+        public override string GetDesignTimeHtml();
+        protected virtual void MapPropertyToStyle(string propName, object varPropValue);
+        protected override void OnBehaviorAttached();
+        public override void OnComponentChanged(object sender, ComponentChangedEventArgs ce);
+        public override void UpdateDesignTimeHtml();
+    }
+    public class ResourceExpressionEditor : ExpressionEditor {
+        public ResourceExpressionEditor();
+        public override object EvaluateExpression(string expression, object parseTimeData, Type propertyType, IServiceProvider serviceProvider);
+        public override ExpressionEditorSheet GetExpressionEditorSheet(string expression, IServiceProvider serviceProvider);
+    }
+    public class ResourceExpressionEditorSheet : ExpressionEditorSheet {
+        public ResourceExpressionEditorSheet(string expression, IServiceProvider serviceProvider);
+        public string ClassKey { get; set; }
+        public override bool IsValid { get; }
+        public string ResourceKey { get; set; }
+        public override string GetExpression();
+    }
+    public class RouteUrlExpressionEditor : ExpressionEditor {
+        public RouteUrlExpressionEditor();
+        public override object EvaluateExpression(string expression, object parseTimeData, Type propertyType, IServiceProvider serviceProvider);
+        public override ExpressionEditorSheet GetExpressionEditorSheet(string expression, IServiceProvider serviceProvider);
+    }
+    public class RouteUrlExpressionEditorSheet : ExpressionEditorSheet {
+        public RouteUrlExpressionEditorSheet(string expression, IServiceProvider serviceProvider);
+        public override bool IsValid { get; }
+        public string RouteName { get; set; }
+        public string RouteValues { get; set; }
+        public override string GetExpression();
+    }
+    public class RouteValueExpressionEditor : ExpressionEditor {
+        public RouteValueExpressionEditor();
+        public override object EvaluateExpression(string expression, object parseTimeData, Type propertyType, IServiceProvider serviceProvider);
+        public override ExpressionEditorSheet GetExpressionEditorSheet(string expression, IServiceProvider serviceProvider);
+    }
+    public class RouteValueExpressionEditorSheet : ExpressionEditorSheet {
+        public RouteValueExpressionEditorSheet(string expression, IServiceProvider serviceProvider);
+        public override bool IsValid { get; }
+        public string RouteValue { get; set; }
+        public override string GetExpression();
+    }
+    public class ScriptManagerDesigner : ControlDesigner {
+        public ScriptManagerDesigner();
+        public static string GetApplicationServices(ScriptManager scriptManager, IEnumerable<ScriptManagerProxy> proxies);
+        public override string GetDesignTimeHtml();
+        public static string GetProxyScript(ScriptManager scriptManager, ServiceReference serviceReference);
+        public static string GetProxyUrl(ScriptManager scriptManager, ServiceReference serviceReference);
+        public static string GetScriptFromWebResource(Assembly assembly, string resourceName, CultureInfo culture);
+        public static ReadOnlyCollection<ScriptReference> GetScriptReferences(ScriptManager scriptManager, IEnumerable<ScriptManagerProxy> proxies);
+        public static ReadOnlyCollection<ServiceReference> GetServiceReferences(ScriptManager scriptManager, IEnumerable<ScriptManagerProxy> proxies);
+        public override void Initialize(IComponent component);
+    }
+    public class ScriptManagerProxyDesigner : ControlDesigner {
+        public ScriptManagerProxyDesigner();
+        public override string GetDesignTimeHtml();
+        public override void Initialize(IComponent component);
+    }
+    public class ServiceReferenceCollectionEditor : CollectionEditorBase {
+        public ServiceReferenceCollectionEditor(Type type);
+        protected override bool CanSelectMultipleInstances();
+        protected override Type[] CreateNewItemTypes();
+    }
+    public class SkinIDTypeConverter : TypeConverter {
+        public SkinIDTypeConverter();
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destType);
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
+        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
+    }
+    public sealed class SupportsPreviewControlAttribute : Attribute {
+        public static readonly SupportsPreviewControlAttribute Default;
+        public SupportsPreviewControlAttribute(bool supportsPreviewControl);
+        public bool SupportsPreviewControl { get; }
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public override bool IsDefaultAttribute();
+    }
+    public abstract class TemplatedControlDesigner : ControlDesigner {
+        public TemplatedControlDesigner();
+        public ITemplateEditingFrame ActiveTemplateEditingFrame { get; }
+        public bool CanEnterTemplateMode { get; }
+        protected override bool DataBindingsEnabled { get; }
+        public new bool InTemplateMode { get; }
+        public override TemplateGroupCollection TemplateGroups { get; }
+        protected abstract ITemplateEditingFrame CreateTemplateEditingFrame(TemplateEditingVerb verb);
+        public void EnterTemplateMode(ITemplateEditingFrame newTemplateEditingFrame);
+        public void ExitTemplateMode(bool fSwitchingTemplates, bool fNested, bool fSave);
+        protected abstract TemplateEditingVerb[] GetCachedTemplateEditingVerbs();
+        public virtual string GetTemplateContainerDataItemProperty(string templateName);
+        public virtual IEnumerable GetTemplateContainerDataSource(string templateName);
+        public abstract string GetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, out bool allowEditing);
+        public TemplateEditingVerb[] GetTemplateEditingVerbs();
+        protected ITemplate GetTemplateFromText(string text);
+        public virtual Type GetTemplatePropertyParentType(string templateName);
+        protected string GetTextFromTemplate(ITemplate template);
+        public override void Initialize(IComponent component);
+        protected override void OnBehaviorAttached();
+        public override void OnComponentChanged(object sender, ComponentChangedEventArgs ce);
+        public override void OnSetParent();
+        protected virtual void OnTemplateModeChanged();
+        protected void SaveActiveTemplateEditingFrame();
+        public abstract void SetTemplateContent(ITemplateEditingFrame editingFrame, string templateName, string templateContent);
+        public override void UpdateDesignTimeHtml();
+    }
+    public class TemplatedEditableDesignerRegion : EditableDesignerRegion {
+        public TemplatedEditableDesignerRegion(TemplateDefinition templateDefinition);
+        public virtual bool IsSingleInstanceTemplate { get; set; }
+        public override bool SupportsDataBinding { get; set; }
+        public TemplateDefinition TemplateDefinition { get; }
+    }
+    public class TemplateDefinition : DesignerObject {
+        public TemplateDefinition(ControlDesigner designer, string name, object templatedObject, string templatePropertyName);
+        public TemplateDefinition(ControlDesigner designer, string name, object templatedObject, string templatePropertyName, bool serverControlsOnly);
+        public TemplateDefinition(ControlDesigner designer, string name, object templatedObject, string templatePropertyName, Style style);
+        public TemplateDefinition(ControlDesigner designer, string name, object templatedObject, string templatePropertyName, Style style, bool serverControlsOnly);
+        public virtual bool AllowEditing { get; }
+        public virtual string Content { get; set; }
+        public bool ServerControlsOnly { get; }
+        public Style Style { get; }
+        public bool SupportsDataBinding { get; set; }
+        public object TemplatedObject { get; }
+        public string TemplatePropertyName { get; }
+    }
+    public sealed class TemplateEditingService : IDisposable, ITemplateEditingService {
+        public TemplateEditingService(IDesignerHost designerHost);
+        public bool SupportsNestedTemplateEditing { get; }
+        public ITemplateEditingFrame CreateFrame(TemplatedControlDesigner designer, string frameName, string[] templateNames);
+        public ITemplateEditingFrame CreateFrame(TemplatedControlDesigner designer, string frameName, string[] templateNames, Style controlStyle, Style[] templateStyles);
+        public void Dispose();
+        ~TemplateEditingService();
+        public string GetContainingTemplateName(Control control);
+    }
+    public class TemplateEditingVerb : DesignerVerb, IDisposable {
+        public TemplateEditingVerb(string text, int index);
+        public TemplateEditingVerb(string text, int index, TemplatedControlDesigner designer);
+        public int Index { get; }
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+        ~TemplateEditingVerb();
+    }
+    public class TemplateGroup {
+        public TemplateGroup(string groupName);
+        public TemplateGroup(string groupName, Style groupStyle);
+        public string GroupName { get; }
+        public Style GroupStyle { get; }
+        public bool IsEmpty { get; }
+        public TemplateDefinition[] Templates { get; }
+        public void AddTemplateDefinition(TemplateDefinition templateDefinition);
+    }
+    public sealed class TemplateGroupCollection : ICollection, IEnumerable, IList {
+        public TemplateGroupCollection();
+        public int Count { get; }
+        int System.Collections.ICollection.Count { get; }
+        bool System.Collections.ICollection.IsSynchronized { get; }
+        object System.Collections.ICollection.SyncRoot { get; }
+        bool System.Collections.IList.IsFixedSize { get; }
+        bool System.Collections.IList.IsReadOnly { get; }
+        object System.Collections.IList.this[int index] { get; set; }
+        public TemplateGroup this[int index] { get; set; }
+        public int Add(TemplateGroup group);
+        public void AddRange(TemplateGroupCollection groups);
+        public void Clear();
+        public bool Contains(TemplateGroup group);
+        public void CopyTo(TemplateGroup[] array, int index);
+        public int IndexOf(TemplateGroup group);
+        public void Insert(int index, TemplateGroup group);
+        public void Remove(TemplateGroup group);
+        public void RemoveAt(int index);
+        void System.Collections.ICollection.CopyTo(Array array, int index);
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+        int System.Collections.IList.Add(object o);
+        void System.Collections.IList.Clear();
+        bool System.Collections.IList.Contains(object o);
+        int System.Collections.IList.IndexOf(object o);
+        void System.Collections.IList.Insert(int index, object o);
+        void System.Collections.IList.Remove(object o);
+        void System.Collections.IList.RemoveAt(int index);
+    }
+    public class TemplateModeChangedEventArgs : EventArgs {
+        public TemplateModeChangedEventArgs(TemplateGroup newTemplateGroup);
+        public TemplateGroup NewTemplateGroup { get; }
+    }
+    public class TextControlDesigner : ControlDesigner {
+        public TextControlDesigner();
+        public override string GetDesignTimeHtml();
+    }
+    public class TextDataBindingHandler : DataBindingHandler {
+        public TextDataBindingHandler();
+        public override void DataBindControl(IDesignerHost designerHost, Control control);
+    }
+    public class TimerDesigner : ControlDesigner {
+        public TimerDesigner();
+        public override string GetDesignTimeHtml();
+    }
+    public delegate bool TransactedChangeCallback(object context);
+    public sealed class TypeSchema : IDataSourceSchema {
+        public TypeSchema(Type type);
+        public IDataSourceViewSchema[] GetViews();
+    }
+    public class UpdatePanelDesigner : ControlDesigner {
+        public UpdatePanelDesigner();
+        protected override bool UsePreviewControl { get; }
+        public override string GetDesignTimeHtml(DesignerRegionCollection regions);
+        public override string GetEditableDesignerRegionContent(EditableDesignerRegion region);
+        public override void Initialize(IComponent component);
+        public override void OnComponentChanged(object sender, ComponentChangedEventArgs ce);
+        public override void SetEditableDesignerRegionContent(EditableDesignerRegion region, string content);
+    }
+    public class UpdatePanelTriggerCollectionEditor : CollectionEditorBase {
+        public UpdatePanelTriggerCollectionEditor(Type type);
+        protected override bool CanSelectMultipleInstances();
+        protected override Type CreateCollectionItemType();
+        protected override Type[] CreateNewItemTypes();
+        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value);
+    }
+    public class UpdateProgressAssociatedUpdatePanelIDConverter : StringConverter {
+        public UpdateProgressAssociatedUpdatePanelIDConverter();
+        public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context);
+        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context);
+        public override bool GetStandardValuesSupported(ITypeDescriptorContext context);
+    }
+    public class UpdateProgressDesigner : ControlDesigner {
+        public UpdateProgressDesigner();
+        protected override bool UsePreviewControl { get; }
+        public override string GetDesignTimeHtml(DesignerRegionCollection regions);
+        public override string GetEditableDesignerRegionContent(EditableDesignerRegion region);
+        public override void SetEditableDesignerRegionContent(EditableDesignerRegion region, string content);
+    }
+    public sealed class UrlBuilder {
+        public static string BuildUrl(IComponent component, Control owner, string initialUrl, string caption, string filter);
+        public static string BuildUrl(IComponent component, Control owner, string initialUrl, string caption, string filter, UrlBuilderOptions options);
+        public static string BuildUrl(IServiceProvider serviceProvider, Control owner, string initialUrl, string caption, string filter, UrlBuilderOptions options);
+    }
+    public enum UrlBuilderOptions {
+        NoAbsolute = 1,
+        None = 0,
+    }
+    public class UrlEditor : UITypeEditor {
+        public UrlEditor();
+        protected virtual string Caption { get; }
+        protected virtual string Filter { get; }
+        protected virtual UrlBuilderOptions Options { get; }
+        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value);
+        public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context);
+    }
+    public class UserControlDesigner : ControlDesigner {
+        public UserControlDesigner();
+        public override DesignerActionListCollection ActionLists { get; }
+        public override bool AllowResize { get; }
+        public override string GetDesignTimeHtml();
+    }
+    public class UserControlFileEditor : UrlEditor {
+        public UserControlFileEditor();
+        protected override string Caption { get; }
+        protected override string Filter { get; }
+    }
+    public sealed class ViewEvent {
+        public static readonly ViewEvent Click;
+        public static readonly ViewEvent Paint;
+        public static readonly ViewEvent TemplateModeChanged;
+    }
+    public class ViewEventArgs : EventArgs {
+        public ViewEventArgs(ViewEvent eventType, DesignerRegion region, EventArgs eventArgs);
+        public EventArgs EventArgs { get; }
+        public ViewEvent EventType { get; }
+        public DesignerRegion Region { get; }
+    }
+    public delegate void ViewEventHandler(object sender, ViewEventArgs e);
+    public enum ViewFlags {
+        CustomPaint = 1,
+        DesignTimeHtmlRequiresLoadComplete = 2,
+        TemplateEditing = 4,
+    }
+    public class ViewRendering {
+        public ViewRendering(string content, DesignerRegionCollection regions);
+        public ViewRendering(string content, DesignerRegionCollection regions, bool visible);
+        public string Content { get; }
+        public DesignerRegionCollection Regions { get; }
+        public bool Visible { get; }
+    }
+    public class WebControlToolboxItem : ToolboxItem {
+        public WebControlToolboxItem();
+        protected WebControlToolboxItem(SerializationInfo info, StreamingContext context);
+        public WebControlToolboxItem(Type type);
+        protected override IComponent[] CreateComponentsCore(IDesignerHost host);
+        protected override void Deserialize(SerializationInfo info, StreamingContext context);
+        public object GetToolAttributeValue(IDesignerHost host, Type attributeType);
+        public string GetToolHtml(IDesignerHost host);
+        public Type GetToolType(IDesignerHost host);
+        public override void Initialize(Type type);
+        protected override void Serialize(SerializationInfo info, StreamingContext context);
+    }
+    public class WebFormsDesignerActionService : DesignerActionService {
+        public WebFormsDesignerActionService(IServiceProvider serviceProvider);
+        protected override void GetComponentDesignerActions(IComponent component, DesignerActionListCollection actionLists);
+    }
+    public abstract class WebFormsReferenceManager {
+        protected WebFormsReferenceManager();
+        public abstract ICollection GetRegisterDirectives();
+        public abstract string GetTagPrefix(Type objectType);
+        public abstract Type GetType(string tagPrefix, string tagName);
+        public abstract string GetUserControlPath(string tagPrefix, string tagName);
+        public abstract string RegisterTagPrefix(Type objectType);
+    }
+    public abstract class WebFormsRootDesigner : IDesigner, IDesignerFilter, IDisposable, IRootDesigner {
+        protected WebFormsRootDesigner();
+        public virtual IComponent Component { get; set; }
+        public CultureInfo CurrentCulture { get; }
+        public abstract string DocumentUrl { get; }
+        public abstract bool IsDesignerViewLocked { get; }
+        public abstract bool IsLoading { get; }
+        public abstract WebFormsReferenceManager ReferenceManager { get; }
+        protected ViewTechnology[] SupportedTechnologies { get; }
+        DesignerVerbCollection System.ComponentModel.Design.IDesigner.Verbs { get; }
+        ViewTechnology[] System.ComponentModel.Design.IRootDesigner.SupportedTechnologies { get; }
+        protected DesignerVerbCollection Verbs { get; }
+        public event EventHandler LoadComplete;
+        public abstract void AddClientScriptToDocument(ClientScriptItem scriptItem);
+        public abstract string AddControlToDocument(Control newControl, Control referenceControl, ControlLocation location);
+        protected virtual DesignerActionService CreateDesignerActionService(IServiceProvider serviceProvider);
+        protected virtual IUrlResolutionService CreateUrlResolutionService();
+        protected virtual void Dispose(bool disposing);
+        ~WebFormsRootDesigner();
+        public virtual string GenerateEmptyDesignTimeHtml(Control control);
+        public virtual string GenerateErrorDesignTimeHtml(Control control, Exception e, string errorMessage);
+        public abstract ClientScriptItemCollection GetClientScriptsInDocument();
+        protected internal abstract void GetControlViewAndTag(Control control, out IControlDesignerView view, out IControlDesignerTag tag);
+        protected internal virtual object GetService(Type serviceType);
+        protected object GetView(ViewTechnology viewTechnology);
+        public virtual void Initialize(IComponent component);
+        protected virtual void OnLoadComplete(EventArgs e);
+        protected virtual void PostFilterAttributes(IDictionary attributes);
+        protected virtual void PostFilterEvents(IDictionary events);
+        protected virtual void PostFilterProperties(IDictionary properties);
+        protected virtual void PreFilterAttributes(IDictionary attributes);
+        protected virtual void PreFilterEvents(IDictionary events);
+        protected virtual void PreFilterProperties(IDictionary properties);
+        public abstract void RemoveClientScriptFromDocument(string clientScriptId);
+        public abstract void RemoveControlFromDocument(Control control);
+        public string ResolveUrl(string relativeUrl);
+        public virtual void SetControlID(Control control, string id);
+        void System.ComponentModel.Design.IDesigner.DoDefaultAction();
+        void System.ComponentModel.Design.IDesignerFilter.PostFilterAttributes(IDictionary attributes);
+        void System.ComponentModel.Design.IDesignerFilter.PostFilterEvents(IDictionary events);
+        void System.ComponentModel.Design.IDesignerFilter.PostFilterProperties(IDictionary properties);
+        void System.ComponentModel.Design.IDesignerFilter.PreFilterAttributes(IDictionary attributes);
+        void System.ComponentModel.Design.IDesignerFilter.PreFilterEvents(IDictionary events);
+        void System.ComponentModel.Design.IDesignerFilter.PreFilterProperties(IDictionary properties);
+        object System.ComponentModel.Design.IRootDesigner.GetView(ViewTechnology viewTechnology);
+        void System.IDisposable.Dispose();
+    }
+    public class XmlDataFileEditor : UrlEditor {
+        public XmlDataFileEditor();
+        protected override string Caption { get; }
+        protected override string Filter { get; }
+    }
+    public sealed class XmlDocumentSchema : IDataSourceSchema {
+        public XmlDocumentSchema(XmlDocument xmlDocument, string xPath);
+        public IDataSourceViewSchema[] GetViews();
+    }
+    public class XmlFileEditor : UITypeEditor {
+        public XmlFileEditor();
+        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value);
+        public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context);
+    }
+    public class XmlUrlEditor : UrlEditor {
+        public XmlUrlEditor();
+        protected override string Caption { get; }
+        protected override string Filter { get; }
+        protected override UrlBuilderOptions Options { get; }
+    }
+    public class XsdSchemaFileEditor : UrlEditor {
+        public XsdSchemaFileEditor();
+        protected override string Caption { get; }
+        protected override string Filter { get; }
+    }
+    public class XslTransformFileEditor : UrlEditor {
+        public XslTransformFileEditor();
+        protected override string Caption { get; }
+        protected override string Filter { get; }
+    }
+    public class XslUrlEditor : UrlEditor {
+        public XslUrlEditor();
+        protected override string Caption { get; }
+        protected override string Filter { get; }
+        protected override UrlBuilderOptions Options { get; }
+    }
+}
```


text:
function spectrum(hue, steps, minSat, maxSat, minLig, maxLig){

    var deltaSat = maxSat - minSat;
    var deltaLig = minLig - maxLig;

    var satIncrement = Math.floor(deltaSat / steps);
    var ligIncrement = Math.floor(deltaLig / steps);

    var theSat = minSat;
    var theLig = maxLig;

    var theColors = new Array();

    for(i = 1; i <= steps; i++){
        var theColor = Raphael.hsl2rgb( hue, theSat, theLig);
        theColors[i] = theColor.hex;

        theSat = theSat + satIncrement;
        theLig = theLig + ligIncrement;
    }

    return theColors;
}

jQuery(document).ready(function(){
  // Checking what SDGS are alive on the country page
  var theSDGList = jQuery('.sdg-tabs .sdg-term-list .sdg-icon-list .sdg-icon');
  var activeSDG = [];
  theSDGList.each(function(){
    var sdgIndex = jQuery(this).data('sdg');
    if(jQuery('.country-taxonomy-entry.sdg-class-' + sdgIndex).length > 0){
      activeSDG.push(sdgIndex);
    }
    else {
      jQuery(this).fadeTo(300, 0.2);
    }
  });

  // show/hide organizatons and initiatives on the main country page
  jQuery('.sdg-tabs .sdg-taxonomy-term').click(function(e){
    e.preventDefault();
    var theSDG = jQuery(this).data('sdg');
    jQuery('.country-taxonomy-entry').addClass('sdg-hidden').removeClass('sdg-show');
    jQuery('.country-taxonomy-entry.sdg-class-' + theSDG ).removeClass('sdg-hidden').addClass('sdg-show');
  })

});

redpajama_set_name: RedPajamaGithub


text:
typedef void (^EmptyCompletionBlock)(void);

@interface ZumoSavedAppsTableViewController : UITableViewController
{
    IBOutlet UIButton *editButton;
    IBOutlet UIView *headerView;
}

@property (nonatomic) BOOL savedAppsChanged;
@property (nonatomic, copy) NSString *selectedAppUrl;
@property (nonatomic, copy) NSString *selectedAppKey;
@property (nonatomic, copy) NSMutableArray *savedApps;
@property (nonatomic, strong) EmptyCompletionBlock completion;

- (IBAction)editApps:(id)sender;
- (IBAction)cancel:(id)sender;
- (IBAction)selectApp:(id)sender;

@end


text:
require 'yaml'
require "line_change/version"
require "line_change/errors"
require "line_change/configuration"
require "line_change/deploy"

module LineChange
  DEFAULT_CONFIG = 'config/line_change.yml'.freeze

  def self.config_path
    @config_path ||= ENV['LINE_CHANGE_CONFIG'] || File.expand_path(DEFAULT_CONFIG)
  end

  def self.config_dir
    @config_dir ||= File.dirname(config_path)
  end

  def self.configuration
    @configuration ||= Configuration.new(YAML.load(open(config_path).read))
  end

  def self.deploy(app_id, apk_path)
    Deploy.new(app_id, apk_path).start
  end

  def self.install
    if Configuration.exists?
      puts "You already have a config file in #{config_path}!"
    else
      puts "Generating a new config file: #{config_path}"
      Configuration.create_config(config_dir, config_path)
    end
  end
end


text:
from random import randint

def binary_search(array, element):
    """
    Perform Binary Search by Iterative Method.

    :param array: Iterable of elements
    :param element: element to search
    :return: returns value of index of element (if found) else return None
    """
    left = 0
    right = len(array) - 1
    while left <= right:
        mid = (right + left) // 2
        # indices of a list must be integer
        if array[mid] == element:
            return mid
        elif array[mid] > element:
            right = mid - 1
        else:
            left = mid + 1
    return None

def binary_search_recursive(array, element, left=0, right=None):
    """
    Perform Binary Search by Iterative Method.

    :param array: Iterable of elements
    :param left: start limit of array
    :param right: end limit of array
    :param element: element to be searched
    :return: returns value of index of element (if found) else return None
    """
    right = len(array) - 1 if right is None else right
    if right >= left:
        mid = (right + left) // 2
        if array[mid] == element:
            return mid
        elif array[mid] > element:
            return binary_search_recursive(array, element, left, mid - 1)
        else:
            return binary_search_recursive(array, element, mid + 1, right)
    else:
        return None

def main():
    size = 100  # user can change it
    domain = 100  # user can change it
    array = [1, 9, 11, 13, 5, 7, 8, 5, 17, 1156, 114]
    array.sort()
    element = 13
    result = binary_search_recursive(array, element)
    if result is None:
        print('Recursive Binary Search : Element not present in array')
    else:
        print('Recursive Binary Search : Element is present at index', result)
    result = binary_search(array, element)
    if result is None:
        print('Iterative Binary Search : Element not present in array')
    else:
        print('Iterative Binary Search : Element is present at index', result)

if __name__ == '__main__':
    main()


text:
package com.grapz.betterbuckets.Infrastructure;

import com.grapz.betterbuckets.Infrastructure.Constants.Items;

public class Constants {
	public static final class General {
		public static final String VERSION = "0.1";
		public static final String MODID = "betterbuckets";
		public static final String NAME = "BetterBuckets";
	}

	public static final class Items {
		public static final String GoldBucket = "goldBucket";
	}
}


text:
Introduction
==============
Jitsi-videobridge supports two HTTP(S) interfaces, a _public_ and a _private_ one.
The two interfaces use different ports. The _private_ interface exposes
HTTP endpoints which are not meant to be publicly accessible (but might be used
by other components of the infrastructure, e.g. a signaling server), such as:

* The [COLIBRI control interface](rest-colibri.md) (```/colibri/```)
* The health-check interface (```/about/health```)
* The version interface (```/about/version```)

The _public_ interface is used for Colibri Web Sockets that clients connect to.

Configuration
==============

The following configuration properties can be added to the jitsi-videobridge configuration file (whichever file is
passed to `-Dconfig.file` when running the bridge) to control the behavior of the HTTP interfaces

For the _private_ interface, use the following block and values:

```hocon
videobridge {
    http-servers {
        private {
            // The port for the private HTTP interface (or -1 to disable it).  Defaults to 8080.
            port = <Number>
            // The port for the private HTTP interface if TLS is to be used (or -1 to disable). Defaults to 8443.
            tls-port = <Number>
            // The address on which the server will listen
            host = <String>
            // The file path to the keystore to be used with HTTPS for the private interface.  If this is not specified,
            // HTTPS is disabled for the private interface
            key-store-path = <String (path to key store)>
            // The password to be used by the SslContextFactory when HTTPS is used
            key-store-password = <String>
            // Whether or not client certificate authentication is to be required when
            // HTTPS is used
            need-client-auth: <Boolean>
        }
    }
}
```

The _public_ interface uses the same values, but under a different scope:

```hocon
videobridge {
    http-servers {
        public {
            // Same values as above
        }
    }
}
```


text:
How to create an extension for Sylius?
======================================

Sylius extension is nothing more but a regular Symfony bundle adding custom behaviour to the default Sylius application.

The best way to create your own extension is to use `Sylius bundle skeleton <https://github.com/Sylius/BundleSkeleton>`_,
which has built-in infrastructure for designing and testing using `Behat <http://behat.org/en/latest/>`_.

1. Create project using Composer.
---------------------------------

.. code-block:: bash

    $ composer create-project sylius/bundle-skeleton SyliusExtensionPath

.. note::

    The extension can be created anywhere, not only inside Sylius application, because it already has the test environment inside.

2. Get familiar with basic extension design.
--------------------------------------------

The skeleton comes with simple application that greets a customer. There are feature scenarios in ``features`` directory;
exemplary bundle with a controller, a template and a routing configuration in ``src``;
and the testing infrastructure in ``tests``.

.. note::

    The ``tests/Application`` directory contains a sample Symfony application used to test your extension.

3. Remove boilerplate files and rename your bundle.
---------------------------------------------------

In most cases you don't want your Sylius extension to greet customer like it is now, so feel free to remove unnecessary
controllers, assets and features. You will also want to change the extension's namespace from ``Acme\ExampleBundle`` to a
more meaningful one. Keep in mind that these changes also need to be done in ``tests/Application`` and ``composer.json``.

4. Implement your awesome features.
-----------------------------------

Looking at existing Sylius extensions like `Lakion\SyliusCmsBundle`_ or `Lakion\SyliusElasticSearchBundle`_ is
a great way to start developing your own extensions.

Feel free to use `BDD`_ with `Behat`_, `phpspec`_ and `PhpUnit`_ to ensure your extension's extraordinary quality.

.. _`Lakion\SyliusCmsBundle`: https://github.com/Lakion/SyliusCmsBundle
.. _`Lakion\SyliusElasticSearchBundle`: https://github.com/Lakion/SyliusElasticSearchBundle
.. _`BDD`: https://en.wikipedia.org/wiki/Behavior-driven_development
.. _`Behat`: http://behat.org/en/latest/
.. _`phpspec`: http://www.phpspec.net/en/stable/
.. _`PHPUnit`: https://phpunit.de/


text:
    <md-tabs md-selected="step" flex-sm="100" flex-md="90" flex-lg="80" flex-gt-lg="66" class="md-whiteframe-z4">
      <md-tab label="Intro" ng-disabled="!(step==0)">

A lot of Google Maps use cases require to plot regions, such as sales sectors, maintenance zones or potential
          customer markets. Doing this by hands is often tedious and error-prone. Since a lot of use cases are based on
          administrative boundaries (states, cities and others), our best option
          is to use the administrative boundary as a starting point.

On the map below you can see the French "départment" called Loir Et Cher. You are going to split this
          administrative region in two sales zones.

          <md-button class="md-raised md-primary" ng-click="startDemo()">Start</md-button>

      </md-tab>
      <md-tab label="1. Select the region to split" ng-disabled="!(step==1)">

First, click on the Loir-Et-Cher's boundary to start splitting the region.

When your cursor is on top of the boundary, it changes color. Click when the boundary becomes black.

            <video autoplay="autoplay" loop>
              <source src="videos/maps1.mp4" type="video/mp4">
              Your browser does not support the video tag.
            </video>

      </md-tab>
      <md-tab label="2. Define the new boundary" ng-disabled="!(step==2)">

Now, click inside the département to draw a polyline that will be the boundary separating our two new
              zones.

Click on other points in the département to extend the polyline.

When you are done, just click one last time on the département's boundary to finish the polyline.

            <video autoplay="autoplay" loop>
              <source src="videos/maps2.mp4" type="video/mp4">
              Your browser does not support the video tag.
            </video>

      </md-tab>
      <md-tab label="3. Finish splitting" ng-disabled="!(step==3)">

You can continue clicking to extend the polyline.

When you are done, just click one last time on the département's boundary to finish the polyline.

            <video autoplay="autoplay" loop>
              <source src="videos/maps3.mp4" type="video/mp4">
              Your browser does not support the video tag.
            </video>

      </md-tab>
      <md-tab label="4. Test your new regions" ng-disabled="!(step==4)">

The département should now be split in two regions in light and dark blue.

Let us imagine that we have two sales representative, and that each sales rep has been assigned one of
              those new regions.

Use the text on the right to input an address and see which sales rep we will assign to visit this
              address. If you do not know well the geography of Loire Et Cher, use one of the predefined addresses.

              <md-input-container flex layout-align="center start" layout="column" layout-fill>

Input an address here :

                  <input type="text" ng-model="testAddress.text" flex="80" flex-order="1">
                  <md-button class="md-raised md-primary" ng-click="testFreeAddress()" flex="20" flex-order="2">Test
                  </md-button>

Or use one of those :

                <md-button class="md-raised" ng-click="testGeocodedAddress(47.887905, 1.207687)">32 Rue Louis et
                  M-Louise Tessier
                  41160 Fréteval
                  France
                </md-button>

                <md-button class="md-raised" ng-click="testGeocodedAddress(47.358524, 1.747364)">17 Faubourg Saint-Roch
                  41200 Romorantin-Lanthenay
                  France
                </md-button>
              </md-input-container>

      </md-tab>
      </md-tab>
    </md-tabs>

    <hatanian-gmap style="width:100%; height: 700px" add-marker="newMarker" on-splitted="onSplitted()" on-splitting-start="onSplittingStart()"
                   on-first-segment-drawn="onFirstSegmentDrawn()"></hatanian-gmap>


text:
<?php

namespace tests\QATools\QATools\HtmlElementsLive\Element;

use QATools\QATools\HtmlElements\Element\LabeledElement;

class LabeledElementTest extends TypifiedElementTestCase
{

	protected function setUp()
	{
		parent::setUp();

		$this->elementClass = '\\QATools\\QATools\\HtmlElements\\Element\\LabeledElement';
	}

	/**
	 * @dataProvider labelDataProvider
	 */
	public function testGetLabel($id, $label_text)
	{
		/* @var $label_element LabeledElement */
		$label_element = $this->createElement(array('id' => $id));
		$label = $label_element->getLabel();

		if ( is_null($label_text) ) {
			$this->assertNull($label);
		}
		else {
			$this->assertEquals($label_text, $label->getText());
		}
	}

	/**
	 * @dataProvider labelDataProvider
	 */
	public function testGetLabelText($id, $label_text)
	{
		/* @var $label_element LabeledElement */
		$label_element = $this->createElement(array('id' => $id));
		$this->assertSame($label_text, $label_element->getLabelText());
	}

	/**
	 * @dataProvider labelDataProvider
	 */
	public function testGetText($id, $label_text)
	{
		/* @var $label_element LabeledElement */
		$label_element = $this->createElement(array('id' => $id));
		$this->assertSame($label_text, $label_element->getText());
	}

	/**
	 * Provides test data for label detection.
	 *
	 * @return array
	 */
	public function labelDataProvider()
	{
		return array(
			array('checkbox-without-label', null),
			array('checkbox-with-label', 'label text 2'),
			array('checkbox-inside-label', 'label text 3'),
		);
	}

}


text:
#include <fcntl.h>
#include <stdio.h>
#include <semaphore.h>
#include <signal.h>
#include <vector>
#include <queue>
#include <map>
#include <yaml-cpp/yaml.h>
#include <iostream>
#include "io/BaseStream.h"

#include "core/Core.h"

#include "core/FlowConfiguration.h"
#include "core/ConfigurationFactory.h"
#include "core/RepositoryFactory.h"
#include "FlowController.h"
#include "Main.h"
#include "properties/Configure.h"
#include "Controller.h"
#include "c2/ControllerSocketProtocol.h"

#include "cxxopts.hpp"

int main(int argc, char **argv) {

  std::shared_ptr<logging::Logger> logger = logging::LoggerConfiguration::getConfiguration().getLogger("controller");

  // assumes POSIX compliant environment
  std::string minifiHome;
  if (const char *env_p = std::getenv(MINIFI_HOME_ENV_KEY)) {
    minifiHome = env_p;
    logger->log_info("Using MINIFI_HOME=%s from environment.", minifiHome);
  } else {
    logger->log_info("MINIFI_HOME is not set; determining based on environment.");
    char *path = nullptr;
    char full_path[PATH_MAX];
    path = realpath(argv[0], full_path);

    if (path != nullptr) {
      std::string minifiHomePath(path);
      if (minifiHomePath.find_last_of("/\\") != std::string::npos) {
        minifiHomePath = minifiHomePath.substr(0, minifiHomePath.find_last_of("/\\"));  //Remove /minifi from path
        minifiHome = minifiHomePath.substr(0, minifiHomePath.find_last_of("/\\"));    //Remove /bin from path
      }
    }

    // attempt to use cwd as MINIFI_HOME
    if (minifiHome.empty() || !validHome(minifiHome)) {
      char cwd[PATH_MAX];
      #ifdef WIN32
          _getcwd(cwd,PATH_MAX);
      #else
          getcwd(cwd, PATH_MAX);
      #endif
      minifiHome = cwd;
    }

  }

  if (!validHome(minifiHome)) {
    logger->log_error("No valid MINIFI_HOME could be inferred. "
                      "Please set MINIFI_HOME or run minifi from a valid location.");
    //return -1;
  }

  std::shared_ptr<minifi::Configure> configuration = std::make_shared<minifi::Configure>();
  configuration->setHome(minifiHome);
  configuration->loadConfigureFile(DEFAULT_NIFI_PROPERTIES_FILE);

  std::shared_ptr<logging::LoggerProperties> log_properties = std::make_shared<logging::LoggerProperties>();
  log_properties->setHome(minifiHome);
  log_properties->loadConfigureFile(DEFAULT_LOG_PROPERTIES_FILE);
  logging::LoggerConfiguration::getConfiguration().initialize(log_properties);

  std::string context_name;

  std::shared_ptr<minifi::controllers::SSLContextService> secure_context = nullptr;

  // if the user wishes to use a controller service we need to instantiate the flow
  if (configuration->get("controller.ssl.context.service", context_name)) {
    std::shared_ptr<core::controller::ControllerService> service = getControllerService(configuration, context_name);
    if (nullptr != service) {
      secure_context = std::static_pointer_cast<minifi::controllers::SSLContextService>(service);
    }
  }

  if (nullptr == secure_context) {
    std::string secureStr;
    bool is_secure = false;
    if (configuration->get(minifi::Configure::nifi_remote_input_secure, secureStr) && org::apache::nifi::minifi::utils::StringUtils::StringToBool(secureStr, is_secure)) {
      secure_context = std::make_shared<minifi::controllers::SSLContextService>("ControllerSocketProtocolSSL", configuration);
      secure_context->onEnable();
    }
  }

  std::string value;

  auto stream_factory_ = minifi::io::StreamFactory::getInstance(configuration);

  std::string host = "localhost", portStr, caCert;
  int port = -1;

  cxxopts::Options options("MiNiFiController", "MiNiFi local agent controller");
  options.positional_help("[optional args]").show_positional_help();

  options.add_options()  //NOLINT
  ("h,help", "Shows Help")  //NOLINT
  ("host", "Specifies connecting host name", cxxopts::value<std::string>())  //NOLINT
  ("port", "Specifies connecting host port", cxxopts::value<int>())  //NOLINT
  ("stop", "Shuts down the provided component", cxxopts::value<std::vector<std::string>>())  //NOLINT
  ("start", "Starts provided component", cxxopts::value<std::vector<std::string>>())  //NOLINT
  ("l,list", "Provides a list of connections or processors", cxxopts::value<std::string>())  //NOLINT
  ("c,clear", "Clears the associated connection queue", cxxopts::value<std::vector<std::string>>())  //NOLINT
  ("getsize", "Reports the size of the associated connection queue", cxxopts::value<std::vector<std::string>>())  //NOLINT
  ("updateflow", "Updates the flow of the agent using the provided flow file", cxxopts::value<std::string>())  //NOLINT
  ("getfull", "Reports a list of full connections")  //NOLINT
  ("jstack", "Returns backtraces from the agent")  //NOLINT
  ("manifest", "Generates a manifest for the current binary")  //NOLINT
  ("noheaders", "Removes headers from output streams");

  bool show_headers = true;

  try {
    auto result = options.parse(argc, argv);

    if (result.count("help")) {
      std::cout << options.help( { "", "Group" }) << std::endl;
      exit(0);
    }

    if (result.count("host")) {
      host = result["host"].as<std::string>();
    } else {
      configuration->get("controller.socket.host", host);
    }

    if (result.count("port")) {
      port = result["port"].as<int>();
    } else {
      if (port == -1 && configuration->get("controller.socket.port", portStr)) {
        port = std::stoi(portStr);
      }
    }

    if ((IsNullOrEmpty(host) && port == -1)) {
      std::cout << "MiNiFi Controller is disabled" << std::endl;
      exit(0);
    } else

    if (result.count("noheaders")) {
      show_headers = false;
    }

    if (result.count("stop") > 0) {
      auto& components = result["stop"].as<std::vector<std::string>>();
      for (const auto& component : components) {
        auto socket = secure_context != nullptr ? stream_factory_->createSecureSocket(host, port, secure_context) : stream_factory_->createSocket(host, port);
        if (stopComponent(std::move(socket), component))
          std::cout << component << " requested to stop" << std::endl;
        else
          std::cout << "Could not connect to remote host " << host << ":" << port << std::endl;
      }
    }

    if (result.count("start") > 0) {
      auto& components = result["start"].as<std::vector<std::string>>();
      for (const auto& component : components) {
        auto socket = secure_context != nullptr ? stream_factory_->createSecureSocket(host, port, secure_context) : stream_factory_->createSocket(host, port);
        if (startComponent(std::move(socket), component))
          std::cout << component << " requested to start" << std::endl;
        else
          std::cout << "Could not connect to remote host " << host << ":" << port << std::endl;
      }
    }

    if (result.count("c") > 0) {
      auto& components = result["c"].as<std::vector<std::string>>();
      for (const auto& connection : components) {
        auto socket = secure_context != nullptr ? stream_factory_->createSecureSocket(host, port, secure_context) : stream_factory_->createSocket(host, port);
        if (clearConnection(std::move(socket), connection)) {
          std::cout << "Sent clear command to " << connection << ". Size before clear operation sent: " << std::endl;
          socket = secure_context != nullptr ? stream_factory_->createSecureSocket(host, port, secure_context) : stream_factory_->createSocket(host, port);
          if (getConnectionSize(std::move(socket), std::cout, connection) < 0)
            std::cout << "Could not connect to remote host " << host << ":" << port << std::endl;
        } else
          std::cout << "Could not connect to remote host " << host << ":" << port << std::endl;
      }
    }

    if (result.count("getsize") > 0) {
      auto& components = result["getsize"].as<std::vector<std::string>>();
      for (const auto& component : components) {
        auto socket = secure_context != nullptr ? stream_factory_->createSecureSocket(host, port, secure_context) : stream_factory_->createSocket(host, port);
        if (getConnectionSize(std::move(socket), std::cout, component) < 0)
          std::cout << "Could not connect to remote host " << host << ":" << port << std::endl;
      }

    }

    if (result.count("l") > 0) {
      auto& option = result["l"].as<std::string>();
      auto socket = secure_context != nullptr ? stream_factory_->createSecureSocket(host, port, secure_context) : stream_factory_->createSocket(host, port);
      if (option == "components") {
        if (listComponents(std::move(socket), std::cout, show_headers) < 0)
          std::cout << "Could not connect to remote host " << host << ":" << port << std::endl;
      } else if (option == "connections") {
        if (listConnections(std::move(socket), std::cout, show_headers) < 0)
          std::cout << "Could not connect to remote host " << host << ":" << port << std::endl;
      }

    }

    if (result.count("getfull") > 0) {
      auto socket = secure_context != nullptr ? stream_factory_->createSecureSocket(host, port, secure_context) : stream_factory_->createSocket(host, port);
      if (getFullConnections(std::move(socket), std::cout) < 0)
        std::cout << "Could not connect to remote host " << host << ":" << port << std::endl;
    }

    if (result.count("jstack") > 0) {
      auto socket = secure_context != nullptr ? stream_factory_->createSecureSocket(host, port, secure_context) : stream_factory_->createSocket(host, port);
      if (getJstacks(std::move(socket), std::cout) < 0)
        std::cout << "Could not connect to remote host " << host << ":" << port << std::endl;
    }

    if (result.count("updateflow") > 0) {
      auto& flow_file = result["updateflow"].as<std::string>();
      auto socket = secure_context != nullptr ? stream_factory_->createSecureSocket(host, port, secure_context) : stream_factory_->createSocket(host, port);
      if (updateFlow(std::move(socket), std::cout, flow_file) < 0)
        std::cout << "Could not connect to remote host " << host << ":" << port << std::endl;
    }

    if (result.count("manifest") > 0) {
      printManifest(configuration);
    }
  } catch (const std::exception &exc) {
    // catch anything thrown within try block that derives from std::exception
    std::cerr << exc.what() << std::endl;
  } catch (...) {
    std::cout << options.help( { "", "Group" }) << std::endl;
    exit(0);
  }
  return 0;
}


text:
<!doctype html>

  <meta charset="UTF-8">
  <title>Cardborde</title>
  <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">

  <link rel="stylesheet" type="text/css" href="/components/normalize.css/normalize.css">
  <link rel="stylesheet" type="text/css" href="/dist/cardborde.css">

Cardborde

Home

Popup

Build with ❤ and SASS

        <button type="button" class="close">×</button>
        This is a title

        Test


text:
<?php

class Google_Service_Dataflow_DynamicSourceSplit extends Google_Model
{
  protected $primaryType = 'Google_Service_Dataflow_DerivedSource';
  protected $primaryDataType = '';
  protected $residualType = 'Google_Service_Dataflow_DerivedSource';
  protected $residualDataType = '';

  /**
   * @param Google_Service_Dataflow_DerivedSource
   */
  public function setPrimary(Google_Service_Dataflow_DerivedSource $primary)
  {
    $this->primary = $primary;
  }
  /**
   * @return Google_Service_Dataflow_DerivedSource
   */
  public function getPrimary()
  {
    return $this->primary;
  }
  /**
   * @param Google_Service_Dataflow_DerivedSource
   */
  public function setResidual(Google_Service_Dataflow_DerivedSource $residual)
  {
    $this->residual = $residual;
  }
  /**
   * @return Google_Service_Dataflow_DerivedSource
   */
  public function getResidual()
  {
    return $this->residual;
  }
}