@tsonic/dotnet/System.ComponentModel/internal/index.d.ts

TypeScript type definitions for .NET 10 BCL (Base Class Library)

// Generated by tsbindgen - Architecture
// Namespace: System.ComponentModel
// Assembly: System.ComponentModel, System.ComponentModel.EventBasedAsync, System.ComponentModel.Primitives, System.ComponentModel.TypeConverter, System.ObjectModel, System.Private.CoreLib

// Branded primitive types are sourced from @tsonic/types
import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/types';

// Import support types from @tsonic/types
import type { ptr, ref } from "@tsonic/types";

// Import types from other namespaces
import * as System_Collections_Generic_Internal from "../../System.Collections.Generic/internal/index.js";
import type { ICollection_1, IEnumerable_1, IEnumerator_1, IList_1, IReadOnlyCollection_1, IReadOnlyList_1 } from "../../System.Collections.Generic/internal/index.js";
import * as System_Collections_ObjectModel_Internal from "../../System.Collections.ObjectModel/internal/index.js";
import type { Collection_1 } from "../../System.Collections.ObjectModel/internal/index.js";
import * as System_Collections_Internal from "../../System.Collections/internal/index.js";
import type { Hashtable, ICollection, IComparer, IDictionary, IDictionaryEnumerator, IEnumerable, IEnumerator, IList, ReadOnlyCollectionBase } from "../../System.Collections/internal/index.js";
import type { IDesigner } from "../../System.ComponentModel.Design/internal/index.js";
import type { CultureInfo } from "../../System.Globalization/internal/index.js";
import type { UnmanagedMemoryStream } from "../../System.IO/internal/index.js";
import type { Assembly, MethodBase, MethodInfo, Module } from "../../System.Reflection/internal/index.js";
import * as System_Resources_Internal from "../../System.Resources/internal/index.js";
import type { ResourceManager, ResourceSet } from "../../System.Resources/internal/index.js";
import * as System_Runtime_InteropServices_Internal from "../../System.Runtime.InteropServices/internal/index.js";
import type { ExternalException } from "../../System.Runtime.InteropServices/internal/index.js";
import * as System_Runtime_Serialization_Internal from "../../System.Runtime.Serialization/internal/index.js";
import type { ISerializable, SerializationInfo, StreamingContext } from "../../System.Runtime.Serialization/internal/index.js";
import type { SendOrPostCallback, SynchronizationContext } from "../../System.Threading/internal/index.js";
import * as System_Internal from "../../System/internal/index.js";
import type { ArgumentException, Array as ClrArray, AsyncCallback, Attribute, Boolean as ClrBoolean, Byte, Char, Delegate, Double, Enum, EventArgs, EventHandler, EventHandler_1, Exception, IAsyncResult, ICloneable, IComparable, IConvertible, IDisposable, IFormatProvider, IFormattable, Int16, Int32, Int64, IntPtr, IServiceProvider, ISpanFormattable, MarshalByRefObject, MulticastDelegate, Nullable_1, Object as ClrObject, SByte, Single, String as ClrString, SystemException, Type, TypeCode, UInt16, UInt32, UInt64, Void } from "../../System/internal/index.js";

// CLROf<T> - Maps ergonomic primitives to their CLR types for generic constraints
// This utility is used ONLY in generic type arguments to satisfy CLR interface constraints
// Value positions (parameters, return types) use lowercase primitives for ergonomics
export type CLROf<T> =
    T extends sbyte ? System_Internal.SByte :
    T extends short ? System_Internal.Int16 :
    T extends int ? System_Internal.Int32 :
    T extends long ? System_Internal.Int64 :
    T extends int128 ? System_Internal.Int128 :
    T extends nint ? System_Internal.IntPtr :
    T extends byte ? System_Internal.Byte :
    T extends ushort ? System_Internal.UInt16 :
    T extends uint ? System_Internal.UInt32 :
    T extends ulong ? System_Internal.UInt64 :
    T extends uint128 ? System_Internal.UInt128 :
    T extends nuint ? System_Internal.UIntPtr :
    T extends half ? System_Internal.Half :
    T extends float ? System_Internal.Single :
    T extends double ? System_Internal.Double :
    T extends decimal ? System_Internal.Decimal :
    T extends char ? System_Internal.Char :
    T extends boolean ? System_Internal.Boolean :
    T extends string ? System_Internal.String :
    T; // Identity fallback for non-primitive types

export enum BindableSupport {
    no = 0,
    yes = 1,
    default_ = 2
}


export enum BindingDirection {
    oneWay = 0,
    twoWay = 1
}


export enum CollectionChangeAction {
    add = 1,
    remove = 2,
    refresh = 3
}


export enum DataObjectMethodType {
    fill = 0,
    select = 1,
    update = 2,
    insert = 3,
    delete_ = 4
}


export enum DesignerSerializationVisibility {
    hidden = 0,
    visible = 1,
    content = 2
}


export enum EditorBrowsableState {
    always = 0,
    never_ = 1,
    advanced = 2
}


export enum InheritanceLevel {
    inherited = 1,
    inheritedReadOnly = 2,
    notInherited = 3
}


export enum LicenseUsageMode {
    runtime = 0,
    designtime = 1
}


export enum ListChangedType {
    reset = 0,
    itemAdded = 1,
    itemDeleted = 2,
    itemMoved = 3,
    itemChanged = 4,
    propertyDescriptorAdded = 5,
    propertyDescriptorDeleted = 6,
    propertyDescriptorChanged = 7
}


export enum ListSortDirection {
    ascending = 0,
    descending = 1
}


export enum MaskedTextResultHint {
    unknown_ = 0,
    characterEscaped = 1,
    noEffect = 2,
    sideEffect = 3,
    success = 4,
    asciiCharacterExpected = -1,
    alphanumericCharacterExpected = -2,
    digitExpected = -3,
    letterExpected = -4,
    signedDigitExpected = -5,
    invalidInput = -51,
    promptCharNotAllowed = -52,
    unavailableEditPosition = -53,
    nonEditPosition = -54,
    positionOutOfRange = -55
}


export enum PropertyTabScope {
    static_ = 0,
    global = 1,
    document = 2,
    component = 3
}


export enum RefreshProperties {
    none = 0,
    all = 1,
    repaint = 2
}


export enum ToolboxItemFilterType {
    allow = 0,
    custom = 1,
    prevent = 2,
    require = 3
}


export type AddingNewEventHandler = (sender: unknown, e: AddingNewEventArgs) => void;


export type AsyncCompletedEventHandler = (sender: unknown, e: AsyncCompletedEventArgs) => void;


export type CancelEventHandler = (sender: unknown, e: CancelEventArgs) => void;


export type CollectionChangeEventHandler = (sender: unknown, e: CollectionChangeEventArgs) => void;


export type DoWorkEventHandler = (sender: unknown, e: DoWorkEventArgs) => void;


export type HandledEventHandler = (sender: unknown, e: HandledEventArgs) => void;


export type ListChangedEventHandler = (sender: unknown, e: ListChangedEventArgs) => void;


export type ProgressChangedEventHandler = (sender: unknown, e: ProgressChangedEventArgs) => void;


export type PropertyChangedEventHandler = (sender: unknown, e: PropertyChangedEventArgs) => void;


export type PropertyChangingEventHandler = (sender: unknown, e: PropertyChangingEventArgs) => void;


export type RefreshEventHandler = (e: RefreshEventArgs) => void;


export type RunWorkerCompletedEventHandler = (sender: unknown, e: RunWorkerCompletedEventArgs) => void;


export interface IBindingList$instance extends IList, ICollection, IEnumerable {
    readonly allowNew: boolean;
    readonly allowEdit: boolean;
    readonly allowRemove: boolean;
    readonly supportsChangeNotification: boolean;
    readonly supportsSearching: boolean;
    readonly supportsSorting: boolean;
    readonly isSorted: boolean;
    readonly sortProperty: PropertyDescriptor;
    readonly sortDirection: ListSortDirection;
    item: unknown;
    readonly isReadOnly: boolean;
    readonly isFixedSize: boolean;
    readonly count: int;
    readonly syncRoot: unknown;
    readonly isSynchronized: boolean;
    add(value: unknown): int;
    addIndex(property: PropertyDescriptor): void;
    addNew(): unknown;
    applySort(property: PropertyDescriptor, direction: ListSortDirection): void;
    contains(value: unknown): boolean;
    copyTo(array: ClrArray, index: int): void;
    find(property: PropertyDescriptor, key: unknown): int;
    getEnumerator(): IEnumerator;
    insert(index: int, value: unknown): void;
    remove(value: unknown): void;
    removeAt(index: int): void;
    removeSort(): void;
}


export type IBindingList = IBindingList$instance;

export interface IBindingListView$instance extends IBindingList, IList, ICollection, IEnumerable {
    filter: string;
    readonly sortDescriptions: ListSortDescriptionCollection;
    readonly supportsAdvancedSorting: boolean;
    readonly supportsFiltering: boolean;
    readonly allowNew: boolean;
    readonly allowEdit: boolean;
    readonly allowRemove: boolean;
    readonly supportsChangeNotification: boolean;
    readonly supportsSearching: boolean;
    readonly supportsSorting: boolean;
    readonly isSorted: boolean;
    readonly sortProperty: PropertyDescriptor;
    readonly sortDirection: ListSortDirection;
    item: unknown;
    readonly isReadOnly: boolean;
    readonly isFixedSize: boolean;
    readonly count: int;
    readonly syncRoot: unknown;
    readonly isSynchronized: boolean;
    add(value: unknown): int;
    addIndex(property: PropertyDescriptor): void;
    addNew(): unknown;
    applySort(property: PropertyDescriptor, direction: ListSortDirection): void;
    applySort(sorts: ListSortDescriptionCollection): void;
    contains(value: unknown): boolean;
    copyTo(array: ClrArray, index: int): void;
    find(property: PropertyDescriptor, key: unknown): int;
    getEnumerator(): IEnumerator;
    insert(index: int, value: unknown): void;
    remove(value: unknown): void;
    removeAt(index: int): void;
    removeFilter(): void;
}


export type IBindingListView = IBindingListView$instance;

export interface ICancelAddNew$instance {
    cancelNew(itemIndex: int): void;
}


export type ICancelAddNew = ICancelAddNew$instance;

export interface IChangeTracking$instance {
    readonly isChanged: boolean;
    acceptChanges(): void;
}


export type IChangeTracking = IChangeTracking$instance;

export interface IComNativeDescriptorHandler$instance {
    getAttributes(component: unknown): AttributeCollection;
    getClassName(component: unknown): string;
    getConverter(component: unknown): TypeConverter;
    getDefaultEvent(component: unknown): EventDescriptor;
    getDefaultProperty(component: unknown): PropertyDescriptor;
    getEditor(component: unknown, baseEditorType: Type): unknown;
    getEvents(component: unknown, attributes: Attribute[]): EventDescriptorCollection;
    getEvents(component: unknown): EventDescriptorCollection;
    getProperties(component: unknown, attributes: Attribute[]): PropertyDescriptorCollection;
    getPropertyValue(component: unknown, dispid: int, success: { value: ref<boolean> }): unknown;
    getPropertyValue(component: unknown, propertyName: string, success: { value: ref<boolean> }): unknown;
}


export type IComNativeDescriptorHandler = IComNativeDescriptorHandler$instance;

export interface IComponent$instance extends IDisposable {
    site: ISite;
    dispose(): void;
}


export interface IComponent$instance extends System_Internal.IDisposable$instance {}

export type IComponent = IComponent$instance;

export interface IContainer$instance extends IDisposable {
    readonly components: ComponentCollection;
    add(component: IComponent, name: string): void;
    add(component: IComponent): void;
    dispose(): void;
}


export interface IContainer$instance extends System_Internal.IDisposable$instance {}

export type IContainer = IContainer$instance;

export interface ICustomTypeDescriptor$instance {
    readonly requireRegisteredTypes: Nullable_1<CLROf<boolean>>;
    getAttributes(): AttributeCollection;
    getClassName(): string;
    getConverter(): TypeConverter;
    getDefaultEvent(): EventDescriptor;
    getDefaultProperty(): PropertyDescriptor;
    getEditor(editorBaseType: Type): unknown;
    getEvents(): EventDescriptorCollection;
    getEvents(attributes: Attribute[]): EventDescriptorCollection;
    getProperties(): PropertyDescriptorCollection;
    getProperties(attributes: Attribute[]): PropertyDescriptorCollection;
    getPropertyOwner(pd: PropertyDescriptor): unknown;
}


export type ICustomTypeDescriptor = ICustomTypeDescriptor$instance;

export interface IDataErrorInfo$instance {
    readonly item: string;
    readonly error: string;
}


export type IDataErrorInfo = IDataErrorInfo$instance;

export interface IEditableObject$instance {
    beginEdit(): void;
}


export type IEditableObject = IEditableObject$instance;

export interface IExtenderProvider$instance {
    canExtend(extendee: unknown): boolean;
}


export type IExtenderProvider = IExtenderProvider$instance;

export interface IIntellisenseBuilder$instance {
    readonly name: string;
    show(language: string, value: string, newValue: { value: ref<string> }): boolean;
}


export type IIntellisenseBuilder = IIntellisenseBuilder$instance;

export interface IListSource$instance {
    readonly containsListCollection: boolean;
    getList(): IList;
}


export type IListSource = IListSource$instance;

export interface INestedContainer$instance extends IContainer, IDisposable {
    readonly owner: IComponent;
    readonly components: ComponentCollection;
    add(component: IComponent, name: string): void;
    add(component: IComponent): void;
    dispose(): void;
}


export type INestedContainer = INestedContainer$instance;

export interface INestedSite$instance extends ISite, IServiceProvider {
    readonly fullName: string;
    readonly component: IComponent;
    readonly container: IContainer;
    readonly designMode: boolean;
    name: string;
    getService(serviceType: Type): unknown;
}


export type INestedSite = INestedSite$instance;

export interface INotifyDataErrorInfo$instance {
    readonly hasErrors: boolean;
    getErrors(propertyName: string): IEnumerable;
}


export type INotifyDataErrorInfo = INotifyDataErrorInfo$instance;

export interface INotifyPropertyChanged$instance {
}


export type INotifyPropertyChanged = INotifyPropertyChanged$instance;

export interface INotifyPropertyChanging$instance {
}


export type INotifyPropertyChanging = INotifyPropertyChanging$instance;

export interface IRaiseItemChangedEvents$instance {
    readonly raisesItemChangedEvents: boolean;
}


export type IRaiseItemChangedEvents = IRaiseItemChangedEvents$instance;

export interface IRevertibleChangeTracking$instance extends IChangeTracking {
    readonly isChanged: boolean;
    rejectChanges(): void;
}


export interface IRevertibleChangeTracking$instance extends IChangeTracking$instance {}

export type IRevertibleChangeTracking = IRevertibleChangeTracking$instance;

export interface ISite$instance extends IServiceProvider {
    readonly component: IComponent;
    readonly container: IContainer;
    readonly designMode: boolean;
    name: string;
    getService(serviceType: Type): unknown;
}


export interface ISite$instance extends System_Internal.IServiceProvider$instance {}

export type ISite = ISite$instance;

export interface ISupportInitialize$instance {
    beginInit(): void;
}


export type ISupportInitialize = ISupportInitialize$instance;

export interface ISupportInitializeNotification$instance extends ISupportInitialize {
    readonly isInitialized: boolean;
    beginInit(): void;
}


export interface ISupportInitializeNotification$instance extends ISupportInitialize$instance {}

export type ISupportInitializeNotification = ISupportInitializeNotification$instance;

export interface ISynchronizeInvoke$instance {
    readonly invokeRequired: boolean;
    beginInvoke(method: Function, args: unknown[]): IAsyncResult;
    endInvoke(result: IAsyncResult): unknown;
    invoke(method: Function, args: unknown[]): unknown;
}


export type ISynchronizeInvoke = ISynchronizeInvoke$instance;

export interface ITypeDescriptorContext$instance extends IServiceProvider {
    readonly container: IContainer;
    readonly instance: unknown;
    readonly propertyDescriptor: PropertyDescriptor;
    getService(serviceType: Type): unknown;
    onComponentChanged(): void;
    onComponentChanging(): boolean;
}


export interface ITypeDescriptorContext$instance extends System_Internal.IServiceProvider$instance {}

export type ITypeDescriptorContext = ITypeDescriptorContext$instance;

export interface ITypedList$instance {
    getItemProperties(listAccessors: PropertyDescriptor[]): PropertyDescriptorCollection;
    getListName(listAccessors: PropertyDescriptor[]): string;
}


export type ITypedList = ITypedList$instance;

export interface AddingNewEventArgs$instance extends EventArgs {
    newObject: unknown;
}


export const AddingNewEventArgs: {
    new(): AddingNewEventArgs$instance;
    new(newObject: unknown): AddingNewEventArgs$instance;
};


export type AddingNewEventArgs = AddingNewEventArgs$instance;

export interface AmbientValueAttribute$instance extends Attribute {
    readonly value: unknown;
    equals(obj: unknown): boolean;
    getHashCode(): int;
}


export const AmbientValueAttribute: {
    new(type_: Type, value: string): AmbientValueAttribute$instance;
    new(value: char): AmbientValueAttribute$instance;
    new(value: byte): AmbientValueAttribute$instance;
    new(value: short): AmbientValueAttribute$instance;
    new(value: int): AmbientValueAttribute$instance;
    new(value: long): AmbientValueAttribute$instance;
    new(value: float): AmbientValueAttribute$instance;
    new(value: double): AmbientValueAttribute$instance;
    new(value: boolean): AmbientValueAttribute$instance;
    new(value: string): AmbientValueAttribute$instance;
    new(value: unknown): AmbientValueAttribute$instance;
};


export type AmbientValueAttribute = AmbientValueAttribute$instance;

export interface ArrayConverter$instance extends CollectionConverter {
    convertTo(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown, destinationType: Type): unknown;
    convertTo(value: unknown, destinationType: Type): unknown;
    getProperties(context: ITypeDescriptorContext, value: unknown, attributes: Attribute[]): PropertyDescriptorCollection;
    getProperties(value: unknown): PropertyDescriptorCollection;
    getProperties(context: ITypeDescriptorContext, value: unknown): PropertyDescriptorCollection;
    getPropertiesSupported(context: ITypeDescriptorContext): boolean;
    getPropertiesSupported(): boolean;
}


export const ArrayConverter: {
    new(): ArrayConverter$instance;
};


export type ArrayConverter = ArrayConverter$instance;

export interface AsyncCompletedEventArgs$instance extends EventArgs {
    readonly cancelled: boolean;
    readonly error: Exception;
    readonly userState: unknown;
}


export const AsyncCompletedEventArgs: {
    new(error: Exception, cancelled: boolean, userState: unknown): AsyncCompletedEventArgs$instance;
};


export type AsyncCompletedEventArgs = AsyncCompletedEventArgs$instance;

export interface AsyncOperation$instance {
    readonly synchronizationContext: SynchronizationContext;
    readonly userSuppliedState: unknown;
    operationCompleted(): void;
    post(d: SendOrPostCallback, arg: unknown): void;
    postOperationCompleted(d: SendOrPostCallback, arg: unknown): void;
}


export const AsyncOperation: {
    new(): AsyncOperation$instance;
};


export type AsyncOperation = AsyncOperation$instance;

export interface AttributeCollection$instance {
    readonly count: int;
    contains(attribute: Attribute): boolean;
    contains(attributes: Attribute[]): boolean;
    copyTo(array: ClrArray, index: int): void;
    get_Item(index: int): Attribute;
    get_Item(attributeType: Type): Attribute;
    getEnumerator(): IEnumerator;
    matches(attribute: Attribute): boolean;
    matches(attributes: Attribute[]): boolean;
}


export const AttributeCollection: {
    new(attributes: Attribute[]): AttributeCollection$instance;
    readonly empty: AttributeCollection;
    fromExisting(existing: AttributeCollection, newAttributes: Attribute[]): AttributeCollection;
};


export interface __AttributeCollection$views {
    As_ICollection(): System_Collections_Internal.ICollection$instance;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
}

export type AttributeCollection = AttributeCollection$instance & __AttributeCollection$views;


export interface AttributeProviderAttribute$instance extends Attribute {
    readonly propertyName: string;
    readonly typeName: string;
}


export const AttributeProviderAttribute: {
    new(typeName: string): AttributeProviderAttribute$instance;
    new(typeName: string, propertyName: string): AttributeProviderAttribute$instance;
    new(type_: Type): AttributeProviderAttribute$instance;
};


export type AttributeProviderAttribute = AttributeProviderAttribute$instance;

export interface BackgroundWorker$instance extends Component$instance {
    readonly cancellationPending: boolean;
    readonly isBusy: boolean;
    workerReportsProgress: boolean;
    workerSupportsCancellation: boolean;
    cancelAsync(): void;
    dispose(): void;
    reportProgress(percentProgress: int): void;
    reportProgress(percentProgress: int, userState: unknown): void;
    runWorkerAsync(): void;
    runWorkerAsync(argument: unknown): void;
}


export const BackgroundWorker: {
    new(): BackgroundWorker$instance;
};


export interface __BackgroundWorker$views {
    As_IComponent(): IComponent$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface BackgroundWorker$instance extends IComponent$instance {}

export type BackgroundWorker = BackgroundWorker$instance & __BackgroundWorker$views;


export interface BaseNumberConverter$instance extends TypeConverter {
    canConvertFrom(context: ITypeDescriptorContext, sourceType: Type): boolean;
    canConvertFrom(sourceType: Type): boolean;
    canConvertTo(context: ITypeDescriptorContext, destinationType: Type): boolean;
    canConvertTo(destinationType: Type): boolean;
    convertFrom(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown): unknown;
    convertFrom(value: unknown): unknown;
    convertTo(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown, destinationType: Type): unknown;
    convertTo(value: unknown, destinationType: Type): unknown;
}


export const BaseNumberConverter: {
};


export type BaseNumberConverter = BaseNumberConverter$instance;

export interface BindableAttribute$instance extends Attribute {
    readonly bindable: boolean;
    readonly direction: BindingDirection;
    equals(obj: unknown): boolean;
    getHashCode(): int;
    isDefaultAttribute(): boolean;
}


export const BindableAttribute: {
    new(bindable: boolean): BindableAttribute$instance;
    new(bindable: boolean, direction: BindingDirection): BindableAttribute$instance;
    new(flags: BindableSupport): BindableAttribute$instance;
    new(flags: BindableSupport, direction: BindingDirection): BindableAttribute$instance;
    readonly yes: BindableAttribute;
    readonly no: BindableAttribute;
    readonly default_: BindableAttribute;
};


export type BindableAttribute = BindableAttribute$instance;

export interface BindingList_1$instance<T> extends Collection_1<T> {
    allowEdit: boolean;
    allowNew: boolean;
    allowRemove: boolean;
    raiseListChangedEvents: boolean;
    add(item: T): void;
    add(value: unknown): int;
    addNew(): T;
    cancelNew(itemIndex: int): void;
    clear(): void;
    contains(item: T): boolean;
    contains(value: unknown): boolean;
    copyTo(array: T[], index: int): void;
    copyTo(array: ClrArray, index: int): void;
    endNew(itemIndex: int): void;
    getEnumerator(): IEnumerator_1<T>;
    getEnumerator(): IEnumerator;
    indexOf(item: T): int;
    insert(index: int, item: T): void;
    insert(index: int, value: unknown): void;
    remove(item: T): boolean;
    remove(value: unknown): void;
    removeAt(index: int): void;
    resetBindings(): void;
    resetItem(position: int): void;
}


export const BindingList_1: {
    new<T>(): BindingList_1$instance<T>;
    new<T>(list: IList_1<T>): BindingList_1$instance<T>;
};


export interface __BindingList_1$views<T> {
    As_IBindingList(): IBindingList$instance;
    As_ICancelAddNew(): ICancelAddNew$instance;
    As_IRaiseItemChangedEvents(): IRaiseItemChangedEvents$instance;
    As_ICollection_1(): System_Collections_Generic_Internal.ICollection_1$instance<T>;
    As_IEnumerable_1(): System_Collections_Generic_Internal.IEnumerable_1$instance<T>;
    As_IList_1(): System_Collections_Generic_Internal.IList_1$instance<T>;
    As_IReadOnlyCollection_1(): System_Collections_Generic_Internal.IReadOnlyCollection_1$instance<T>;
    As_ICollection(): System_Collections_Internal.ICollection$instance;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
    As_IList(): System_Collections_Internal.IList$instance;
}

export interface BindingList_1$instance<T> extends ICancelAddNew$instance, IRaiseItemChangedEvents$instance {}

export type BindingList_1<T> = BindingList_1$instance<T> & __BindingList_1$views<T>;


export interface BooleanConverter$instance extends TypeConverter {
    canConvertFrom(context: ITypeDescriptorContext, sourceType: Type): boolean;
    canConvertFrom(sourceType: Type): boolean;
    convertFrom(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown): unknown;
    convertFrom(value: unknown): unknown;
    getStandardValues(context: ITypeDescriptorContext): TypeConverter_StandardValuesCollection;
    getStandardValues(): ICollection;
    getStandardValuesExclusive(context: ITypeDescriptorContext): boolean;
    getStandardValuesExclusive(): boolean;
    getStandardValuesSupported(context: ITypeDescriptorContext): boolean;
    getStandardValuesSupported(): boolean;
}


export const BooleanConverter: {
    new(): BooleanConverter$instance;
};


export type BooleanConverter = BooleanConverter$instance;

export interface BrowsableAttribute$instance extends Attribute {
    readonly browsable: boolean;
    equals(obj: unknown): boolean;
    getHashCode(): int;
    isDefaultAttribute(): boolean;
}


export const BrowsableAttribute: {
    new(browsable: boolean): BrowsableAttribute$instance;
    readonly yes: BrowsableAttribute;
    readonly no: BrowsableAttribute;
    readonly default_: BrowsableAttribute;
};


export type BrowsableAttribute = BrowsableAttribute$instance;

export interface ByteConverter$instance extends BaseNumberConverter {
}


export const ByteConverter: {
    new(): ByteConverter$instance;
};


export type ByteConverter = ByteConverter$instance;

export interface CancelEventArgs$instance extends EventArgs {
    cancel: boolean;
}


export const CancelEventArgs: {
    new(): CancelEventArgs$instance;
    new(cancel: boolean): CancelEventArgs$instance;
};


export type CancelEventArgs = CancelEventArgs$instance;

export interface CategoryAttribute$instance extends Attribute {
    readonly category: string;
    equals(obj: unknown): boolean;
    getHashCode(): int;
    isDefaultAttribute(): boolean;
}


export const CategoryAttribute: {
    new(): CategoryAttribute$instance;
    new(category: string): CategoryAttribute$instance;
    readonly action: CategoryAttribute;
    readonly appearance: CategoryAttribute;
    readonly asynchronous: CategoryAttribute;
    readonly behavior: CategoryAttribute;
    readonly data: CategoryAttribute;
    readonly default_: CategoryAttribute;
    readonly design: CategoryAttribute;
    readonly dragDrop: CategoryAttribute;
    readonly focus: CategoryAttribute;
    readonly format: CategoryAttribute;
    readonly key: CategoryAttribute;
    readonly layout: CategoryAttribute;
    readonly mouse: CategoryAttribute;
    readonly windowStyle: CategoryAttribute;
};


export type CategoryAttribute = CategoryAttribute$instance;

export interface CharConverter$instance extends TypeConverter {
    canConvertFrom(context: ITypeDescriptorContext, sourceType: Type): boolean;
    canConvertFrom(sourceType: Type): boolean;
    convertFrom(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown): unknown;
    convertFrom(value: unknown): unknown;
    convertTo(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown, destinationType: Type): unknown;
    convertTo(value: unknown, destinationType: Type): unknown;
}


export const CharConverter: {
    new(): CharConverter$instance;
};


export type CharConverter = CharConverter$instance;

export interface CollectionChangeEventArgs$instance extends EventArgs {
    readonly action: CollectionChangeAction;
    readonly element: unknown;
}


export const CollectionChangeEventArgs: {
    new(action: CollectionChangeAction, element: unknown): CollectionChangeEventArgs$instance;
};


export type CollectionChangeEventArgs = CollectionChangeEventArgs$instance;

export interface CollectionConverter$instance extends TypeConverter {
    convertTo(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown, destinationType: Type): unknown;
    convertTo(value: unknown, destinationType: Type): unknown;
    getProperties(context: ITypeDescriptorContext, value: unknown, attributes: Attribute[]): PropertyDescriptorCollection;
    getProperties(value: unknown): PropertyDescriptorCollection;
    getProperties(context: ITypeDescriptorContext, value: unknown): PropertyDescriptorCollection;
}


export const CollectionConverter: {
    new(): CollectionConverter$instance;
};


export type CollectionConverter = CollectionConverter$instance;

export interface ComplexBindingPropertiesAttribute$instance extends Attribute {
    readonly dataMember: string;
    readonly dataSource: string;
    equals(obj: unknown): boolean;
    getHashCode(): int;
}


export const ComplexBindingPropertiesAttribute: {
    new(): ComplexBindingPropertiesAttribute$instance;
    new(dataSource: string): ComplexBindingPropertiesAttribute$instance;
    new(dataSource: string, dataMember: string): ComplexBindingPropertiesAttribute$instance;
    readonly default_: ComplexBindingPropertiesAttribute;
};


export type ComplexBindingPropertiesAttribute = ComplexBindingPropertiesAttribute$instance;

export interface Component$instance extends MarshalByRefObject {
    readonly container: IContainer;
    site: ISite;
    dispose(): void;
    toString(): string;
}


export const Component: {
    new(): Component$instance;
};


export interface __Component$views {
    As_IComponent(): IComponent$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type Component = Component$instance & __Component$views;


export interface ComponentCollection$instance extends ReadOnlyCollectionBase {
    copyTo(array: ClrArray, index: int): void;
    get_Item(name: string): IComponent;
    get_Item(index: int): IComponent;
    getEnumerator(): IEnumerator;
}


export const ComponentCollection: {
    new(components: IComponent[]): ComponentCollection$instance;
};


export interface __ComponentCollection$views {
    As_ICollection(): System_Collections_Internal.ICollection$instance;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
}

export interface ComponentCollection$instance extends System_Collections_Internal.ICollection$instance {}

export type ComponentCollection = ComponentCollection$instance & __ComponentCollection$views;


export interface ComponentConverter$instance extends ReferenceConverter {
    getProperties(context: ITypeDescriptorContext, value: unknown, attributes: Attribute[]): PropertyDescriptorCollection;
    getProperties(value: unknown): PropertyDescriptorCollection;
    getProperties(context: ITypeDescriptorContext, value: unknown): PropertyDescriptorCollection;
    getPropertiesSupported(context: ITypeDescriptorContext): boolean;
    getPropertiesSupported(): boolean;
}


export const ComponentConverter: {
    new(type_: Type): ComponentConverter$instance;
};


export type ComponentConverter = ComponentConverter$instance;

export interface ComponentEditor$instance {
    editComponent(component: unknown): boolean;
    editComponent(context: ITypeDescriptorContext, component: unknown): boolean;
}


export const ComponentEditor: {
};


export type ComponentEditor = ComponentEditor$instance;

export interface ComponentResourceManager$instance extends ResourceManager {
    applyResources(value: unknown, objectName: string): void;
    applyResources(value: unknown, objectName: string, culture: CultureInfo): void;
    applyResourcesToRegisteredType(value: unknown, objectName: string, culture: CultureInfo): void;
}


export const ComponentResourceManager: {
    new(): ComponentResourceManager$instance;
    new(t: Type): ComponentResourceManager$instance;
};


export type ComponentResourceManager = ComponentResourceManager$instance;

export interface Container$instance {
    readonly components: ComponentCollection;
    add(component: IComponent): void;
    add(component: IComponent, name: string): void;
    dispose(): void;
    remove(component: IComponent): void;
}


export const Container: {
    new(): Container$instance;
};


export interface __Container$views {
    As_IContainer(): IContainer$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export type Container = Container$instance & __Container$views;


export interface ContainerFilterService$instance {
    filterComponents(components: ComponentCollection): ComponentCollection;
}


export const ContainerFilterService: {
};


export type ContainerFilterService = ContainerFilterService$instance;

export interface CultureInfoConverter$instance extends TypeConverter {
    canConvertFrom(context: ITypeDescriptorContext, sourceType: Type): boolean;
    canConvertFrom(sourceType: Type): boolean;
    canConvertTo(context: ITypeDescriptorContext, destinationType: Type): boolean;
    canConvertTo(destinationType: Type): boolean;
    convertFrom(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown): unknown;
    convertFrom(value: unknown): unknown;
    convertTo(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown, destinationType: Type): unknown;
    convertTo(value: unknown, destinationType: Type): unknown;
    getStandardValues(context: ITypeDescriptorContext): TypeConverter_StandardValuesCollection;
    getStandardValues(): ICollection;
    getStandardValuesExclusive(context: ITypeDescriptorContext): boolean;
    getStandardValuesExclusive(): boolean;
    getStandardValuesSupported(context: ITypeDescriptorContext): boolean;
    getStandardValuesSupported(): boolean;
}


export const CultureInfoConverter: {
    new(): CultureInfoConverter$instance;
};


export type CultureInfoConverter = CultureInfoConverter$instance;

export interface CustomTypeDescriptor$instance {
    readonly requireRegisteredTypes: Nullable_1<CLROf<boolean>>;
    getAttributes(): AttributeCollection;
    getClassName(): string;
    getComponentName(): string;
    getConverter(): TypeConverter;
    getConverterFromRegisteredType(): TypeConverter;
    getDefaultEvent(): EventDescriptor;
    getDefaultProperty(): PropertyDescriptor;
    getEditor(editorBaseType: Type): unknown;
    getEvents(): EventDescriptorCollection;
    getEvents(attributes: Attribute[]): EventDescriptorCollection;
    getEventsFromRegisteredType(): EventDescriptorCollection;
    getProperties(): PropertyDescriptorCollection;
    getProperties(attributes: Attribute[]): PropertyDescriptorCollection;
    getPropertiesFromRegisteredType(): PropertyDescriptorCollection;
    getPropertyOwner(pd: PropertyDescriptor): unknown;
}


export const CustomTypeDescriptor: {
};


export interface __CustomTypeDescriptor$views {
    As_ICustomTypeDescriptor(): ICustomTypeDescriptor$instance;
}

export interface CustomTypeDescriptor$instance extends ICustomTypeDescriptor$instance {}

export type CustomTypeDescriptor = CustomTypeDescriptor$instance & __CustomTypeDescriptor$views;


export interface DataErrorsChangedEventArgs$instance extends EventArgs {
    readonly propertyName: string;
}


export const DataErrorsChangedEventArgs: {
    new(propertyName: string): DataErrorsChangedEventArgs$instance;
};


export type DataErrorsChangedEventArgs = DataErrorsChangedEventArgs$instance;

export interface DataObjectAttribute$instance extends Attribute {
    readonly isDataObject: boolean;
    equals(obj: unknown): boolean;
    getHashCode(): int;
    isDefaultAttribute(): boolean;
}


export const DataObjectAttribute: {
    new(): DataObjectAttribute$instance;
    new(isDataObject: boolean): DataObjectAttribute$instance;
    readonly dataObject: DataObjectAttribute;
    readonly nonDataObject: DataObjectAttribute;
    readonly default_: DataObjectAttribute;
};


export type DataObjectAttribute = DataObjectAttribute$instance;

export interface DataObjectFieldAttribute$instance extends Attribute {
    readonly isIdentity: boolean;
    readonly isNullable: boolean;
    readonly length: int;
    readonly primaryKey: boolean;
    equals(obj: unknown): boolean;
    getHashCode(): int;
}


export const DataObjectFieldAttribute: {
    new(primaryKey: boolean): DataObjectFieldAttribute$instance;
    new(primaryKey: boolean, isIdentity: boolean): DataObjectFieldAttribute$instance;
    new(primaryKey: boolean, isIdentity: boolean, isNullable: boolean): DataObjectFieldAttribute$instance;
    new(primaryKey: boolean, isIdentity: boolean, isNullable: boolean, length: int): DataObjectFieldAttribute$instance;
};


export type DataObjectFieldAttribute = DataObjectFieldAttribute$instance;

export interface DataObjectMethodAttribute$instance extends Attribute {
    readonly isDefault: boolean;
    readonly methodType: DataObjectMethodType;
    equals(obj: unknown): boolean;
    getHashCode(): int;
    match(obj: unknown): boolean;
}


export const DataObjectMethodAttribute: {
    new(methodType: DataObjectMethodType): DataObjectMethodAttribute$instance;
    new(methodType: DataObjectMethodType, isDefault: boolean): DataObjectMethodAttribute$instance;
};


export type DataObjectMethodAttribute = DataObjectMethodAttribute$instance;

export interface DateOnlyConverter$instance extends TypeConverter {
    canConvertFrom(context: ITypeDescriptorContext, sourceType: Type): boolean;
    canConvertFrom(sourceType: Type): boolean;
    canConvertTo(context: ITypeDescriptorContext, destinationType: Type): boolean;
    canConvertTo(destinationType: Type): boolean;
    convertFrom(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown): unknown;
    convertFrom(value: unknown): unknown;
    convertTo(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown, destinationType: Type): unknown;
    convertTo(value: unknown, destinationType: Type): unknown;
}


export const DateOnlyConverter: {
    new(): DateOnlyConverter$instance;
};


export type DateOnlyConverter = DateOnlyConverter$instance;

export interface DateTimeConverter$instance extends TypeConverter {
    canConvertFrom(context: ITypeDescriptorContext, sourceType: Type): boolean;
    canConvertFrom(sourceType: Type): boolean;
    canConvertTo(context: ITypeDescriptorContext, destinationType: Type): boolean;
    canConvertTo(destinationType: Type): boolean;
    convertFrom(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown): unknown;
    convertFrom(value: unknown): unknown;
    convertTo(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown, destinationType: Type): unknown;
    convertTo(value: unknown, destinationType: Type): unknown;
}


export const DateTimeConverter: {
    new(): DateTimeConverter$instance;
};


export type DateTimeConverter = DateTimeConverter$instance;

export interface DateTimeOffsetConverter$instance extends TypeConverter {
    canConvertFrom(context: ITypeDescriptorContext, sourceType: Type): boolean;
    canConvertFrom(sourceType: Type): boolean;
    canConvertTo(context: ITypeDescriptorContext, destinationType: Type): boolean;
    canConvertTo(destinationType: Type): boolean;
    convertFrom(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown): unknown;
    convertFrom(value: unknown): unknown;
    convertTo(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown, destinationType: Type): unknown;
    convertTo(value: unknown, destinationType: Type): unknown;
}


export const DateTimeOffsetConverter: {
    new(): DateTimeOffsetConverter$instance;
};


export type DateTimeOffsetConverter = DateTimeOffsetConverter$instance;

export interface DecimalConverter$instance extends BaseNumberConverter {
    canConvertTo(context: ITypeDescriptorContext, destinationType: Type): boolean;
    canConvertTo(destinationType: Type): boolean;
    convertTo(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown, destinationType: Type): unknown;
    convertTo(value: unknown, destinationType: Type): unknown;
}


export const DecimalConverter: {
    new(): DecimalConverter$instance;
};


export type DecimalConverter = DecimalConverter$instance;

export interface DefaultBindingPropertyAttribute$instance extends Attribute {
    readonly name: string;
    equals(obj: unknown): boolean;
    getHashCode(): int;
}


export const DefaultBindingPropertyAttribute: {
    new(): DefaultBindingPropertyAttribute$instance;
    new(name: string): DefaultBindingPropertyAttribute$instance;
    readonly default_: DefaultBindingPropertyAttribute;
};


export type DefaultBindingPropertyAttribute = DefaultBindingPropertyAttribute$instance;

export interface DefaultEventAttribute$instance extends Attribute {
    readonly name: string;
    equals(obj: unknown): boolean;
    getHashCode(): int;
}


export const DefaultEventAttribute: {
    new(name: string): DefaultEventAttribute$instance;
    readonly default_: DefaultEventAttribute;
};


export type DefaultEventAttribute = DefaultEventAttribute$instance;

export interface DefaultPropertyAttribute$instance extends Attribute {
    readonly name: string;
    equals(obj: unknown): boolean;
    getHashCode(): int;
}


export const DefaultPropertyAttribute: {
    new(name: string): DefaultPropertyAttribute$instance;
    readonly default_: DefaultPropertyAttribute;
};


export type DefaultPropertyAttribute = DefaultPropertyAttribute$instance;

export interface DefaultValueAttribute$instance extends Attribute {
    readonly value: unknown;
    equals(obj: unknown): boolean;
    getHashCode(): int;
}


export const DefaultValueAttribute: {
    new(type_: Type, value: string): DefaultValueAttribute$instance;
    new(value: char): DefaultValueAttribute$instance;
    new(value: byte): DefaultValueAttribute$instance;
    new(value: short): DefaultValueAttribute$instance;
    new(value: int): DefaultValueAttribute$instance;
    new(value: long): DefaultValueAttribute$instance;
    new(value: float): DefaultValueAttribute$instance;
    new(value: double): DefaultValueAttribute$instance;
    new(value: boolean): DefaultValueAttribute$instance;
    new(value: string): DefaultValueAttribute$instance;
    new(value: unknown): DefaultValueAttribute$instance;
    new(value: sbyte): DefaultValueAttribute$instance;
    new(value: ushort): DefaultValueAttribute$instance;
    new(value: uint): DefaultValueAttribute$instance;
    new(value: ulong): DefaultValueAttribute$instance;
};


export type DefaultValueAttribute = DefaultValueAttribute$instance;

export interface DescriptionAttribute$instance extends Attribute {
    readonly description: string;
    equals(obj: unknown): boolean;
    getHashCode(): int;
    isDefaultAttribute(): boolean;
}


export const DescriptionAttribute: {
    new(): DescriptionAttribute$instance;
    new(description: string): DescriptionAttribute$instance;
    readonly default_: DescriptionAttribute;
};


export type DescriptionAttribute = DescriptionAttribute$instance;

export interface DesignerAttribute$instance extends Attribute {
    readonly designerBaseTypeName: string;
    readonly designerTypeName: string;
    readonly typeId: unknown;
    equals(obj: unknown): boolean;
    getHashCode(): int;
}


export const DesignerAttribute: {
    new(designerTypeName: string): DesignerAttribute$instance;
    new(designerType: Type): DesignerAttribute$instance;
    new(designerTypeName: string, designerBaseTypeName: string): DesignerAttribute$instance;
    new(designerTypeName: string, designerBaseType: Type): DesignerAttribute$instance;
    new(designerType: Type, designerBaseType: Type): DesignerAttribute$instance;
};


export type DesignerAttribute = DesignerAttribute$instance;

export interface DesignerCategoryAttribute$instance extends Attribute {
    readonly category: string;
    readonly typeId: unknown;
    equals(obj: unknown): boolean;
    getHashCode(): int;
    isDefaultAttribute(): boolean;
}


export const DesignerCategoryAttribute: {
    new(): DesignerCategoryAttribute$instance;
    new(category: string): DesignerCategoryAttribute$instance;
    readonly component: DesignerCategoryAttribute;
    readonly default_: DesignerCategoryAttribute;
    readonly form: DesignerCategoryAttribute;
    readonly generic: DesignerCategoryAttribute;
};


export type DesignerCategoryAttribute = DesignerCategoryAttribute$instance;

export interface DesignerSerializationVisibilityAttribute$instance extends Attribute {
    readonly visibility: DesignerSerializationVisibility;
    equals(obj: unknown): boolean;
    getHashCode(): int;
    isDefaultAttribute(): boolean;
}


export const DesignerSerializationVisibilityAttribute: {
    new(visibility: DesignerSerializationVisibility): DesignerSerializationVisibilityAttribute$instance;
    readonly content: DesignerSerializationVisibilityAttribute;
    readonly hidden: DesignerSerializationVisibilityAttribute;
    readonly visible: DesignerSerializationVisibilityAttribute;
    readonly default_: DesignerSerializationVisibilityAttribute;
};


export type DesignerSerializationVisibilityAttribute = DesignerSerializationVisibilityAttribute$instance;

export interface DesignOnlyAttribute$instance extends Attribute {
    readonly isDesignOnly: boolean;
    equals(obj: unknown): boolean;
    getHashCode(): int;
    isDefaultAttribute(): boolean;
}


export const DesignOnlyAttribute: {
    new(isDesignOnly: boolean): DesignOnlyAttribute$instance;
    readonly yes: DesignOnlyAttribute;
    readonly no: DesignOnlyAttribute;
    readonly default_: DesignOnlyAttribute;
};


export type DesignOnlyAttribute = DesignOnlyAttribute$instance;

export interface DesignTimeVisibleAttribute$instance extends Attribute {
    readonly visible: boolean;
    equals(obj: unknown): boolean;
    getHashCode(): int;
    isDefaultAttribute(): boolean;
}


export const DesignTimeVisibleAttribute: {
    new(visible: boolean): DesignTimeVisibleAttribute$instance;
    new(): DesignTimeVisibleAttribute$instance;
    readonly yes: DesignTimeVisibleAttribute;
    readonly no: DesignTimeVisibleAttribute;
    readonly default_: DesignTimeVisibleAttribute;
};


export type DesignTimeVisibleAttribute = DesignTimeVisibleAttribute$instance;

export interface DisplayNameAttribute$instance extends Attribute {
    readonly displayName: string;
    equals(obj: unknown): boolean;
    getHashCode(): int;
    isDefaultAttribute(): boolean;
}


export const DisplayNameAttribute: {
    new(): DisplayNameAttribute$instance;
    new(displayName: string): DisplayNameAttribute$instance;
    readonly default_: DisplayNameAttribute;
};


export type DisplayNameAttribute = DisplayNameAttribute$instance;

export interface DoubleConverter$instance extends BaseNumberConverter {
}


export const DoubleConverter: {
    new(): DoubleConverter$instance;
};


export type DoubleConverter = DoubleConverter$instance;

export interface DoWorkEventArgs$instance extends CancelEventArgs {
    readonly argument: unknown;
    result: unknown;
}


export const DoWorkEventArgs: {
    new(argument: unknown): DoWorkEventArgs$instance;
};


export type DoWorkEventArgs = DoWorkEventArgs$instance;

export interface EditorAttribute$instance extends Attribute {
    readonly editorBaseTypeName: string;
    readonly editorTypeName: string;
    readonly typeId: unknown;
    equals(obj: unknown): boolean;
    getHashCode(): int;
}


export const EditorAttribute: {
    new(): EditorAttribute$instance;
    new(typeName: string, baseTypeName: string): EditorAttribute$instance;
    new(typeName: string, baseType: Type): EditorAttribute$instance;
    new(type_: Type, baseType: Type): EditorAttribute$instance;
};


export type EditorAttribute = EditorAttribute$instance;

export interface EditorBrowsableAttribute$instance extends Attribute {
    readonly state: EditorBrowsableState;
    equals(obj: unknown): boolean;
    getHashCode(): int;
}


export const EditorBrowsableAttribute: {
    new(state: EditorBrowsableState): EditorBrowsableAttribute$instance;
    new(): EditorBrowsableAttribute$instance;
};


export type EditorBrowsableAttribute = EditorBrowsableAttribute$instance;

export interface EnumConverter$instance extends TypeConverter {
    canConvertFrom(context: ITypeDescriptorContext, sourceType: Type): boolean;
    canConvertFrom(sourceType: Type): boolean;
    canConvertTo(context: ITypeDescriptorContext, destinationType: Type): boolean;
    canConvertTo(destinationType: Type): boolean;
    convertFrom(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown): unknown;
    convertFrom(value: unknown): unknown;
    convertTo(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown, destinationType: Type): unknown;
    convertTo(value: unknown, destinationType: Type): unknown;
    getStandardValues(context: ITypeDescriptorContext): TypeConverter_StandardValuesCollection;
    getStandardValues(): ICollection;
    getStandardValuesExclusive(context: ITypeDescriptorContext): boolean;
    getStandardValuesExclusive(): boolean;
    getStandardValuesSupported(context: ITypeDescriptorContext): boolean;