@bettergi/types 0.0.10 → 0.0.12

package/csharp/Microsoft/Extensions/Localization/IStringLocalizer.d.ts

@@ -0,0 +1,16 @@
+import "../../../System/Collections/Generic/IEnumerable";
+import "./LocalizedString";
+
+declare global {
+  namespace Microsoft.Extensions.Localization {
+    interface IStringLocalizer<T> {
+      [name: string]: Microsoft.Extensions.Localization.LocalizedString | ((...args: any[]) => any);
+
+      getAllStrings(
+        includeParentCultures: boolean
+      ): System.Collections.Generic.IEnumerable<Microsoft.Extensions.Localization.LocalizedString>;
+    }
+  }
+}
+
+export {};

package/csharp/Microsoft/Extensions/Localization/LocalizedString.d.ts

@@ -0,0 +1,26 @@
+declare global {
+  namespace Microsoft.Extensions.Localization {
+    class LocalizedString {
+      name: string;
+
+      value: string;
+
+      resourceNotFound: boolean;
+
+      searchedLocation: string | null;
+
+      constructor(name: string, value: string);
+
+      constructor(name: string, value: string, resourceNotFound: boolean);
+
+      constructor(
+        name: string,
+        value: string,
+        resourceNotFound: boolean,
+        searchedLocation: string | null
+      );
+    }
+  }
+}
+
+export {};

package/csharp/SixLabors/ImageSharp/Image.d.ts

@@ -0,0 +1,9 @@
+declare global {
+  namespace SixLabors.ImageSharp {
+    class Image {
+      // TODO: 待补充（如果有必要）
+    }
+  }
+}
+
+export {};

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

@@ -0,0 +1,14 @@
+declare global {
+  namespace System.Collections {
+    class DictionaryEntry {
+      key: any;
+      value: any;
+
+      deconstruct(): [any, any];
+
+      constructor(key: any, value: any);
+    }
+  }
+}
+
+export {};

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

@@ -1,55 +1,214 @@
-import { ICollection } from "./ICollection";
-import { IDictionary } from "./IDictionary";
-import { IEnumerable } from "./IEnumerable";
-import { IEnumerator } from "./IEnumerator";
-import { IEqualityComparer } from "./IEqualityComparer";
-import { IReadOnlyDictionary } from "./IReadOnlyDictionary";
-import { KeyValuePair } from "./KeyValuePair";
+import "../../Runtime/Serialization/IDeserializationCallback";
+import "../../Runtime/Serialization/ISerializable";
+import "../DictionaryEntry";
+import "../ICollection";
+import "../IDictionary";
+import "./DictionaryEnumerator";
+import "./ICollection";
+import "./IDictionary";
+import "./IEnumerable";
+import "./IEnumerator";
+import "./IEqualityComparer";
+import "./IReadOnlyCollection";
+import "./IReadOnlyDictionary";
+import "./KeyValuePair";
 
-export interface Dictionary<TKey, TValue>
-  extends IDictionary<TKey, TValue>,
-    IReadOnlyDictionary<TKey, TValue> {
-  comparer: IEqualityComparer<TKey>;
+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;
+      count: number;
 
-  keys: KeyCollection<TKey, TValue>;
+      keys: System.Collections.Generic.KeyCollection<TKey, TValue>;
 
-  values: ValueCollection<TKey, TValue>;
+      values: System.Collections.Generic.ValueCollection<TKey, TValue>;
 
-  add(item: KeyValuePair<TKey, TValue>): void;
+      add(item: System.Collections.Generic.KeyValuePair<TKey, TValue>): void;
 
-  // overload
-  add(key: TKey, value: TValue): void;
+      add(key: TKey, value: TValue): void;
 
-  clear(): void;
+      contains(item: System.Collections.Generic.KeyValuePair<TKey, TValue>): boolean;
 
-  containsKey(key: TKey): boolean;
+      remove(item: System.Collections.Generic.KeyValuePair<TKey, TValue>): boolean;
 
-  containsValue(value: TValue): boolean;
+      remove(key: TKey): boolean;
 
-  getEnumerator(): Enumerator<KeyValuePair<TKey, TValue>>;
+      remove(key: TKey, value: TValue | null): boolean;
 
-  remove(item: KeyValuePair<TKey, TValue>): boolean;
+      clear(): void;
 
-  // overload
-  remove(key: TKey): boolean;
+      containsKey(key: TKey): boolean;
 
-  remove(key: TKey, value: TValue | null): boolean;
+      containsValue(value: TValue): boolean;
 
-  tryGetValue(key: TKey, value: TValue | null): boolean;
+      getEnumerator(): System.Collections.Generic.DictionaryEnumerator<TKey, TValue>;
 
-  tryAdd(key: TKey, value: TValue): boolean;
+      onDeserialization(sender: any): void;
 
-  ensureCapacity(capacity: number): number;
+      tryGetValue(key: TKey, value: TValue | null): boolean;
 
-  trimExcess(): void;
+      tryAdd(key: TKey, value: TValue): boolean;
 
-  trimExcess(capacity: number): void;
-}
+      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;
 
-interface KeyCollection<TKey, TValue> extends ICollection<TKey>, IEnumerable<TKey> {}
+      isReadOnly: boolean;
 
-interface ValueCollection<TKey, TValue> extends ICollection<TValue>, IEnumerable<TValue> {}
+      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;
+
+        moveNext(): boolean;
+
+        current: TKey;
+
+        reset(): void;
+      }
+    }
+
+    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>;
+
+      copyTo(array: TValue[], index: number): void;
+
+      count: number;
+
+      isReadOnly: boolean;
+
+      add(item: TValue): void;
+
+      clear(): void;
+
+      contains(key: TValue): boolean;
+
+      remove(item: TValue): boolean;
+
+      isSynchronized: boolean;
+
+      syncRoot: any;
+
+      constructor(dictionary: System.Collections.Generic.Dictionary<TKey, TValue>);
+    }
+
+    namespace ValueCollection {
+      class Enumerator<TValue> implements System.Collections.Generic.IEnumerator<TValue> {
+        dispose(): void;
+
+        moveNext(): boolean;
+
+        current: TValue;
+
+        reset(): void;
+      }
+    }
+  }
+}
 
-interface Enumerator<T> extends IEnumerator<T> {}
+export {};

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

@@ -1,17 +1,23 @@
-import { IEnumerable } from "./IEnumerable";
+import "./IEnumerable";
 
-export interface ICollection<T> extends IEnumerable<T> {
-  count: number;
+declare global {
+  namespace System.Collections.Generic {
+    interface ICollection<T> extends System.Collections.Generic.IEnumerable<T> {
+      count: number;
 
-  isReadOnly: boolean;
+      isReadOnly: boolean;
 
-  add(item: T): void;
+      add(item: T): void;
 
-  clear(): void;
+      clear(): void;
 
-  contains(item: T): boolean;
+      contains(item: T): boolean;
 
-  copyTo(array: T[], arrayIndex: number): void;
+      copyTo(array: T[], arrayIndex: number): void;
 
-  remove(item: T): boolean;
+      remove(item: T): boolean;
+    }
+  }
 }
+
+export {};

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

@@ -1,23 +1,12 @@
-import { ICollection } from "./ICollection";
-import { IEnumerable } from "./IEnumerable";
-import { KeyValuePair } from "./KeyValuePair";
-
-export interface IDictionary<TKey, TValue> extends ICollection<KeyValuePair<TKey, TValue>> {
-  keys: ICollection<TKey>;
-
-  values: ICollection<TValue>;
-
-  containsKey(key: TKey): boolean;
-
-  add(item: KeyValuePair<TKey, TValue>): void;
-
-  // overload
-  add(key: TKey, value: TValue): void;
-
-  remove(item: KeyValuePair<TKey, TValue>): boolean;
-
-  // overload
-  remove(key: TKey): boolean;
-
-  tryGetValue(key: TKey, value: TValue | null): boolean;
+import "./ICollection";
+import "./IEnumerable";
+
+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>> {}
+  }
 }
+
+export {};

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

@@ -1,5 +1,12 @@
-import { IEnumerator } from "./IEnumerator";
+import "../../Collections/IEnumerable";
+import "./IEnumerator";
 
-export interface IEnumerable<T> {
-  getEnumerator(): IEnumerator<T>;
+declare global {
+  namespace System.Collections.Generic {
+    interface IEnumerable<T> extends System.Collections.IEnumerable {
+      getEnumerator(): System.Collections.Generic.IEnumerator<T>;
+    }
+  }
 }
+
+export {};

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

@@ -1,7 +1,12 @@
-export interface IEnumerator<T> {
-  moveNext(): boolean;
+import "../../Collections/IEnumerator";
+import "../../IDisposable";
 
-  current: T;
-
-  reset(): void;
+declare global {
+  namespace System.Collections.Generic {
+    interface IEnumerator<T> extends System.IDisposable, System.Collections.IEnumerator {
+      current: T;
+    }
+  }
 }
+
+export {};

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

@@ -1,5 +1,11 @@
-export interface IEqualityComparer<T> {
-  equals(x: T | null, y: T | null): boolean;
+declare global {
+  namespace System.Collections.Generic {
+    interface IEqualityComparer<T> {
+      equals(x: T | null, y: T | null): boolean;
 
-  getHashCode(obj: T): number;
+      getHashCode(obj: T): number;
+    }
+  }
 }
+
+export {};

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

@@ -1,13 +1,22 @@
-import { ICollection } from "./ICollection";
+import "./ICollection";
+import "./IEnumerable";
 
-export interface IList<T> extends ICollection<T> {
-  isFixedSize: boolean;
+declare global {
+  namespace System.Collections.Generic {
+    interface IList<T>
+      extends System.Collections.Generic.ICollection<T>,
+        System.Collections.Generic.IEnumerable<T> {
+      isFixedSize: boolean;
 
-  [index: number]: T;
+      [index: number]: T;
 
-  indexOf(item: T): number;
+      indexOf(item: T): number;
 
-  insert(index: number, item: T): void;
+      insert(index: number, item: T): void;
 
-  removeAt(index: number): void;
+      removeAt(index: number): void;
+    }
+  }
 }
+
+export {};

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

@@ -1,5 +1,11 @@
-import { IEnumerable } from "./IEnumerable";
+import "./IEnumerable";
 
-interface IReadOnlyCollection<T> extends IEnumerable<T> {
-  count: number;
+declare global {
+  namespace System.Collections.Generic {
+    interface IReadOnlyCollection<T> extends System.Collections.Generic.IEnumerable<T> {
+      count: number;
+    }
+  }
 }
+
+export {};

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

@@ -1,15 +1,20 @@
-import { IEnumerable } from "./IEnumerable";
-import { IReadOnlyCollection } from "./IReadOnlyCollection";
-import { KeyValuePair } from "./KeyValuePair";
+import "./IEnumerable";
+import "./IReadOnlyCollection";
 
-export interface IReadOnlyDictionary<TKey, TValue>
-  extends IReadOnlyCollection<KeyValuePair<TKey, TValue>>,
-    IEnumerable<KeyValuePair<TKey, TValue>> {
-  containsKey(key: TKey): boolean;
+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;
+      tryGetValue(key: TKey, value: TValue | null): boolean;
 
-  Keys: IEnumerable<TKey>;
+      keys: System.Collections.Generic.IEnumerable<TKey>;
 
-  Values: IEnumerable<TValue>;
+      values: System.Collections.Generic.IEnumerable<TValue>;
+    }
+  }
 }
+
+export {};

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

@@ -1,5 +1,11 @@
-import { IReadOnlyCollection } from "./IReadOnlyCollection";
+import "./IReadOnlyCollection";
 
-interface IReadOnlyList<T> extends IReadOnlyCollection<T> {
-  [index: number]: T;
+declare global {
+  namespace System.Collections.Generic {
+    interface IReadOnlyList<T> extends System.Collections.Generic.IReadOnlyCollection<T> {
+      [index: number]: T;
+    }
+  }
 }
+
+export {};

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 {};