@bettergi/types 0.0.11 → 0.0.13

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

@@ -1,13 +1,20 @@
-export interface KeyValuePair<TKey, TValue> {
-  key: TKey;
+declare global {
+  namespace System.Collections.Generic {
+    class KeyValuePair<TKey, TValue> {
+      key: TKey;
 
-  value: TValue;
+      value: TValue;
 
-  create<TKey, TValue>(key: TKey, value: TValue): KeyValuePair<TKey, TValue>;
+      static create<TKey, TValue>(
+        key: TKey,
+        value: TValue
+      ): System.Collections.Generic.KeyValuePair<TKey, TValue>;
 
-  pairToString(key: any, value: any): string;
+      deconstruct(outKey: TKey, outValue: TValue): void;
 
-  toString(): string;
-
-  deconstruct(outKey: TKey, outValue: TValue): void;
+      constructor(key: TKey, value: TValue);
+    }
+  }
 }
+
+export {};

package/csharp/System/Collections/Generic/List.d.ts

@@ -1,78 +1,150 @@
-import { IEnumerable } from "./IEnumerable";
-import { IEnumerator } from "./IEnumerator";
-import { IList } from "./IList";
-import { IReadOnlyList } from "./IReadOnlyList";
-
-export interface List<T> extends IList<T>, IReadOnlyList<T> {
-  capacity: number;
-  count: number;
-  isReadOnly: boolean;
-  isFixedSize: boolean;
-  [index: number]: T;
-  add(item: T): void;
-  addRange(collection: IEnumerable<T>): void;
-  asReadOnly(): IReadOnlyList<T>;
-  /** @deprecated Not yet supported  */
-  binarySearch(item: T, comparer?: (a: T, b: T) => number): number;
-  /** @deprecated Not yet supported  */
-  binarySearch(index: number, count: number, item: T, comparer?: (a: T, b: T) => number): number;
-  clear(): void;
-  contains(item: T): boolean;
-  /** @deprecated Not yet supported  */
-  convertAll<TOutput>(converter: (item: T) => TOutput): List<TOutput>;
-  copyTo(array: T[]): void;
-  copyTo(array: T[], arrayIndex: number): void;
-  copyTo(index: number, array: T[], arrayIndex: number, count: number): void;
-  ensureCapacity(capacity: number): number;
-  /** @deprecated Not yet supported  */
-  exists(match: (item: T) => boolean): boolean;
-  /** @deprecated Not yet supported  */
-  find(match: (item: T) => boolean): T | null;
-  /** @deprecated Not yet supported  */
-  findAll(match: (item: T) => boolean): List<T>;
-  /** @deprecated Not yet supported  */
-  findIndex(match: (item: T) => boolean): number;
-  /** @deprecated Not yet supported  */
-  findIndex(startIndex: number, match: (item: T) => boolean): number;
-  /** @deprecated Not yet supported  */
-  findIndex(startIndex: number, count: number, match: (item: T) => boolean): number;
-  /** @deprecated Not yet supported  */
-  findLast(match: (item: T) => boolean): T | null;
-  /** @deprecated Not yet supported  */
-  findLastIndex(match: (item: T) => boolean): number;
-  /** @deprecated Not yet supported  */
-  findLastIndex(startIndex: number, match: (item: T) => boolean): number;
-  /** @deprecated Not yet supported  */
-  findLastIndex(startIndex: number, count: number, match: (item: T) => boolean): number;
-  /** @deprecated Not yet supported  */
-  forEach(action: (item: T) => void): void;
-  getEnumerator(): IEnumerator<T>;
-  getRange(index: number, count: number): List<T>;
-  indexOf(item: T): number;
-  indexOf(item: T, index: number): number;
-  indexOf(item: T, index: number, count: number): number;
-  insert(index: number, item: T): void;
-  insertRange(index: number, collection: IEnumerable<T>): void;
-  lastIndexOf(item: T): number;
-  lastIndexOf(item: T, index: number): number;
-  lastIndexOf(item: T, index: number, count: number): number;
-  remove(item: T): boolean;
-  /** @deprecated Not yet supported  */
-  removeAll(match: (item: T) => boolean): number;
-  removeAt(index: number): void;
-  removeRange(index: number, count: number): void;
-  reverse(): void;
-  reverse(index: number, count: number): void;
-  slice(start: number, length: number): List<T>;
-  sort(): void;
-  /** @deprecated Not yet supported  */
-  sort(comparer: (a: T, b: T) => number): void;
-  /** @deprecated Not yet supported  */
-  sort(index: number, count: number, comparer: (a: T, b: T) => number): void;
-  /** @deprecated Not yet supported  */
-  sort(comparison: (a: T, b: T) => number): void;
-  toArray(): T[];
-  trimExcess(): void;
-  /** @deprecated Not yet supported  */
-  trueForAll(match: (item: T) => boolean): boolean;
+import "./IEnumerable";
+import "./IEnumerator";
+import "./IList";
+import "./IReadOnlyList";
+
+declare global {
+  namespace System.Collections.Generic {
+    class List<T>
+      implements System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyList<T>
+    {
+      capacity: number;
+
+      count: number;
+
+      isReadOnly: boolean;
+
+      isFixedSize: boolean;
+
+      [index: number]: T;
+
+      add(item: T): void;
+
+      addRange(collection: System.Collections.Generic.IEnumerable<T>): void;
+
+      asReadOnly(): System.Collections.Generic.IReadOnlyList<T>;
+
+      /** @deprecated Not yet supported  */
+      binarySearch(item: T, comparer?: (a: T, b: T) => number): number;
+
+      /** @deprecated Not yet supported  */
+      binarySearch(
+        index: number,
+        count: number,
+        item: T,
+        comparer?: (a: T, b: T) => number
+      ): number;
+
+      clear(): void;
+
+      contains(item: T): boolean;
+
+      /** @deprecated Not yet supported  */
+      convertAll<TOutput>(
+        converter: (item: T) => TOutput
+      ): System.Collections.Generic.List<TOutput>;
+
+      copyTo(array: T[]): void;
+
+      copyTo(array: T[], arrayIndex: number): void;
+
+      copyTo(index: number, array: T[], arrayIndex: number, count: number): void;
+
+      ensureCapacity(capacity: number): number;
+
+      /** @deprecated Not yet supported  */
+      exists(match: (item: T) => boolean): boolean;
+
+      /** @deprecated Not yet supported  */
+      find(match: (item: T) => boolean): T | null;
+
+      /** @deprecated Not yet supported  */
+      findAll(match: (item: T) => boolean): System.Collections.Generic.List<T>;
+
+      /** @deprecated Not yet supported  */
+      findIndex(match: (item: T) => boolean): number;
+
+      /** @deprecated Not yet supported  */
+      findIndex(startIndex: number, match: (item: T) => boolean): number;
+
+      /** @deprecated Not yet supported  */
+      findIndex(startIndex: number, count: number, match: (item: T) => boolean): number;
+
+      /** @deprecated Not yet supported  */
+      findLast(match: (item: T) => boolean): T | null;
+
+      /** @deprecated Not yet supported  */
+      findLastIndex(match: (item: T) => boolean): number;
+
+      /** @deprecated Not yet supported  */
+      findLastIndex(startIndex: number, match: (item: T) => boolean): number;
+
+      /** @deprecated Not yet supported  */
+      findLastIndex(startIndex: number, count: number, match: (item: T) => boolean): number;
+
+      /** @deprecated Not yet supported  */
+      forEach(action: (item: T) => void): void;
+
+      getEnumerator(): System.Collections.Generic.IEnumerator<T>;
+
+      getRange(index: number, count: number): System.Collections.Generic.List<T>;
+
+      indexOf(item: T): number;
+
+      indexOf(item: T, index: number): number;
+
+      indexOf(item: T, index: number, count: number): number;
+
+      insert(index: number, item: T): void;
+
+      insertRange(index: number, collection: System.Collections.Generic.IEnumerable<T>): void;
+
+      lastIndexOf(item: T): number;
+
+      lastIndexOf(item: T, index: number): number;
+
+      lastIndexOf(item: T, index: number, count: number): number;
+
+      remove(item: T): boolean;
+
+      /** @deprecated Not yet supported  */
+      removeAll(match: (item: T) => boolean): number;
+
+      removeAt(index: number): void;
+
+      removeRange(index: number, count: number): void;
+
+      reverse(): void;
+
+      reverse(index: number, count: number): void;
+
+      slice(start: number, length: number): System.Collections.Generic.List<T>;
+
+      sort(): void;
+
+      /** @deprecated Not yet supported  */
+      sort(comparer: (a: T, b: T) => number): void;
+
+      /** @deprecated Not yet supported  */
+      sort(index: number, count: number, comparer: (a: T, b: T) => number): void;
+
+      /** @deprecated Not yet supported  */
+      sort(comparison: (a: T, b: T) => number): void;
+
+      toArray(): T[];
+
+      trimExcess(): void;
+
+      /** @deprecated Not yet supported  */
+      trueForAll(match: (item: T) => boolean): boolean;
+
+      constructor();
+
+      constructor(capacity: number);
+
+      constructor(collection: System.Collections.Generic.IEnumerable<T>);
+    }
+  }
 }
+
+export {};

package/csharp/System/Collections/ICollection.d.ts

@@ -0,0 +1,17 @@
+import "./IEnumerable";
+
+declare global {
+  namespace System.Collections {
+    interface ICollection extends System.Collections.IEnumerable {
+      copyTo(array: Array<any>, index: number): void;
+
+      count: number;
+
+      syncRoot: any;
+
+      isSynchronized: boolean;
+    }
+  }
+}
+
+export {};

package/csharp/System/Collections/IDictionary.d.ts

@@ -0,0 +1,29 @@
+import "./ICollection";
+import "./IDictionaryEnumerator";
+import "./IEnumerable";
+
+declare global {
+  namespace System.Collections {
+    interface IDictionary extends System.Collections.ICollection, System.Collections.IEnumerable {
+      keys: System.Collections.ICollection;
+
+      values: System.Collections.ICollection;
+
+      contains(key: any): boolean;
+
+      add(key: any, value: any): void;
+
+      clear(): void;
+
+      isReadOnly: boolean;
+
+      isFixedSize: boolean;
+
+      getEnumerator(): System.Collections.IDictionaryEnumerator;
+
+      remove(key: any): void;
+    }
+  }
+}
+
+export {};

package/csharp/System/Collections/IDictionaryEnumerator.d.ts

@@ -0,0 +1,14 @@
+import "../Collections/DictionaryEntry";
+import "./IEnumerator";
+
+declare global {
+  namespace System.Collections {
+    interface IDictionaryEnumerator extends System.Collections.IEnumerator {
+      key: any;
+      value: any;
+      entry: System.Collections.DictionaryEntry;
+    }
+  }
+}
+
+export {};

package/csharp/System/Collections/IEnumerable.d.ts

@@ -0,0 +1,9 @@
+declare global {
+  namespace System.Collections {
+    interface IEnumerable {
+      getEnumerator(): IEnumerator;
+    }
+  }
+}
+
+export {};

package/csharp/System/Collections/IEnumerator.d.ts

@@ -0,0 +1,13 @@
+declare global {
+  namespace System.Collections {
+    interface IEnumerator {
+      moveNext(): boolean;
+
+      current: any;
+
+      reset(): void;
+    }
+  }
+}
+
+export {};

package/csharp/System/Collections/IList.d.ts

@@ -0,0 +1,30 @@
+import "../Collections/IEnumerable";
+import "./ICollection";
+
+declare global {
+  namespace System.Collections {
+    interface IList extends System.Collections.ICollection, System.Collections.IEnumerable {
+      [index: number]: any;
+
+      add(item: any): number;
+
+      contains(item: any): boolean;
+
+      clear(): void;
+
+      isReadOnly: boolean;
+
+      isFixedSize: boolean;
+
+      indexOf(item: any): number;
+
+      insert(index: number, item: any): void;
+
+      remove(item: any): void;
+
+      removeAt(index: number): void;
+    }
+  }
+}
+
+export {};

package/csharp/System/DateTimeOffset.d.ts

@@ -0,0 +1,8 @@
+declare global {
+  namespace System {
+    class DateTimeOffset {
+      // TODO: 待补充（如果有必要）
+    }
+  }
+}
+export {};

package/csharp/System/Drawing/Bitmap.d.ts

@@ -1,3 +1,9 @@
-export interface Bitmap {
-  // TODO: Shims for System.Drawing.Bitmap
+import "./Image";
+
+declare global {
+  class Bitmap extends System.Drawing.Image {
+    // TODO: 待补充（如果有必要）
+  }
 }
+
+export {};