@bettergi/types 0.1.12 → 0.1.14

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

@@ -0,0 +1,44 @@
+import type {
+  FamilyArgumentOmitted,
+  HostType,
+  InterfaceTypeTrait
+} from "../../../Microsoft/ClearScript/HostType";
+
+declare const iComparerArity1InputBrand: unique symbol;
+export interface _IComparerArity1Input<T> {
+  readonly [iComparerArity1InputBrand]: true;
+}
+
+export interface _IComparerArity1<T>
+  extends
+    Microsoft.ClearScript.ClrInterfaceView<_IComparerArity1Input<T>>,
+    _IComparerArity1Input<T> {
+  compare(x: T | null, y: T | null): number;
+}
+
+export interface _IComparerArity1HostType<T> extends HostType<
+  _IComparerArity1<T>,
+  InterfaceTypeTrait
+> {}
+
+export type IComparerFamily<T1 = FamilyArgumentOmitted> = _IComparerArity1<T1>;
+
+declare global {
+  namespace System.Collections.Generic {
+    type IComparer<T1 = Microsoft.ClearScript.FamilyArgumentOmitted> =
+      import("./IComparer").IComparerFamily<T1>;
+  }
+}
+
+export type IComparerInputFamily<T1 = FamilyArgumentOmitted> = _IComparerArity1Input<T1>;
+export type IComparerInput<T1> = _IComparerArity1Input<T1>;
+
+declare global {
+  namespace System.Collections.Generic {
+    type IComparerInput<T1> = import("./IComparer").IComparerInput<T1>;
+  }
+}
+
+export type IComparerHostType<T1> = _IComparerArity1HostType<T1>;
+
+export {};

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

@@ -1,12 +1,64 @@
+import type {
+  FamilyArgumentOmitted,
+  HostType,
+  InterfaceTypeTrait
+} from "../../../Microsoft/ClearScript/HostType";
+import type { HostVariableOut } from "../../../Microsoft/ClearScript/HostVariable";
+import type { VoidResult } from "../../../Microsoft/ClearScript/VoidResult";
+import "../IEnumerable";
 import "./ICollection";
 import "./IEnumerable";
+import "./KeyValuePair";
+
+declare const iDictionaryArity2InputBrand: unique symbol;
+export interface _IDictionaryArity2Input<TKey, TValue> {
+  readonly [iDictionaryArity2InputBrand]: true;
+}
+
+export interface _IDictionaryArity2<TKey, TValue>
+  extends
+    Microsoft.ClearScript.ClrInterfaceView<_IDictionaryArity2Input<TKey, TValue>>,
+    _IDictionaryArity2Input<TKey, TValue> {
+  add(key: TKey | null, value: TValue | null): VoidResult;
+  containsKey(key: TKey | null): boolean;
+  item: { (key: TKey): TValue; get(key: TKey): TValue; set(key: TKey, value: TValue): TValue };
+  readonly keys: System.Collections.Generic.ICollection<TKey>;
+  readonly values: System.Collections.Generic.ICollection<TValue>;
+  remove(key: TKey | null): boolean;
+  tryGetValue(key: TKey | null, value: HostVariableOut<TValue>): boolean;
+}
+
+export interface _IDictionaryArity2HostType<TKey, TValue> extends HostType<
+  _IDictionaryArity2<TKey, TValue>,
+  InterfaceTypeTrait
+> {}
+
+export type IDictionaryFamily<
+  T1 = FamilyArgumentOmitted,
+  T2 = FamilyArgumentOmitted
+> = _IDictionaryArity2<T1, T2>;
 
 declare global {
   namespace System.Collections.Generic {
-    interface IDictionary<TKey, TValue>
-      extends System.Collections.Generic.ICollection<KeyValuePair<TKey, TValue>>,
-        System.Collections.Generic.IEnumerable<KeyValuePair<TKey, TValue>> {}
+    type IDictionary<
+      T1 = Microsoft.ClearScript.FamilyArgumentOmitted,
+      T2 = Microsoft.ClearScript.FamilyArgumentOmitted
+    > = import("./IDictionary").IDictionaryFamily<T1, T2>;
   }
 }
 
+export type IDictionaryInputFamily<
+  T1 = FamilyArgumentOmitted,
+  T2 = FamilyArgumentOmitted
+> = _IDictionaryArity2Input<T1, T2>;
+export type IDictionaryInput<T1, T2> = _IDictionaryArity2Input<T1, T2>;
+
+declare global {
+  namespace System.Collections.Generic {
+    type IDictionaryInput<T1, T2> = import("./IDictionary").IDictionaryInput<T1, T2>;
+  }
+}
+
+export type IDictionaryHostType<T1, T2> = _IDictionaryArity2HostType<T1, T2>;
+
 export {};

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

@@ -1,12 +1,46 @@
-import "../../Collections/IEnumerable";
+import type {
+  FamilyArgumentOmitted,
+  HostType,
+  InterfaceTypeTrait
+} from "../../../Microsoft/ClearScript/HostType";
+import "../IEnumerable";
 import "./IEnumerator";
 
+declare const iEnumerableArity1InputBrand: unique symbol;
+export interface _IEnumerableArity1Input<T> {
+  readonly [iEnumerableArity1InputBrand]: true;
+}
+
+export interface _IEnumerableArity1<T>
+  extends
+    Microsoft.ClearScript.ClrInterfaceView<_IEnumerableArity1Input<T>>,
+    _IEnumerableArity1Input<T> {
+  getEnumerator(): System.Collections.Generic.IEnumerator<T>;
+}
+
+export interface _IEnumerableArity1HostType<T> extends HostType<
+  _IEnumerableArity1<T>,
+  InterfaceTypeTrait
+> {}
+
+export type IEnumerableFamily<T1 = FamilyArgumentOmitted> = _IEnumerableArity1<T1>;
+
 declare global {
   namespace System.Collections.Generic {
-    interface IEnumerable<T> extends System.Collections.IEnumerable {
-      getEnumerator(): System.Collections.Generic.IEnumerator<T>;
-    }
+    type IEnumerable<T1 = Microsoft.ClearScript.FamilyArgumentOmitted> =
+      import("./IEnumerable").IEnumerableFamily<T1>;
   }
 }
 
+export type IEnumerableInputFamily<T1 = FamilyArgumentOmitted> = _IEnumerableArity1Input<T1>;
+export type IEnumerableInput<T1> = _IEnumerableArity1Input<T1>;
+
+declare global {
+  namespace System.Collections.Generic {
+    type IEnumerableInput<T1> = import("./IEnumerable").IEnumerableInput<T1>;
+  }
+}
+
+export type IEnumerableHostType<T1> = _IEnumerableArity1HostType<T1>;
+
 export {};

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

@@ -1,12 +1,46 @@
-import "../../Collections/IEnumerator";
+import type {
+  FamilyArgumentOmitted,
+  HostType,
+  InterfaceTypeTrait
+} from "../../../Microsoft/ClearScript/HostType";
 import "../../IDisposable";
+import "../IEnumerator";
+
+declare const iEnumeratorArity1InputBrand: unique symbol;
+export interface _IEnumeratorArity1Input<T> {
+  readonly [iEnumeratorArity1InputBrand]: true;
+}
+
+export interface _IEnumeratorArity1<T>
+  extends
+    Microsoft.ClearScript.ClrInterfaceView<_IEnumeratorArity1Input<T>>,
+    _IEnumeratorArity1Input<T> {
+  readonly current: T;
+}
+
+export interface _IEnumeratorArity1HostType<T> extends HostType<
+  _IEnumeratorArity1<T>,
+  InterfaceTypeTrait
+> {}
+
+export type IEnumeratorFamily<T1 = FamilyArgumentOmitted> = _IEnumeratorArity1<T1>;
 
 declare global {
   namespace System.Collections.Generic {
-    interface IEnumerator<T> extends System.IDisposable, System.Collections.IEnumerator {
-      current: T;
-    }
+    type IEnumerator<T1 = Microsoft.ClearScript.FamilyArgumentOmitted> =
+      import("./IEnumerator").IEnumeratorFamily<T1>;
   }
 }
 
+export type IEnumeratorInputFamily<T1 = FamilyArgumentOmitted> = _IEnumeratorArity1Input<T1>;
+export type IEnumeratorInput<T1> = _IEnumeratorArity1Input<T1>;
+
+declare global {
+  namespace System.Collections.Generic {
+    type IEnumeratorInput<T1> = import("./IEnumerator").IEnumeratorInput<T1>;
+  }
+}
+
+export type IEnumeratorHostType<T1> = _IEnumeratorArity1HostType<T1>;
+
 export {};

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

@@ -1,11 +1,46 @@
+import type {
+  FamilyArgumentOmitted,
+  HostType,
+  InterfaceTypeTrait
+} from "../../../Microsoft/ClearScript/HostType";
+
+declare const iEqualityComparerArity1InputBrand: unique symbol;
+export interface _IEqualityComparerArity1Input<T> {
+  readonly [iEqualityComparerArity1InputBrand]: true;
+}
+
+export interface _IEqualityComparerArity1<T>
+  extends
+    Microsoft.ClearScript.ClrInterfaceView<_IEqualityComparerArity1Input<T>>,
+    _IEqualityComparerArity1Input<T> {
+  equals(x: T | null, y: T | null): boolean;
+  getHashCode(obj: T | null): number;
+}
+
+export interface _IEqualityComparerArity1HostType<T> extends HostType<
+  _IEqualityComparerArity1<T>,
+  InterfaceTypeTrait
+> {}
+
+export type IEqualityComparerFamily<T1 = FamilyArgumentOmitted> = _IEqualityComparerArity1<T1>;
+
 declare global {
   namespace System.Collections.Generic {
-    interface IEqualityComparer<T> {
-      equals(x: T | null, y: T | null): boolean;
+    type IEqualityComparer<T1 = Microsoft.ClearScript.FamilyArgumentOmitted> =
+      import("./IEqualityComparer").IEqualityComparerFamily<T1>;
+  }
+}
+
+export type IEqualityComparerInputFamily<T1 = FamilyArgumentOmitted> =
+  _IEqualityComparerArity1Input<T1>;
+export type IEqualityComparerInput<T1> = _IEqualityComparerArity1Input<T1>;
 
-      getHashCode(obj: T): number;
-    }
+declare global {
+  namespace System.Collections.Generic {
+    type IEqualityComparerInput<T1> = import("./IEqualityComparer").IEqualityComparerInput<T1>;
   }
 }
 
+export type IEqualityComparerHostType<T1> = _IEqualityComparerArity1HostType<T1>;
+
 export {};

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

@@ -1,22 +1,53 @@
+import type {
+  FamilyArgumentOmitted,
+  HostType,
+  Int32Host,
+  InterfaceTypeTrait,
+  StrongNumeric
+} from "../../../Microsoft/ClearScript/HostType";
+import type { VoidResult } from "../../../Microsoft/ClearScript/VoidResult";
+import "../IEnumerable";
 import "./ICollection";
 import "./IEnumerable";
 
-declare global {
-  namespace System.Collections.Generic {
-    interface IList<T>
-      extends System.Collections.Generic.ICollection<T>,
-        System.Collections.Generic.IEnumerable<T> {
-      isFixedSize: boolean;
+declare const iListArity1InputBrand: unique symbol;
+export interface _IListArity1Input<T> {
+  readonly [iListArity1InputBrand]: true;
+}
 
-      [index: number]: T;
+export interface _IListArity1<T>
+  extends Microsoft.ClearScript.ClrInterfaceView<_IListArity1Input<T>>, _IListArity1Input<T> {
+  [index: number]: T;
+  indexOf(item: T | null): number;
+  insert(index: number | StrongNumeric<Int32Host>, item: T | null): VoidResult;
+  item: {
+    (index: number | StrongNumeric<Int32Host>): T;
+    get(index: number | StrongNumeric<Int32Host>): T;
+    set(index: number | StrongNumeric<Int32Host>, value: T): T;
+  };
+  removeAt(index: number | StrongNumeric<Int32Host>): VoidResult;
+}
 
-      indexOf(item: T): number;
+export interface _IListArity1HostType<T> extends HostType<_IListArity1<T>, InterfaceTypeTrait> {}
 
-      insert(index: number, item: T): void;
+export type IListFamily<T1 = FamilyArgumentOmitted> = _IListArity1<T1>;
 
-      removeAt(index: number): void;
-    }
+declare global {
+  namespace System.Collections.Generic {
+    type IList<T1 = Microsoft.ClearScript.FamilyArgumentOmitted> =
+      import("./IList").IListFamily<T1>;
   }
 }
 
+export type IListInputFamily<T1 = FamilyArgumentOmitted> = _IListArity1Input<T1>;
+export type IListInput<T1> = _IListArity1Input<T1>;
+
+declare global {
+  namespace System.Collections.Generic {
+    type IListInput<T1> = import("./IList").IListInput<T1>;
+  }
+}
+
+export type IListHostType<T1> = _IListArity1HostType<T1>;
+
 export {};

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

@@ -1,11 +1,48 @@
+import type {
+  FamilyArgumentOmitted,
+  HostType,
+  InterfaceTypeTrait
+} from "../../../Microsoft/ClearScript/HostType";
+import "../IEnumerable";
 import "./IEnumerable";
 
+declare const iReadOnlyCollectionArity1InputBrand: unique symbol;
+export interface _IReadOnlyCollectionArity1Input<T> {
+  readonly [iReadOnlyCollectionArity1InputBrand]: true;
+}
+
+export interface _IReadOnlyCollectionArity1<T>
+  extends
+    Microsoft.ClearScript.ClrInterfaceView<_IReadOnlyCollectionArity1Input<T>>,
+    _IReadOnlyCollectionArity1Input<T> {
+  readonly count: number;
+}
+
+export interface _IReadOnlyCollectionArity1HostType<T> extends HostType<
+  _IReadOnlyCollectionArity1<T>,
+  InterfaceTypeTrait
+> {}
+
+export type IReadOnlyCollectionFamily<T1 = FamilyArgumentOmitted> = _IReadOnlyCollectionArity1<T1>;
+
 declare global {
   namespace System.Collections.Generic {
-    interface IReadOnlyCollection<T> extends System.Collections.Generic.IEnumerable<T> {
-      count: number;
-    }
+    type IReadOnlyCollection<T1 = Microsoft.ClearScript.FamilyArgumentOmitted> =
+      import("./IReadOnlyCollection").IReadOnlyCollectionFamily<T1>;
   }
 }
 
+export type IReadOnlyCollectionInputFamily<T1 = FamilyArgumentOmitted> =
+  _IReadOnlyCollectionArity1Input<T1>;
+export type IReadOnlyCollectionInput<T1> = _IReadOnlyCollectionArity1Input<T1>;
+
+declare global {
+  namespace System.Collections.Generic {
+    type IReadOnlyCollectionInput<T1> =
+      import("./IReadOnlyCollection").IReadOnlyCollectionInput<T1>;
+  }
+}
+
+export type IReadOnlyCollectionHostType<T1> = _IReadOnlyCollectionArity1HostType<T1>;
+
 export {};

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

@@ -1,20 +1,62 @@
+import type {
+  FamilyArgumentOmitted,
+  HostType,
+  InterfaceTypeTrait
+} from "../../../Microsoft/ClearScript/HostType";
+import type { HostVariableOut } from "../../../Microsoft/ClearScript/HostVariable";
+import "../IEnumerable";
 import "./IEnumerable";
 import "./IReadOnlyCollection";
+import "./KeyValuePair";
+
+declare const iReadOnlyDictionaryArity2InputBrand: unique symbol;
+export interface _IReadOnlyDictionaryArity2Input<TKey, TValue> {
+  readonly [iReadOnlyDictionaryArity2InputBrand]: true;
+}
+
+export interface _IReadOnlyDictionaryArity2<TKey, TValue>
+  extends
+    Microsoft.ClearScript.ClrInterfaceView<_IReadOnlyDictionaryArity2Input<TKey, TValue>>,
+    _IReadOnlyDictionaryArity2Input<TKey, TValue> {
+  containsKey(key: TKey | null): boolean;
+  item: { (key: TKey): TValue; get(key: TKey): TValue };
+  readonly keys: System.Collections.Generic.IEnumerable<TKey>;
+  readonly values: System.Collections.Generic.IEnumerable<TValue>;
+  tryGetValue(key: TKey | null, value: HostVariableOut<TValue>): boolean;
+}
+
+export interface _IReadOnlyDictionaryArity2HostType<TKey, TValue> extends HostType<
+  _IReadOnlyDictionaryArity2<TKey, TValue>,
+  InterfaceTypeTrait
+> {}
+
+export type IReadOnlyDictionaryFamily<
+  T1 = FamilyArgumentOmitted,
+  T2 = FamilyArgumentOmitted
+> = _IReadOnlyDictionaryArity2<T1, T2>;
 
 declare global {
   namespace System.Collections.Generic {
-    interface IReadOnlyDictionary<TKey, TValue>
-      extends System.Collections.Generic.IReadOnlyCollection<KeyValuePair<TKey, TValue>>,
-        System.Collections.Generic.IEnumerable<KeyValuePair<TKey, TValue>> {
-      containsKey(key: TKey): boolean;
-
-      tryGetValue(key: TKey, value: TValue | null): boolean;
+    type IReadOnlyDictionary<
+      T1 = Microsoft.ClearScript.FamilyArgumentOmitted,
+      T2 = Microsoft.ClearScript.FamilyArgumentOmitted
+    > = import("./IReadOnlyDictionary").IReadOnlyDictionaryFamily<T1, T2>;
+  }
+}
 
-      keys: System.Collections.Generic.IEnumerable<TKey>;
+export type IReadOnlyDictionaryInputFamily<
+  T1 = FamilyArgumentOmitted,
+  T2 = FamilyArgumentOmitted
+> = _IReadOnlyDictionaryArity2Input<T1, T2>;
+export type IReadOnlyDictionaryInput<T1, T2> = _IReadOnlyDictionaryArity2Input<T1, T2>;
 
-      values: System.Collections.Generic.IEnumerable<TValue>;
-    }
+declare global {
+  namespace System.Collections.Generic {
+    type IReadOnlyDictionaryInput<T1, T2> =
+      import("./IReadOnlyDictionary").IReadOnlyDictionaryInput<T1, T2>;
   }
 }
 
+export type IReadOnlyDictionaryHostType<T1, T2> = _IReadOnlyDictionaryArity2HostType<T1, T2>;
+
 export {};

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

@@ -1,11 +1,53 @@
+import type {
+  FamilyArgumentOmitted,
+  HostType,
+  Int32Host,
+  InterfaceTypeTrait,
+  StrongNumeric
+} from "../../../Microsoft/ClearScript/HostType";
+import "../IEnumerable";
+import "./IEnumerable";
 import "./IReadOnlyCollection";
 
+declare const iReadOnlyListArity1InputBrand: unique symbol;
+export interface _IReadOnlyListArity1Input<T> {
+  readonly [iReadOnlyListArity1InputBrand]: true;
+}
+
+export interface _IReadOnlyListArity1<T>
+  extends
+    Microsoft.ClearScript.ClrInterfaceView<_IReadOnlyListArity1Input<T>>,
+    _IReadOnlyListArity1Input<T> {
+  [index: number]: T;
+  item: {
+    (index: number | StrongNumeric<Int32Host>): T;
+    get(index: number | StrongNumeric<Int32Host>): T;
+  };
+}
+
+export interface _IReadOnlyListArity1HostType<T> extends HostType<
+  _IReadOnlyListArity1<T>,
+  InterfaceTypeTrait
+> {}
+
+export type IReadOnlyListFamily<T1 = FamilyArgumentOmitted> = _IReadOnlyListArity1<T1>;
+
 declare global {
   namespace System.Collections.Generic {
-    interface IReadOnlyList<T> extends System.Collections.Generic.IReadOnlyCollection<T> {
-      [index: number]: T;
-    }
+    type IReadOnlyList<T1 = Microsoft.ClearScript.FamilyArgumentOmitted> =
+      import("./IReadOnlyList").IReadOnlyListFamily<T1>;
   }
 }
 
+export type IReadOnlyListInputFamily<T1 = FamilyArgumentOmitted> = _IReadOnlyListArity1Input<T1>;
+export type IReadOnlyListInput<T1> = _IReadOnlyListArity1Input<T1>;
+
+declare global {
+  namespace System.Collections.Generic {
+    type IReadOnlyListInput<T1> = import("./IReadOnlyList").IReadOnlyListInput<T1>;
+  }
+}
+
+export type IReadOnlyListHostType<T1> = _IReadOnlyListArity1HostType<T1>;
+
 export {};

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

@@ -0,0 +1,53 @@
+import type {
+  FamilyArgumentOmitted,
+  HostType,
+  InterfaceTypeTrait
+} from "../../../Microsoft/ClearScript/HostType";
+import "../IEnumerable";
+import "./IEnumerable";
+import "./IReadOnlyCollection";
+
+declare const iReadOnlySetArity1InputBrand: unique symbol;
+export interface _IReadOnlySetArity1Input<T> {
+  readonly [iReadOnlySetArity1InputBrand]: true;
+}
+
+export interface _IReadOnlySetArity1<T>
+  extends
+    Microsoft.ClearScript.ClrInterfaceView<_IReadOnlySetArity1Input<T>>,
+    _IReadOnlySetArity1Input<T> {
+  contains(item: T | null): boolean;
+  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;
+  overlaps(other: System.Collections.Generic.IEnumerable<T>): boolean;
+  setEquals(other: System.Collections.Generic.IEnumerable<T>): boolean;
+}
+
+export interface _IReadOnlySetArity1HostType<T> extends HostType<
+  _IReadOnlySetArity1<T>,
+  InterfaceTypeTrait
+> {}
+
+export type IReadOnlySetFamily<T1 = FamilyArgumentOmitted> = _IReadOnlySetArity1<T1>;
+
+declare global {
+  namespace System.Collections.Generic {
+    type IReadOnlySet<T1 = Microsoft.ClearScript.FamilyArgumentOmitted> =
+      import("./IReadOnlySet").IReadOnlySetFamily<T1>;
+  }
+}
+
+export type IReadOnlySetInputFamily<T1 = FamilyArgumentOmitted> = _IReadOnlySetArity1Input<T1>;
+export type IReadOnlySetInput<T1> = _IReadOnlySetArity1Input<T1>;
+
+declare global {
+  namespace System.Collections.Generic {
+    type IReadOnlySetInput<T1> = import("./IReadOnlySet").IReadOnlySetInput<T1>;
+  }
+}
+
+export type IReadOnlySetHostType<T1> = _IReadOnlySetArity1HostType<T1>;
+
+export {};

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

@@ -0,0 +1,52 @@
+import type {
+  FamilyArgumentOmitted,
+  HostType,
+  InterfaceTypeTrait
+} from "../../../Microsoft/ClearScript/HostType";
+import type { VoidResult } from "../../../Microsoft/ClearScript/VoidResult";
+import "../IEnumerable";
+import "./ICollection";
+import "./IEnumerable";
+
+declare const iSetArity1InputBrand: unique symbol;
+export interface _ISetArity1Input<T> {
+  readonly [iSetArity1InputBrand]: true;
+}
+
+export interface _ISetArity1<T>
+  extends Microsoft.ClearScript.ClrInterfaceView<_ISetArity1Input<T>>, _ISetArity1Input<T> {
+  add(item: T | null): boolean;
+  exceptWith(other: System.Collections.Generic.IEnumerable<T>): 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;
+  overlaps(other: System.Collections.Generic.IEnumerable<T>): boolean;
+  setEquals(other: System.Collections.Generic.IEnumerable<T>): boolean;
+  symmetricExceptWith(other: System.Collections.Generic.IEnumerable<T>): VoidResult;
+  unionWith(other: System.Collections.Generic.IEnumerable<T>): VoidResult;
+}
+
+export interface _ISetArity1HostType<T> extends HostType<_ISetArity1<T>, InterfaceTypeTrait> {}
+
+export type ISetFamily<T1 = FamilyArgumentOmitted> = _ISetArity1<T1>;
+
+declare global {
+  namespace System.Collections.Generic {
+    type ISet<T1 = Microsoft.ClearScript.FamilyArgumentOmitted> = import("./ISet").ISetFamily<T1>;
+  }
+}
+
+export type ISetInputFamily<T1 = FamilyArgumentOmitted> = _ISetArity1Input<T1>;
+export type ISetInput<T1> = _ISetArity1Input<T1>;
+
+declare global {
+  namespace System.Collections.Generic {
+    type ISetInput<T1> = import("./ISet").ISetInput<T1>;
+  }
+}
+
+export type ISetHostType<T1> = _ISetArity1HostType<T1>;
+
+export {};

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

@@ -1,20 +1,43 @@
-declare global {
-  namespace System.Collections.Generic {
-    class KeyValuePair<TKey, TValue> {
-      key: TKey;
+import type {
+  ClrHostValue,
+  FamilyArgumentOmitted,
+  HostType,
+  ValueTypeTrait
+} from "../../../Microsoft/ClearScript/HostType";
+import type { HostVariableOut } from "../../../Microsoft/ClearScript/HostVariable";
+import type { VoidResult } from "../../../Microsoft/ClearScript/VoidResult";
+import "../../ValueType";
 
-      value: TValue;
+declare const keyValuePairArity2Brand: unique symbol;
+export interface _KeyValuePairArity2<TKey, TValue> extends ClrHostValue {
+  readonly [keyValuePairArity2Brand]: true;
+  deconstruct(key: HostVariableOut<TKey>, value: HostVariableOut<TValue>): VoidResult;
+  readonly key: TKey;
+  readonly value: TValue;
+  toString(): string;
+}
 
-      static create<TKey, TValue>(
-        key: TKey,
-        value: TValue
-      ): System.Collections.Generic.KeyValuePair<TKey, TValue>;
+export interface _KeyValuePairArity2HostType<TKey, TValue> extends HostType<
+  _KeyValuePairArity2<TKey, TValue>,
+  ValueTypeTrait
+> {
+  new (key: TKey, value: TValue): _KeyValuePairArity2<TKey, TValue>;
+}
 
-      deconstruct(outKey: TKey, outValue: TValue): void;
+export type KeyValuePairFamily<
+  T1 = FamilyArgumentOmitted,
+  T2 = FamilyArgumentOmitted
+> = _KeyValuePairArity2<T1, T2>;
 
-      constructor(key: TKey, value: TValue);
-    }
+declare global {
+  namespace System.Collections.Generic {
+    type KeyValuePair<
+      T1 = Microsoft.ClearScript.FamilyArgumentOmitted,
+      T2 = Microsoft.ClearScript.FamilyArgumentOmitted
+    > = import("./KeyValuePair").KeyValuePairFamily<T1, T2>;
   }
 }
 
+export type KeyValuePairHostType<T1, T2> = _KeyValuePairArity2HostType<T1, T2>;
+
 export {};