@tsonic/dotnet-pure/System.ComponentModel.Design/internal/index.d.ts

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

// Generated by tsbindgen - Architecture
// Namespace: System.ComponentModel.Design
// Assembly: System.ComponentModel.TypeConverter

// 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 types from other namespaces
import * as System_Collections_Internal from "../../System.Collections/internal/index.js";
import type { CollectionBase, ICollection, IDictionary, IEnumerable, IEnumerator, IList } from "../../System.Collections/internal/index.js";
import * as System_ComponentModel_Internal from "../../System.ComponentModel/internal/index.js";
import type { EventDescriptor, EventDescriptorCollection, IComponent, IContainer, IExtenderProvider, InheritanceAttribute, LicenseContext, LicenseUsageMode, MemberDescriptor, PropertyDescriptor, PropertyDescriptorCollection, TypeDescriptionProvider } from "../../System.ComponentModel/internal/index.js";
import type { CultureInfo } from "../../System.Globalization/internal/index.js";
import type { Stream } from "../../System.IO/internal/index.js";
import type { Assembly, AssemblyName, MethodBase, MethodInfo } from "../../System.Reflection/internal/index.js";
import type { IResourceReader, IResourceWriter } 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 * as System_Internal from "../../System/internal/index.js";
import type { Array as ClrArray, AsyncCallback, Attribute, Boolean as ClrBoolean, Delegate, Enum, EventArgs, EventHandler, Exception, Guid, IAsyncResult, ICloneable, IComparable, IConvertible, IDisposable, IFormatProvider, IFormattable, Int32, IntPtr, IServiceProvider, ISpanFormattable, MulticastDelegate, Object as ClrObject, String as ClrString, Type, TypeCode, 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 HelpContextType {
    Ambient = 0,
    Window = 1,
    Selection = 2,
    ToolWindowSelection = 3
}


export enum HelpKeywordType {
    F1Keyword = 0,
    GeneralKeyword = 1,
    FilterKeyword = 2
}


export enum SelectionTypes {
    Auto = 1,
    Normal = 1,
    Replace = 2,
    MouseDown = 4,
    MouseUp = 8,
    Click = 16,
    Primary = 16,
    Toggle = 32,
    Add = 64,
    Remove = 128,
    Valid = 31
}


export enum ViewTechnology {
    Passthrough = 0,
    WindowsForms = 1,
    Default = 2
}


export type ActiveDesignerEventHandler = (sender: unknown, e: ActiveDesignerEventArgs) => void;


export type ComponentChangedEventHandler = (sender: unknown, e: ComponentChangedEventArgs) => void;


export type ComponentChangingEventHandler = (sender: unknown, e: ComponentChangingEventArgs) => void;


export type ComponentEventHandler = (sender: unknown, e: ComponentEventArgs) => void;


export type ComponentRenameEventHandler = (sender: unknown, e: ComponentRenameEventArgs) => void;


export type DesignerEventHandler = (sender: unknown, e: DesignerEventArgs) => void;


export type DesignerTransactionCloseEventHandler = (sender: unknown, e: DesignerTransactionCloseEventArgs) => void;


export type ServiceCreatorCallback = (container: IServiceContainer, serviceType: Type) => unknown;


export interface IComponentChangeService$instance {
    OnComponentChanged(component: unknown, member: MemberDescriptor, oldValue: unknown, newValue: unknown): void;
    OnComponentChanging(component: unknown, member: MemberDescriptor): void;
}


export type IComponentChangeService = IComponentChangeService$instance;

export interface IComponentDiscoveryService$instance {
    GetComponentTypes(designerHost: IDesignerHost, baseType: Type): ICollection;
}


export type IComponentDiscoveryService = IComponentDiscoveryService$instance;

export interface IComponentInitializer$instance {
    InitializeExistingComponent(defaultValues: IDictionary): void;
}


export type IComponentInitializer = IComponentInitializer$instance;

export interface IDesigner$instance extends IDisposable {
    readonly Component: IComponent;
    readonly Verbs: DesignerVerbCollection;
    DoDefaultAction(): void;
    Initialize(component: IComponent): void;
}


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

export type IDesigner = IDesigner$instance;

export interface IDesignerEventService$instance {
    readonly ActiveDesigner: IDesignerHost;
    readonly Designers: DesignerCollection;
}


export type IDesignerEventService = IDesignerEventService$instance;

export interface IDesignerFilter$instance {
    PostFilterAttributes(attributes: IDictionary): void;
}


export type IDesignerFilter = IDesignerFilter$instance;

export interface IDesignerHost$instance extends IServiceContainer, IServiceProvider {
    readonly Loading: boolean;
    readonly InTransaction: boolean;
    readonly Container: IContainer;
    readonly RootComponent: IComponent;
    readonly RootComponentClassName: string;
    readonly TransactionDescription: string;
    Activate(): void;
    AddService(serviceType: Type, callback: ServiceCreatorCallback, promote: boolean): void;
    AddService(serviceType: Type, callback: ServiceCreatorCallback): void;
    AddService(serviceType: Type, serviceInstance: unknown, promote: boolean): void;
    AddService(serviceType: Type, serviceInstance: unknown): void;
    CreateComponent(componentClass: Type, name: string): IComponent;
    CreateComponent(componentClass: Type): IComponent;
    CreateTransaction(): DesignerTransaction;
    CreateTransaction(description: string): DesignerTransaction;
    DestroyComponent(component: IComponent): void;
    GetDesigner(component: IComponent): IDesigner;
    GetService(serviceType: Type): unknown;
    GetType(typeName: string): Type;
    RemoveService(serviceType: Type, promote: boolean): void;
    RemoveService(serviceType: Type): void;
}


export type IDesignerHost = IDesignerHost$instance;

export interface IDesignerHostTransactionState$instance {
    readonly IsClosingTransaction: boolean;
}


export type IDesignerHostTransactionState = IDesignerHostTransactionState$instance;

export interface IDesignerOptionService$instance {
    GetOptionValue(pageName: string, valueName: string): unknown;
    SetOptionValue(pageName: string, valueName: string, value: unknown): void;
}


export type IDesignerOptionService = IDesignerOptionService$instance;

export interface IDictionaryService$instance {
    GetKey(value: unknown): unknown;
    SetValue(key: unknown, value: unknown): void;
}


export type IDictionaryService = IDictionaryService$instance;

export interface IEventBindingService$instance {
    CreateUniqueMethodName(component: IComponent, e: EventDescriptor): string;
    GetCompatibleMethods(e: EventDescriptor): ICollection;
    GetEvent(property: PropertyDescriptor): EventDescriptor;
    GetEventProperties(events: EventDescriptorCollection): PropertyDescriptorCollection;
    GetEventProperty(e: EventDescriptor): PropertyDescriptor;
    ShowCode(): boolean;
    ShowCode(component: IComponent, e: EventDescriptor): boolean;
    ShowCode(lineNumber: int): boolean;
}


export type IEventBindingService = IEventBindingService$instance;

export interface IExtenderListService$instance {
    GetExtenderProviders(): IExtenderProvider[];
}


export type IExtenderListService = IExtenderListService$instance;

export interface IExtenderProviderService$instance {
    AddExtenderProvider(provider: IExtenderProvider): void;
}


export type IExtenderProviderService = IExtenderProviderService$instance;

export interface IHelpService$instance {
    AddContextAttribute(name: string, value: string, keywordType: HelpKeywordType): void;
    ClearContextAttributes(): void;
    CreateLocalContext(contextType: HelpContextType): IHelpService;
    RemoveContextAttribute(name: string, value: string): void;
    RemoveLocalContext(localContext: IHelpService): void;
    ShowHelpFromKeyword(helpKeyword: string): void;
}


export type IHelpService = IHelpService$instance;

export interface IInheritanceService$instance {
    AddInheritedComponents(component: IComponent, container: IContainer): void;
    GetInheritanceAttribute(component: IComponent): InheritanceAttribute;
}


export type IInheritanceService = IInheritanceService$instance;

export interface IMenuCommandService$instance {
    readonly Verbs: DesignerVerbCollection;
    AddCommand(command: MenuCommand): void;
    AddVerb(verb: DesignerVerb): void;
    FindCommand(commandID: CommandID): MenuCommand;
    GlobalInvoke(commandID: CommandID): boolean;
    ShowContextMenu(menuID: CommandID, x: int, y: int): void;
}


export type IMenuCommandService = IMenuCommandService$instance;

export interface IReferenceService$instance {
    GetComponent(reference: unknown): IComponent;
    GetName(reference: unknown): string;
    GetReference(name: string): unknown;
    GetReferences(): unknown[];
    GetReferences(baseType: Type): unknown[];
}


export type IReferenceService = IReferenceService$instance;

export interface IResourceService$instance {
    GetResourceReader(info: CultureInfo): IResourceReader;
    GetResourceWriter(info: CultureInfo): IResourceWriter;
}


export type IResourceService = IResourceService$instance;

export interface IRootDesigner$instance extends IDesigner, IDisposable {
    readonly SupportedTechnologies: ViewTechnology[];
    readonly Component: IComponent;
    readonly Verbs: DesignerVerbCollection;
    DoDefaultAction(): void;
    GetView(technology: ViewTechnology): unknown;
    Initialize(component: IComponent): void;
}


export interface IRootDesigner$instance extends IDesigner$instance {}

export type IRootDesigner = IRootDesigner$instance;

export interface ISelectionService$instance {
    readonly PrimarySelection: unknown;
    readonly SelectionCount: int;
    GetComponentSelected(component: unknown): boolean;
    GetSelectedComponents(): ICollection;
    SetSelectedComponents(components: ICollection, selectionType: SelectionTypes): void;
    SetSelectedComponents(components: ICollection): void;
}


export type ISelectionService = ISelectionService$instance;

export interface IServiceContainer$instance extends IServiceProvider {
    AddService(serviceType: Type, callback: ServiceCreatorCallback, promote: boolean): void;
    AddService(serviceType: Type, callback: ServiceCreatorCallback): void;
    AddService(serviceType: Type, serviceInstance: unknown, promote: boolean): void;
    AddService(serviceType: Type, serviceInstance: unknown): void;
    GetService(serviceType: Type): unknown;
    RemoveService(serviceType: Type, promote: boolean): void;
    RemoveService(serviceType: Type): void;
}


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

export type IServiceContainer = IServiceContainer$instance;

export interface ITreeDesigner$instance extends IDesigner, IDisposable {
    readonly Children: ICollection;
    readonly Parent: IDesigner;
    readonly Component: IComponent;
    readonly Verbs: DesignerVerbCollection;
    DoDefaultAction(): void;
    Initialize(component: IComponent): void;
}


export interface ITreeDesigner$instance extends IDesigner$instance {}

export type ITreeDesigner = ITreeDesigner$instance;

export interface ITypeDescriptorFilterService$instance {
    FilterAttributes(component: IComponent, attributes: IDictionary): boolean;
}


export type ITypeDescriptorFilterService = ITypeDescriptorFilterService$instance;

export interface ITypeDiscoveryService$instance {
    GetTypes(baseType: Type, excludeGlobalTypes: boolean): ICollection;
}


export type ITypeDiscoveryService = ITypeDiscoveryService$instance;

export interface ITypeResolutionService$instance {
    GetAssembly(name: AssemblyName, throwOnError: boolean): Assembly;
    GetAssembly(name: AssemblyName): Assembly;
    GetPathOfAssembly(name: AssemblyName): string;
    GetType(name: string, throwOnError: boolean, ignoreCase: boolean): Type;
    GetType(name: string, throwOnError: boolean): Type;
    GetType(name: string): Type;
    ReferenceAssembly(name: AssemblyName): void;
}


export type ITypeResolutionService = ITypeResolutionService$instance;

export interface ActiveDesignerEventArgs$instance extends EventArgs {
    readonly NewDesigner: IDesignerHost;
    readonly OldDesigner: IDesignerHost;
}


export const ActiveDesignerEventArgs: {
    new(oldDesigner: IDesignerHost, newDesigner: IDesignerHost): ActiveDesignerEventArgs$instance;
};


export type ActiveDesignerEventArgs = ActiveDesignerEventArgs$instance;

export interface CheckoutException$instance extends ExternalException {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const CheckoutException: {
    new(): CheckoutException$instance;
    new(message: string): CheckoutException$instance;
    new(message: string, errorCode: int): CheckoutException$instance;
    new(message: string, innerException: Exception): CheckoutException$instance;
    readonly Canceled: CheckoutException;
};


export interface __CheckoutException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type CheckoutException = CheckoutException$instance & __CheckoutException$views;


export interface CommandID$instance {
    readonly Guid: Guid;
    readonly ID: int;
    Equals(obj: unknown): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const CommandID: {
    new(menuGroup: Guid, commandID: int): CommandID$instance;
};


export type CommandID = CommandID$instance;

export interface ComponentChangedEventArgs$instance extends EventArgs {
    readonly Component: unknown;
    readonly Member: MemberDescriptor;
    readonly NewValue: unknown;
    readonly OldValue: unknown;
}


export const ComponentChangedEventArgs: {
    new(component: unknown, member: MemberDescriptor, oldValue: unknown, newValue: unknown): ComponentChangedEventArgs$instance;
};


export type ComponentChangedEventArgs = ComponentChangedEventArgs$instance;

export interface ComponentChangingEventArgs$instance extends EventArgs {
    readonly Component: unknown;
    readonly Member: MemberDescriptor;
}


export const ComponentChangingEventArgs: {
    new(component: unknown, member: MemberDescriptor): ComponentChangingEventArgs$instance;
};


export type ComponentChangingEventArgs = ComponentChangingEventArgs$instance;

export interface ComponentEventArgs$instance extends EventArgs {
    readonly Component: IComponent;
}


export const ComponentEventArgs: {
    new(component: IComponent): ComponentEventArgs$instance;
};


export type ComponentEventArgs = ComponentEventArgs$instance;

export interface ComponentRenameEventArgs$instance extends EventArgs {
    readonly Component: unknown;
    readonly NewName: string;
    readonly OldName: string;
}


export const ComponentRenameEventArgs: {
    new(component: unknown, oldName: string, newName: string): ComponentRenameEventArgs$instance;
};


export type ComponentRenameEventArgs = ComponentRenameEventArgs$instance;

export interface DesignerCollection$instance {
    readonly Count: int;
    readonly Item: IDesignerHost;
    GetEnumerator(): IEnumerator;
}


export const DesignerCollection: {
    new(designers: IDesignerHost[]): DesignerCollection$instance;
    new(designers: IList): DesignerCollection$instance;
};


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

export type DesignerCollection = DesignerCollection$instance & __DesignerCollection$views;


export interface DesignerEventArgs$instance extends EventArgs {
    readonly Designer: IDesignerHost;
}


export const DesignerEventArgs: {
    new(host: IDesignerHost): DesignerEventArgs$instance;
};


export type DesignerEventArgs = DesignerEventArgs$instance;

export interface DesignerOptionService$instance {
    readonly Options: DesignerOptionService_DesignerOptionCollection;
}


export const DesignerOptionService: {
};


export interface __DesignerOptionService$views {
    As_IDesignerOptionService(): IDesignerOptionService$instance;
}

export interface DesignerOptionService$instance extends IDesignerOptionService$instance {}

export type DesignerOptionService = DesignerOptionService$instance & __DesignerOptionService$views;


export interface DesignerOptionService_DesignerOptionCollection$instance {
    readonly Count: int;
    readonly Name: string;
    readonly Parent: DesignerOptionService_DesignerOptionCollection;
    readonly Properties: PropertyDescriptorCollection;
    CopyTo(array: ClrArray, index: int): void;
    get_Item(index: int): DesignerOptionService_DesignerOptionCollection;
    get_Item(name: string): DesignerOptionService_DesignerOptionCollection;
    GetEnumerator(): IEnumerator;
    IndexOf(value: DesignerOptionService_DesignerOptionCollection): int;
    ShowDialog(): boolean;
}


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


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

export type DesignerOptionService_DesignerOptionCollection = DesignerOptionService_DesignerOptionCollection$instance & __DesignerOptionService_DesignerOptionCollection$views;


export interface DesignerTransaction$instance {
    readonly Canceled: boolean;
    readonly Committed: boolean;
    readonly Description: string;
    Cancel(): void;
    Commit(): void;
}


export const DesignerTransaction: {
};


export interface __DesignerTransaction$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

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

export type DesignerTransaction = DesignerTransaction$instance & __DesignerTransaction$views;


export interface DesignerTransactionCloseEventArgs$instance extends EventArgs {
    readonly LastTransaction: boolean;
    readonly TransactionCommitted: boolean;
}


export const DesignerTransactionCloseEventArgs: {
    new(commit: boolean): DesignerTransactionCloseEventArgs$instance;
    new(commit: boolean, lastTransaction: boolean): DesignerTransactionCloseEventArgs$instance;
};


export type DesignerTransactionCloseEventArgs = DesignerTransactionCloseEventArgs$instance;

export interface DesignerVerb$instance extends MenuCommand {
    Description: string;
    readonly Text: string;
    ToString(): string;
}


export const DesignerVerb: {
    new(text: string, handler: EventHandler): DesignerVerb$instance;
    new(text: string, handler: EventHandler, startCommandID: CommandID): DesignerVerb$instance;
};


export type DesignerVerb = DesignerVerb$instance;

export interface DesignerVerbCollection$instance extends CollectionBase {
    Item: DesignerVerb;
    Add(value: unknown): int;
    AddRange(value: DesignerVerb[]): void;
    AddRange(value: DesignerVerbCollection): void;
    Clear(): void;
    Contains(value: unknown): boolean;
    CopyTo(array: ClrArray, index: int): void;
    GetEnumerator(): IEnumerator;
    IndexOf(value: DesignerVerb): int;
    Insert(index: int, value: unknown): void;
    Remove(value: unknown): void;
    RemoveAt(index: int): void;
}


export const DesignerVerbCollection: {
    new(): DesignerVerbCollection$instance;
    new(value: DesignerVerb[]): DesignerVerbCollection$instance;
};


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

export type DesignerVerbCollection = DesignerVerbCollection$instance & __DesignerVerbCollection$views;


export interface DesigntimeLicenseContext$instance extends LicenseContext {
    readonly UsageMode: LicenseUsageMode;
    GetSavedLicenseKey(type_: Type, resourceAssembly: Assembly): string;
    GetService(type_: Type): unknown;
    SetSavedLicenseKey(type_: Type, key: string): void;
}


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


export interface __DesigntimeLicenseContext$views {
    As_IServiceProvider(): System_Internal.IServiceProvider$instance;
}

export type DesigntimeLicenseContext = DesigntimeLicenseContext$instance & __DesigntimeLicenseContext$views;


export interface DesigntimeLicenseContextSerializer$instance {
}


export const DesigntimeLicenseContextSerializer: {
    new(): DesigntimeLicenseContextSerializer$instance;
    Serialize(o: Stream, cryptoKey: string, context: DesigntimeLicenseContext): void;
};


export type DesigntimeLicenseContextSerializer = DesigntimeLicenseContextSerializer$instance;

export interface HelpKeywordAttribute$instance extends Attribute {
    readonly HelpKeyword: string;
    Equals(obj: unknown): boolean;
    GetHashCode(): int;
    IsDefaultAttribute(): boolean;
}


export const HelpKeywordAttribute: {
    new(): HelpKeywordAttribute$instance;
    new(keyword: string): HelpKeywordAttribute$instance;
    new(t: Type): HelpKeywordAttribute$instance;
    readonly Default: HelpKeywordAttribute;
};


export type HelpKeywordAttribute = HelpKeywordAttribute$instance;

export interface MenuCommand$instance {
    Checked: boolean;
    readonly CommandID: CommandID;
    Enabled: boolean;
    readonly OleStatus: int;
    readonly Properties: IDictionary;
    Supported: boolean;
    Visible: boolean;
    Invoke(): void;
    Invoke(arg: unknown): void;
    ToString(): string;
}


export const MenuCommand: {
    new(handler: EventHandler, command: CommandID): MenuCommand$instance;
};


export type MenuCommand = MenuCommand$instance;

export interface ServiceContainer$instance {
    AddService(serviceType: Type, serviceInstance: unknown): void;
    AddService(serviceType: Type, serviceInstance: unknown, promote: boolean): void;
    AddService(serviceType: Type, callback: ServiceCreatorCallback): void;
    AddService(serviceType: Type, callback: ServiceCreatorCallback, promote: boolean): void;
    Dispose(): void;
    GetService(serviceType: Type): unknown;
    RemoveService(serviceType: Type): void;
    RemoveService(serviceType: Type, promote: boolean): void;
}


export const ServiceContainer: {
    new(): ServiceContainer$instance;
    new(parentProvider: IServiceProvider): ServiceContainer$instance;
};


export interface __ServiceContainer$views {
    As_IServiceProvider(): System_Internal.IServiceProvider$instance;
    As_IServiceContainer(): IServiceContainer$instance;
    As_IDisposable(): System_Internal.IDisposable$instance;
}

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

export type ServiceContainer = ServiceContainer$instance & __ServiceContainer$views;


export interface StandardCommands$instance {
}


export const StandardCommands: {
    new(): StandardCommands$instance;
    readonly AlignBottom: CommandID;
    readonly AlignHorizontalCenters: CommandID;
    readonly AlignLeft: CommandID;
    readonly AlignRight: CommandID;
    readonly AlignToGrid: CommandID;
    readonly AlignTop: CommandID;
    readonly AlignVerticalCenters: CommandID;
    readonly ArrangeBottom: CommandID;
    readonly ArrangeRight: CommandID;
    readonly BringForward: CommandID;
    readonly BringToFront: CommandID;
    readonly CenterHorizontally: CommandID;
    readonly CenterVertically: CommandID;
    readonly ViewCode: CommandID;
    readonly DocumentOutline: CommandID;
    readonly Copy: CommandID;
    readonly Cut: CommandID;
    readonly Delete: CommandID;
    readonly Group: CommandID;
    readonly HorizSpaceConcatenate: CommandID;
    readonly HorizSpaceDecrease: CommandID;
    readonly HorizSpaceIncrease: CommandID;
    readonly HorizSpaceMakeEqual: CommandID;
    readonly Paste: CommandID;
    readonly Properties: CommandID;
    readonly Redo: CommandID;
    readonly MultiLevelRedo: CommandID;
    readonly SelectAll: CommandID;
    readonly SendBackward: CommandID;
    readonly SendToBack: CommandID;
    readonly SizeToControl: CommandID;
    readonly SizeToControlHeight: CommandID;
    readonly SizeToControlWidth: CommandID;
    readonly SizeToFit: CommandID;
    readonly SizeToGrid: CommandID;
    readonly SnapToGrid: CommandID;
    readonly TabOrder: CommandID;
    readonly Undo: CommandID;
    readonly MultiLevelUndo: CommandID;
    readonly Ungroup: CommandID;
    readonly VertSpaceConcatenate: CommandID;
    readonly VertSpaceDecrease: CommandID;
    readonly VertSpaceIncrease: CommandID;
    readonly VertSpaceMakeEqual: CommandID;
    readonly ShowGrid: CommandID;
    readonly ViewGrid: CommandID;
    readonly Replace: CommandID;
    readonly PropertiesWindow: CommandID;
    readonly LockControls: CommandID;
    readonly F1Help: CommandID;
    readonly ArrangeIcons: CommandID;
    readonly LineupIcons: CommandID;
    readonly ShowLargeIcons: CommandID;
    readonly VerbFirst: CommandID;
    readonly VerbLast: CommandID;
};


export type StandardCommands = StandardCommands$instance;

export interface StandardToolWindows$instance {
}


export const StandardToolWindows: {
    new(): StandardToolWindows$instance;
    readonly ObjectBrowser: Guid;
    readonly OutputWindow: Guid;
    readonly ProjectExplorer: Guid;
    readonly PropertyBrowser: Guid;
    readonly RelatedLinks: Guid;
    readonly ServerExplorer: Guid;
    readonly TaskList: Guid;
    readonly Toolbox: Guid;
};


export type StandardToolWindows = StandardToolWindows$instance;

export interface TypeDescriptionProviderService$instance {
    GetProvider(instance: unknown): TypeDescriptionProvider;
    GetProvider(type_: Type): TypeDescriptionProvider;
}


export const TypeDescriptionProviderService: {
};


export type TypeDescriptionProviderService = TypeDescriptionProviderService$instance;