@bettergi/types 0.1.12 → 0.1.14

package/types/System/Collections/Generic/Dictionary.d.ts

@@ -1,9 +1,27 @@
+import type {
+  ClrHostValue,
+  FamilyArgumentOmitted,
+  HostArray,
+  HostType,
+  Int32Host,
+  PublicDefaultConstructorTrait,
+  ReferenceTypeTrait,
+  StrongNumeric,
+  ValueTypeTrait
+} from "../../../Microsoft/ClearScript/HostType";
+import type { HostVariableOut } from "../../../Microsoft/ClearScript/HostVariable";
+import type { VoidResult } from "../../../Microsoft/ClearScript/VoidResult";
+import "../../IDisposable";
 import "../../Runtime/Serialization/IDeserializationCallback";
 import "../../Runtime/Serialization/ISerializable";
-import "../DictionaryEntry";
+import "../../Runtime/Serialization/SerializationInfo";
+import "../../Runtime/Serialization/StreamingContext";
+import "../../ValueType";
 import "../ICollection";
 import "../IDictionary";
-import "./DictionaryEnumerator";
+import "../IDictionaryEnumerator";
+import "../IEnumerable";
+import "../IEnumerator";
 import "./ICollection";
 import "./IDictionary";
 import "./IEnumerable";
@@ -13,202 +31,268 @@ import "./IReadOnlyCollection";
 import "./IReadOnlyDictionary";
 import "./KeyValuePair";
 
-declare global {
-  namespace System.Collections.Generic {
-    class Dictionary<TKey, TValue>
-      implements
-        System.Collections.Generic.IDictionary<TKey, TValue>,
-        System.Collections.IDictionary,
-        System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>,
-        System.Runtime.Serialization.ISerializable,
-        System.Runtime.Serialization.IDeserializationCallback
-    {
-      comparer: System.Collections.Generic.IEqualityComparer<TKey>;
-
-      count: number;
-
-      keys: System.Collections.Generic.KeyCollection<TKey, TValue>;
-
-      values: System.Collections.Generic.ValueCollection<TKey, TValue>;
-
-      add(item: System.Collections.Generic.KeyValuePair<TKey, TValue>): void;
-
-      add(key: TKey, value: TValue): void;
-
-      contains(item: System.Collections.Generic.KeyValuePair<TKey, TValue>): boolean;
-
-      remove(item: System.Collections.Generic.KeyValuePair<TKey, TValue>): boolean;
-
-      remove(key: TKey): boolean;
-
-      remove(key: TKey, value: TValue | null): boolean;
-
-      clear(): void;
-
-      containsKey(key: TKey): boolean;
-
-      containsValue(value: TValue): boolean;
-
-      getEnumerator(): System.Collections.Generic.DictionaryEnumerator<TKey, TValue>;
-
-      onDeserialization(sender: any): void;
-
-      tryGetValue(key: TKey, value: TValue | null): boolean;
-
-      tryAdd(key: TKey, value: TValue): boolean;
-
-      copyTo(
-        array: System.Collections.Generic.KeyValuePair<TKey, TValue>[],
-        arrayIndex: number
-      ): void;
-
-      ensureCapacity(capacity: number): number;
-
-      trimExcess(): void;
-
-      trimExcess(capacity: number): void;
-
-      isSynchronized: boolean;
-
-      syncRoot: any;
-
-      isFixedSize: boolean;
-
-      isReadOnly: boolean;
-
-      constructor();
-
-      constructor(capacity: number);
-
-      constructor(comparer: System.Collections.Generic.IEqualityComparer<TKey>);
-
-      constructor(capacity: number, comparer: System.Collections.Generic.IEqualityComparer<TKey>);
-
-      constructor(dictionary: System.Collections.Generic.IDictionary<TKey, TValue>);
-
-      constructor(
-        dictionary: System.Collections.Generic.IDictionary<TKey, TValue>,
-        comparer: System.Collections.Generic.IEqualityComparer<TKey>
-      );
-
-      constructor(
-        collection: System.Collections.Generic.IEnumerable<
-          System.Collections.Generic.KeyValuePair<TKey, TValue>
-        >
-      );
-
-      constructor(
-        collection: System.Collections.Generic.IEnumerable<
-          System.Collections.Generic.KeyValuePair<TKey, TValue>
-        >,
-        comparer: System.Collections.Generic.IEqualityComparer<TKey>
-      );
-    }
-
-    class DictionaryEnumerator<TKey, TValue>
-      implements
-        System.Collections.Generic.IEnumerator<
-          System.Collections.Generic.KeyValuePair<TKey, TValue>
-        >,
-        System.Collections.IDictionaryEnumerator
-    {
-      moveNext(): boolean;
-
-      current: System.Collections.Generic.KeyValuePair<TKey, TValue>;
-
-      dispose(): void;
-
-      reset(): void;
-
-      entry: System.Collections.DictionaryEntry;
-
-      key: any;
-
-      value: any;
-    }
-
-    class KeyCollection<TKey, TValue>
-      implements
-        System.Collections.Generic.ICollection<TKey>,
-        System.Collections.ICollection,
-        System.Collections.Generic.IReadOnlyCollection<TKey>
-    {
-      getEnumerator(): System.Collections.Generic.KeyCollection.Enumerator<TKey>;
-
-      copyTo(array: TKey[], index: number): void;
-
-      count: number;
-
-      isReadOnly: boolean;
-
-      add(item: TKey): void;
-
-      clear(): void;
-
-      contains(key: TKey): boolean;
-
-      remove(item: TKey): boolean;
-
-      isSynchronized: boolean;
-
-      syncRoot: any;
-
-      constructor(dictionary: System.Collections.Generic.Dictionary<TKey, TValue>);
-    }
-
-    namespace KeyCollection {
-      class Enumerator<TKey> implements System.Collections.Generic.IEnumerator<TKey> {
-        dispose(): void;
+declare const dictionaryArity2Brand: unique symbol;
+export interface _DictionaryArity2<TKey, TValue>
+  extends
+    ClrHostValue,
+    System.Collections.Generic.IDictionaryInput<TKey, TValue>,
+    System.Collections.Generic.ICollectionInput<
+      System.Collections.Generic.KeyValuePair<TKey, TValue>
+    >,
+    System.Collections.Generic.IEnumerableInput<
+      System.Collections.Generic.KeyValuePair<TKey, TValue>
+    >,
+    System.Collections.IEnumerableInput,
+    System.Collections.IDictionaryInput,
+    System.Collections.ICollectionInput,
+    System.Collections.Generic.IReadOnlyDictionaryInput<TKey, TValue>,
+    System.Collections.Generic.IReadOnlyCollectionInput<
+      System.Collections.Generic.KeyValuePair<TKey, TValue>
+    >,
+    System.Runtime.Serialization.ISerializableInput,
+    System.Runtime.Serialization.IDeserializationCallbackInput {
+  readonly [dictionaryArity2Brand]: true;
+  add(key: TKey, value: TValue | null): VoidResult;
+  clear(): VoidResult;
+  containsKey(key: TKey): boolean;
+  containsValue(value: TValue | null): boolean;
+  ensureCapacity(capacity: number | StrongNumeric<Int32Host>): number;
+  getEnumerator(): _DictionaryArity2_Enumerator<TKey, TValue>;
+  getObjectData(
+    info: System.Runtime.Serialization.SerializationInfo,
+    context: System.Runtime.Serialization.StreamingContext
+  ): VoidResult;
+  item: { (key: TKey): TValue; get(key: TKey): TValue; set(key: TKey, value: TValue): TValue };
+  onDeserialization(sender: unknown | null): VoidResult;
+  readonly comparer: System.Collections.Generic.IEqualityComparer<TKey>;
+  readonly count: number;
+  readonly keys: _DictionaryArity2_KeyCollection<TKey, TValue>;
+  readonly values: _DictionaryArity2_ValueCollection<TKey, TValue>;
+  remove(key: TKey): boolean;
+  remove(key: TKey, value: HostVariableOut<TValue>): boolean;
+  trimExcess(): VoidResult;
+  trimExcess(capacity: number | StrongNumeric<Int32Host>): VoidResult;
+  tryAdd(key: TKey, value: TValue | null): boolean;
+  tryGetValue(key: TKey, value: HostVariableOut<TValue>): boolean;
+}
 
-        moveNext(): boolean;
+declare const dictionaryArity2_EnumeratorBrand: unique symbol;
+export interface _DictionaryArity2_Enumerator<TKey, TValue>
+  extends
+    ClrHostValue,
+    System.Collections.Generic.IEnumeratorInput<
+      System.Collections.Generic.KeyValuePair<TKey, TValue>
+    >,
+    System.IDisposableInput,
+    System.Collections.IEnumeratorInput,
+    System.Collections.IDictionaryEnumeratorInput {
+  readonly [dictionaryArity2_EnumeratorBrand]: true;
+  moveNext(): boolean;
+  readonly current: System.Collections.Generic.KeyValuePair<TKey, TValue>;
+  dispose(): VoidResult;
+}
 
-        current: TKey;
+export interface _DictionaryArity2_EnumeratorHostType<TKey, TValue> extends HostType<
+  _DictionaryArity2_Enumerator<TKey, TValue>,
+  ValueTypeTrait
+> {}
 
-        reset(): void;
-      }
-    }
+declare global {
+  namespace System.Collections.Generic.Dictionary {
+    type Enumerator<TKey, TValue> = import("./Dictionary")._DictionaryArity2_Enumerator<
+      TKey,
+      TValue
+    >;
+  }
+}
 
-    class ValueCollection<TKey, TValue>
-      implements
-        System.Collections.Generic.ICollection<TValue>,
-        System.Collections.ICollection,
-        System.Collections.Generic.IReadOnlyCollection<TValue>
-    {
-      getEnumerator(): System.Collections.Generic.ValueCollection.Enumerator<TValue>;
+declare const dictionaryArity2_KeyCollectionBrand: unique symbol;
+export interface _DictionaryArity2_KeyCollection<TKey, TValue>
+  extends
+    ClrHostValue,
+    System.Collections.Generic.ICollectionInput<TKey>,
+    System.Collections.Generic.IEnumerableInput<TKey>,
+    System.Collections.IEnumerableInput,
+    System.Collections.ICollectionInput,
+    System.Collections.Generic.IReadOnlyCollectionInput<TKey> {
+  readonly [dictionaryArity2_KeyCollectionBrand]: true;
+  contains(item: TKey): boolean;
+  copyTo(array: HostArray<TKey>, index: number | StrongNumeric<Int32Host>): VoidResult;
+  getEnumerator(): _DictionaryArity2_KeyCollection_Enumerator<TKey, TValue>;
+  readonly count: number;
+}
 
-      copyTo(array: TValue[], index: number): void;
+declare const dictionaryArity2_KeyCollection_EnumeratorBrand: unique symbol;
+export interface _DictionaryArity2_KeyCollection_Enumerator<TKey, TValue>
+  extends
+    ClrHostValue,
+    System.Collections.Generic.IEnumeratorInput<TKey>,
+    System.IDisposableInput,
+    System.Collections.IEnumeratorInput {
+  readonly [dictionaryArity2_KeyCollection_EnumeratorBrand]: true;
+  moveNext(): boolean;
+  readonly current: TKey;
+  dispose(): VoidResult;
+}
 
-      count: number;
+export interface _DictionaryArity2_KeyCollection_EnumeratorHostType<TKey, TValue> extends HostType<
+  _DictionaryArity2_KeyCollection_Enumerator<TKey, TValue>,
+  ValueTypeTrait
+> {}
 
-      isReadOnly: boolean;
+declare global {
+  namespace System.Collections.Generic.Dictionary.KeyCollection {
+    type Enumerator<TKey, TValue> =
+      import("./Dictionary")._DictionaryArity2_KeyCollection_Enumerator<TKey, TValue>;
+  }
+}
 
-      add(item: TValue): void;
+export interface _DictionaryArity2_KeyCollectionHostType<TKey, TValue> extends HostType<
+  _DictionaryArity2_KeyCollection<TKey, TValue>,
+  ReferenceTypeTrait
+> {
+  new (
+    dictionary: System.Collections.Generic.Dictionary<TKey, TValue>
+  ): _DictionaryArity2_KeyCollection<TKey, TValue>;
+  readonly Enumerator: _DictionaryArity2_KeyCollection_EnumeratorHostType<any, any>;
+}
 
-      clear(): void;
+declare global {
+  namespace System.Collections.Generic.Dictionary {
+    type KeyCollection<TKey, TValue> = import("./Dictionary")._DictionaryArity2_KeyCollection<
+      TKey,
+      TValue
+    >;
+  }
+}
 
-      contains(key: TValue): boolean;
+declare const dictionaryArity2_ValueCollectionBrand: unique symbol;
+export interface _DictionaryArity2_ValueCollection<TKey, TValue>
+  extends
+    ClrHostValue,
+    System.Collections.Generic.ICollectionInput<TValue>,
+    System.Collections.Generic.IEnumerableInput<TValue>,
+    System.Collections.IEnumerableInput,
+    System.Collections.ICollectionInput,
+    System.Collections.Generic.IReadOnlyCollectionInput<TValue> {
+  readonly [dictionaryArity2_ValueCollectionBrand]: true;
+  copyTo(array: HostArray<TValue>, index: number | StrongNumeric<Int32Host>): VoidResult;
+  getEnumerator(): _DictionaryArity2_ValueCollection_Enumerator<TKey, TValue>;
+  readonly count: number;
+}
 
-      remove(item: TValue): boolean;
+declare const dictionaryArity2_ValueCollection_EnumeratorBrand: unique symbol;
+export interface _DictionaryArity2_ValueCollection_Enumerator<TKey, TValue>
+  extends
+    ClrHostValue,
+    System.Collections.Generic.IEnumeratorInput<TValue>,
+    System.IDisposableInput,
+    System.Collections.IEnumeratorInput {
+  readonly [dictionaryArity2_ValueCollection_EnumeratorBrand]: true;
+  moveNext(): boolean;
+  readonly current: TValue;
+  dispose(): VoidResult;
+}
 
-      isSynchronized: boolean;
+export interface _DictionaryArity2_ValueCollection_EnumeratorHostType<
+  TKey,
+  TValue
+> extends HostType<_DictionaryArity2_ValueCollection_Enumerator<TKey, TValue>, ValueTypeTrait> {}
 
-      syncRoot: any;
+declare global {
+  namespace System.Collections.Generic.Dictionary.ValueCollection {
+    type Enumerator<TKey, TValue> =
+      import("./Dictionary")._DictionaryArity2_ValueCollection_Enumerator<TKey, TValue>;
+  }
+}
 
-      constructor(dictionary: System.Collections.Generic.Dictionary<TKey, TValue>);
-    }
+export interface _DictionaryArity2_ValueCollectionHostType<TKey, TValue> extends HostType<
+  _DictionaryArity2_ValueCollection<TKey, TValue>,
+  ReferenceTypeTrait
+> {
+  new (
+    dictionary: System.Collections.Generic.Dictionary<TKey, TValue>
+  ): _DictionaryArity2_ValueCollection<TKey, TValue>;
+  readonly Enumerator: _DictionaryArity2_ValueCollection_EnumeratorHostType<any, any>;
+}
 
-    namespace ValueCollection {
-      class Enumerator<TValue> implements System.Collections.Generic.IEnumerator<TValue> {
-        dispose(): void;
+declare global {
+  namespace System.Collections.Generic.Dictionary {
+    type ValueCollection<TKey, TValue> = import("./Dictionary")._DictionaryArity2_ValueCollection<
+      TKey,
+      TValue
+    >;
+  }
+}
 
-        moveNext(): boolean;
+export interface _DictionaryArity2HostType<TKey, TValue> extends HostType<
+  _DictionaryArity2<TKey, TValue>,
+  ReferenceTypeTrait & PublicDefaultConstructorTrait
+> {
+  new (): _DictionaryArity2<TKey, TValue>;
+  new (capacity: number | StrongNumeric<Int32Host>): _DictionaryArity2<TKey, TValue>;
+  new (
+    comparer: System.Collections.Generic.IEqualityComparer<TKey> | null
+  ): _DictionaryArity2<TKey, TValue>;
+  new (
+    capacity: number | StrongNumeric<Int32Host>,
+    comparer: System.Collections.Generic.IEqualityComparer<TKey> | null
+  ): _DictionaryArity2<TKey, TValue>;
+  new (
+    dictionary: System.Collections.Generic.IDictionary<TKey, TValue>
+  ): _DictionaryArity2<TKey, TValue>;
+  new (
+    dictionary: System.Collections.Generic.IDictionary<TKey, TValue>,
+    comparer: System.Collections.Generic.IEqualityComparer<TKey> | null
+  ): _DictionaryArity2<TKey, TValue>;
+  new (
+    collection: System.Collections.Generic.IEnumerable<
+      System.Collections.Generic.KeyValuePair<TKey, TValue>
+    >
+  ): _DictionaryArity2<TKey, TValue>;
+  new (
+    collection: System.Collections.Generic.IEnumerable<
+      System.Collections.Generic.KeyValuePair<TKey, TValue>
+    >,
+    comparer: System.Collections.Generic.IEqualityComparer<TKey> | null
+  ): _DictionaryArity2<TKey, TValue>;
+  readonly Enumerator: _DictionaryArity2_EnumeratorHostType<any, any>;
+  readonly KeyCollection: _DictionaryArity2_KeyCollectionHostType<any, any>;
+  readonly ValueCollection: _DictionaryArity2_ValueCollectionHostType<any, any>;
+}
 
-        current: TValue;
+export type DictionaryFamily<
+  T1 = FamilyArgumentOmitted,
+  T2 = FamilyArgumentOmitted
+> = _DictionaryArity2<T1, T2>;
 
-        reset(): void;
-      }
-    }
+declare global {
+  namespace System.Collections.Generic {
+    type Dictionary<
+      T1 = Microsoft.ClearScript.FamilyArgumentOmitted,
+      T2 = Microsoft.ClearScript.FamilyArgumentOmitted
+    > = import("./Dictionary").DictionaryFamily<T1, T2>;
   }
 }
 
+export type DictionaryHostType<T1, T2> = _DictionaryArity2HostType<T1, T2>;
+
+declare const dictionary_EnumeratorBrand: unique symbol;
+export interface Dictionary_Enumerator<TKey, TValue>
+  extends
+    ClrHostValue,
+    System.Collections.Generic.IEnumeratorInput<TKey>,
+    System.IDisposableInput,
+    System.Collections.IEnumeratorInput {
+  readonly [dictionary_EnumeratorBrand]: true;
+  moveNext(): boolean;
+  readonly current: TKey;
+  dispose(): VoidResult;
+}
+
+export interface Dictionary_EnumeratorHostType<TKey, TValue> extends HostType<
+  Dictionary_Enumerator<TKey, TValue>,
+  ValueTypeTrait
+> {}
+
 export {};

package/types/System/Collections/Generic/HashSet.d.ts

@@ -0,0 +1,134 @@
+import type {
+  ClrHostValue,
+  FamilyArgumentOmitted,
+  HostArray,
+  HostType,
+  Int32Host,
+  PublicDefaultConstructorTrait,
+  ReferenceTypeTrait,
+  StrongNumeric,
+  ValueTypeTrait
+} from "../../../Microsoft/ClearScript/HostType";
+import type { HostVariableOut } from "../../../Microsoft/ClearScript/HostVariable";
+import type { VoidResult } from "../../../Microsoft/ClearScript/VoidResult";
+import "../../IDisposable";
+import "../../Predicate";
+import "../../Runtime/Serialization/IDeserializationCallback";
+import "../../Runtime/Serialization/ISerializable";
+import "../../Runtime/Serialization/SerializationInfo";
+import "../../Runtime/Serialization/StreamingContext";
+import "../../ValueType";
+import "../IEnumerable";
+import "../IEnumerator";
+import "./ICollection";
+import "./IEnumerable";
+import "./IEnumerator";
+import "./IEqualityComparer";
+import "./IReadOnlyCollection";
+import "./IReadOnlySet";
+import "./ISet";
+
+declare const hashSetArity1Brand: unique symbol;
+export interface _HashSetArity1<T>
+  extends
+    ClrHostValue,
+    System.Collections.Generic.ICollectionInput<T>,
+    System.Collections.Generic.IEnumerableInput<T>,
+    System.Collections.IEnumerableInput,
+    System.Collections.Generic.ISetInput<T>,
+    System.Collections.Generic.IReadOnlyCollectionInput<T>,
+    System.Collections.Generic.IReadOnlySetInput<T>,
+    System.Runtime.Serialization.ISerializableInput,
+    System.Runtime.Serialization.IDeserializationCallbackInput {
+  readonly [hashSetArity1Brand]: true;
+  add(item: T | null): boolean;
+  clear(): VoidResult;
+  contains(item: T | null): boolean;
+  copyTo(array: HostArray<T>): VoidResult;
+  copyTo(array: HostArray<T>, arrayIndex: number | StrongNumeric<Int32Host>): VoidResult;
+  copyTo(
+    array: HostArray<T>,
+    arrayIndex: number | StrongNumeric<Int32Host>,
+    count: number | StrongNumeric<Int32Host>
+  ): VoidResult;
+  ensureCapacity(capacity: number | StrongNumeric<Int32Host>): number;
+  exceptWith(other: System.Collections.Generic.IEnumerable<T>): VoidResult;
+  getEnumerator(): _HashSetArity1_Enumerator<T>;
+  getObjectData(
+    info: System.Runtime.Serialization.SerializationInfo,
+    context: System.Runtime.Serialization.StreamingContext
+  ): VoidResult;
+  intersectWith(other: System.Collections.Generic.IEnumerable<T>): VoidResult;
+  isProperSubsetOf(other: System.Collections.Generic.IEnumerable<T>): boolean;
+  isProperSupersetOf(other: System.Collections.Generic.IEnumerable<T>): boolean;
+  isSubsetOf(other: System.Collections.Generic.IEnumerable<T>): boolean;
+  isSupersetOf(other: System.Collections.Generic.IEnumerable<T>): boolean;
+  onDeserialization(sender: unknown | null): VoidResult;
+  overlaps(other: System.Collections.Generic.IEnumerable<T>): boolean;
+  readonly comparer: System.Collections.Generic.IEqualityComparer<T>;
+  readonly count: number;
+  remove(item: T | null): boolean;
+  removeWhere(match: System.Predicate<T>): number;
+  setEquals(other: System.Collections.Generic.IEnumerable<T>): boolean;
+  symmetricExceptWith(other: System.Collections.Generic.IEnumerable<T>): VoidResult;
+  trimExcess(): VoidResult;
+  tryGetValue(equalValue: T | null, actualValue: HostVariableOut<T>): boolean;
+  unionWith(other: System.Collections.Generic.IEnumerable<T>): VoidResult;
+}
+
+declare const hashSetArity1_EnumeratorBrand: unique symbol;
+export interface _HashSetArity1_Enumerator<T>
+  extends
+    ClrHostValue,
+    System.Collections.Generic.IEnumeratorInput<T>,
+    System.IDisposableInput,
+    System.Collections.IEnumeratorInput {
+  readonly [hashSetArity1_EnumeratorBrand]: true;
+  moveNext(): boolean;
+  readonly current: T;
+  dispose(): VoidResult;
+}
+
+export interface _HashSetArity1_EnumeratorHostType<T> extends HostType<
+  _HashSetArity1_Enumerator<T>,
+  ValueTypeTrait
+> {}
+
+declare global {
+  namespace System.Collections.Generic.HashSet {
+    type Enumerator<T> = import("./HashSet")._HashSetArity1_Enumerator<T>;
+  }
+}
+
+export interface _HashSetArity1HostType<T> extends HostType<
+  _HashSetArity1<T>,
+  ReferenceTypeTrait & PublicDefaultConstructorTrait
+> {
+  new (): _HashSetArity1<T>;
+  new (comparer: System.Collections.Generic.IEqualityComparer<T> | null): _HashSetArity1<T>;
+  new (capacity: number | StrongNumeric<Int32Host>): _HashSetArity1<T>;
+  new (collection: System.Collections.Generic.IEnumerable<T>): _HashSetArity1<T>;
+  new (
+    collection: System.Collections.Generic.IEnumerable<T>,
+    comparer: System.Collections.Generic.IEqualityComparer<T> | null
+  ): _HashSetArity1<T>;
+  new (
+    capacity: number | StrongNumeric<Int32Host>,
+    comparer: System.Collections.Generic.IEqualityComparer<T> | null
+  ): _HashSetArity1<T>;
+  createSetComparer(): System.Collections.Generic.IEqualityComparer<System.Collections.Generic.HashSet>;
+  readonly Enumerator: _HashSetArity1_EnumeratorHostType<any>;
+}
+
+export type HashSetFamily<T1 = FamilyArgumentOmitted> = _HashSetArity1<T1>;
+
+declare global {
+  namespace System.Collections.Generic {
+    type HashSet<T1 = Microsoft.ClearScript.FamilyArgumentOmitted> =
+      import("./HashSet").HashSetFamily<T1>;
+  }
+}
+
+export type HashSetHostType<T1> = _HashSetArity1HostType<T1>;
+
+export {};

package/types/System/Collections/Generic/ICollection.d.ts

@@ -1,23 +1,56 @@
+import type {
+  FamilyArgumentOmitted,
+  HostArray,
+  HostType,
+  Int32Host,
+  InterfaceTypeTrait,
+  StrongNumeric
+} from "../../../Microsoft/ClearScript/HostType";
+import type { VoidResult } from "../../../Microsoft/ClearScript/VoidResult";
+import "../IEnumerable";
 import "./IEnumerable";
 
-declare global {
-  namespace System.Collections.Generic {
-    interface ICollection<T> extends System.Collections.Generic.IEnumerable<T> {
-      count: number;
+declare const iCollectionArity1InputBrand: unique symbol;
+export interface _ICollectionArity1Input<T> {
+  readonly [iCollectionArity1InputBrand]: true;
+}
 
-      isReadOnly: boolean;
+export interface _ICollectionArity1<T>
+  extends
+    Microsoft.ClearScript.ClrInterfaceView<_ICollectionArity1Input<T>>,
+    _ICollectionArity1Input<T> {
+  add(item: T | null): VoidResult;
+  clear(): VoidResult;
+  contains(item: T | null): boolean;
+  copyTo(array: HostArray<T>, arrayIndex: number | StrongNumeric<Int32Host>): VoidResult;
+  readonly count: number;
+  readonly isReadOnly: boolean;
+  remove(item: T | null): boolean;
+}
 
-      add(item: T): void;
+export interface _ICollectionArity1HostType<T> extends HostType<
+  _ICollectionArity1<T>,
+  InterfaceTypeTrait
+> {}
 
-      clear(): void;
+export type ICollectionFamily<T1 = FamilyArgumentOmitted> = _ICollectionArity1<T1>;
 
-      contains(item: T): boolean;
+declare global {
+  namespace System.Collections.Generic {
+    type ICollection<T1 = Microsoft.ClearScript.FamilyArgumentOmitted> =
+      import("./ICollection").ICollectionFamily<T1>;
+  }
+}
 
-      copyTo(array: T[], arrayIndex: number): void;
+export type ICollectionInputFamily<T1 = FamilyArgumentOmitted> = _ICollectionArity1Input<T1>;
+export type ICollectionInput<T1> = _ICollectionArity1Input<T1>;
 
-      remove(item: T): boolean;
-    }
+declare global {
+  namespace System.Collections.Generic {
+    type ICollectionInput<T1> = import("./ICollection").ICollectionInput<T1>;
   }
 }
 
+export type ICollectionHostType<T1> = _ICollectionArity1HostType<T1>;
+
 export {};