@bettergi/types 0.1.12 → 0.1.14

package/types/System/Xml/XmlWriter.d.ts

@@ -0,0 +1,228 @@
+import type {
+  ByteHost,
+  CharHost,
+  ClrHostValue,
+  DecimalHost,
+  DoubleHost,
+  HostArray,
+  HostType,
+  Int32Host,
+  Int64Host,
+  ReferenceTypeTrait,
+  SingleHost,
+  StrongNumeric
+} from "../../Microsoft/ClearScript/HostType";
+import type { VoidResult } from "../../Microsoft/ClearScript/VoidResult";
+import "../DateTime";
+import "../DateTimeOffset";
+import "../IAsyncDisposable";
+import "../IDisposable";
+import "../IO/Stream";
+import "../IO/TextWriter";
+import "../Text/StringBuilder";
+import "../Threading/Tasks/ValueTask";
+import "./WriteState";
+import "./XPath/XPathNavigator";
+import "./XmlReader";
+import "./XmlSpace";
+import "./XmlWriterSettings";
+
+declare const xmlWriterBrand: unique symbol;
+export interface XmlWriter
+  extends ClrHostValue, System.IDisposableInput, System.IAsyncDisposableInput {
+  readonly [xmlWriterBrand]: true;
+  close(): VoidResult;
+  dispose(): VoidResult;
+  disposeAsync(): System.Threading.Tasks.ValueTask;
+  flush(): VoidResult;
+  flushAsync(): Promise<void>;
+  lookupPrefix(ns: string): string;
+  readonly settings: System.Xml.XmlWriterSettings;
+  readonly writeState: System.Xml.WriteState;
+  readonly xmlLang: string;
+  readonly xmlSpace: System.Xml.XmlSpace;
+  writeAttributeString(localName: string, ns: string | null, value: string | null): VoidResult;
+  writeAttributeString(localName: string, value: string | null): VoidResult;
+  writeAttributeString(
+    prefix: string | null,
+    localName: string,
+    ns: string | null,
+    value: string | null
+  ): VoidResult;
+  writeAttributeStringAsync(
+    prefix: string | null,
+    localName: string,
+    ns: string | null,
+    value: string | null
+  ): Promise<void>;
+  writeAttributes(reader: System.Xml.XmlReader, defattr: boolean): VoidResult;
+  writeAttributesAsync(reader: System.Xml.XmlReader, defattr: boolean): Promise<void>;
+  writeBase64(
+    buffer: HostArray<number | StrongNumeric<ByteHost>>,
+    index: number | StrongNumeric<Int32Host>,
+    count: number | StrongNumeric<Int32Host>
+  ): VoidResult;
+  writeBase64Async(
+    buffer: HostArray<number | StrongNumeric<ByteHost>>,
+    index: number | StrongNumeric<Int32Host>,
+    count: number | StrongNumeric<Int32Host>
+  ): Promise<void>;
+  writeBinHex(
+    buffer: HostArray<number | StrongNumeric<ByteHost>>,
+    index: number | StrongNumeric<Int32Host>,
+    count: number | StrongNumeric<Int32Host>
+  ): VoidResult;
+  writeBinHexAsync(
+    buffer: HostArray<number | StrongNumeric<ByteHost>>,
+    index: number | StrongNumeric<Int32Host>,
+    count: number | StrongNumeric<Int32Host>
+  ): Promise<void>;
+  writeCData(text: string | null): VoidResult;
+  writeCDataAsync(text: string | null): Promise<void>;
+  writeCharEntity(ch: number | StrongNumeric<CharHost>): VoidResult;
+  writeCharEntityAsync(ch: number | StrongNumeric<CharHost>): Promise<void>;
+  writeChars(
+    buffer: HostArray<number | StrongNumeric<CharHost>>,
+    index: number | StrongNumeric<Int32Host>,
+    count: number | StrongNumeric<Int32Host>
+  ): VoidResult;
+  writeCharsAsync(
+    buffer: HostArray<number | StrongNumeric<CharHost>>,
+    index: number | StrongNumeric<Int32Host>,
+    count: number | StrongNumeric<Int32Host>
+  ): Promise<void>;
+  writeComment(text: string | null): VoidResult;
+  writeCommentAsync(text: string | null): Promise<void>;
+  writeDocType(
+    name: string,
+    pubid: string | null,
+    sysid: string | null,
+    subset: string | null
+  ): VoidResult;
+  writeDocTypeAsync(
+    name: string,
+    pubid: string | null,
+    sysid: string | null,
+    subset: string | null
+  ): Promise<void>;
+  writeElementString(localName: string, ns: string | null, value: string | null): VoidResult;
+  writeElementString(localName: string, value: string | null): VoidResult;
+  writeElementString(
+    prefix: string | null,
+    localName: string,
+    ns: string | null,
+    value: string | null
+  ): VoidResult;
+  writeElementStringAsync(
+    prefix: string | null,
+    localName: string,
+    ns: string | null,
+    value: string
+  ): Promise<void>;
+  writeEndAttribute(): VoidResult;
+  writeEndDocument(): VoidResult;
+  writeEndDocumentAsync(): Promise<void>;
+  writeEndElement(): VoidResult;
+  writeEndElementAsync(): Promise<void>;
+  writeEntityRef(name: string): VoidResult;
+  writeEntityRefAsync(name: string): Promise<void>;
+  writeFullEndElement(): VoidResult;
+  writeFullEndElementAsync(): Promise<void>;
+  writeName(name: string): VoidResult;
+  writeNameAsync(name: string): Promise<void>;
+  writeNmToken(name: string): VoidResult;
+  writeNmTokenAsync(name: string): Promise<void>;
+  writeNode(navigator: System.Xml.XPath.XPathNavigator, defattr: boolean): VoidResult;
+  writeNode(reader: System.Xml.XmlReader, defattr: boolean): VoidResult;
+  writeNodeAsync(navigator: System.Xml.XPath.XPathNavigator, defattr: boolean): Promise<void>;
+  writeNodeAsync(reader: System.Xml.XmlReader, defattr: boolean): Promise<void>;
+  writeProcessingInstruction(name: string, text: string | null): VoidResult;
+  writeProcessingInstructionAsync(name: string, text: string | null): Promise<void>;
+  writeQualifiedName(localName: string, ns: string | null): VoidResult;
+  writeQualifiedNameAsync(localName: string, ns: string | null): Promise<void>;
+  writeRaw(
+    buffer: HostArray<number | StrongNumeric<CharHost>>,
+    index: number | StrongNumeric<Int32Host>,
+    count: number | StrongNumeric<Int32Host>
+  ): VoidResult;
+  writeRaw(data: string): VoidResult;
+  writeRawAsync(
+    buffer: HostArray<number | StrongNumeric<CharHost>>,
+    index: number | StrongNumeric<Int32Host>,
+    count: number | StrongNumeric<Int32Host>
+  ): Promise<void>;
+  writeRawAsync(data: string): Promise<void>;
+  writeStartAttribute(localName: string): VoidResult;
+  writeStartAttribute(localName: string, ns: string | null): VoidResult;
+  writeStartAttribute(prefix: string | null, localName: string, ns: string | null): VoidResult;
+  writeStartDocument(): VoidResult;
+  writeStartDocument(standalone: boolean): VoidResult;
+  writeStartDocumentAsync(): Promise<void>;
+  writeStartDocumentAsync(standalone: boolean): Promise<void>;
+  writeStartElement(localName: string): VoidResult;
+  writeStartElement(localName: string, ns: string | null): VoidResult;
+  writeStartElement(prefix: string | null, localName: string, ns: string | null): VoidResult;
+  writeStartElementAsync(
+    prefix: string | null,
+    localName: string,
+    ns: string | null
+  ): Promise<void>;
+  writeString(text: string | null): VoidResult;
+  writeStringAsync(text: string | null): Promise<void>;
+  writeSurrogateCharEntity(
+    lowChar: number | StrongNumeric<CharHost>,
+    highChar: number | StrongNumeric<CharHost>
+  ): VoidResult;
+  writeSurrogateCharEntityAsync(
+    lowChar: number | StrongNumeric<CharHost>,
+    highChar: number | StrongNumeric<CharHost>
+  ): Promise<void>;
+  writeValue(value: System.DateTime): VoidResult;
+  writeValue(value: System.DateTimeOffset): VoidResult;
+  writeValue(value: boolean): VoidResult;
+  writeValue(value: number | StrongNumeric<DecimalHost>): VoidResult;
+  writeValue(value: number | StrongNumeric<DoubleHost>): VoidResult;
+  writeValue(value: number | StrongNumeric<Int32Host>): VoidResult;
+  writeValue(value: number | StrongNumeric<Int64Host>): VoidResult;
+  writeValue(value: number | StrongNumeric<SingleHost>): VoidResult;
+  writeValue(value: string | null): VoidResult;
+  writeValue(value: unknown): VoidResult;
+  writeWhitespace(ws: string | null): VoidResult;
+  writeWhitespaceAsync(ws: string | null): Promise<void>;
+}
+
+declare global {
+  namespace System.Xml {
+    type XmlWriter = import("./XmlWriter").XmlWriter;
+  }
+}
+
+export interface XmlWriterHostType extends HostType<XmlWriter, ReferenceTypeTrait> {
+  create(outputFileName: string): System.Xml.XmlWriter;
+  create(
+    outputFileName: string,
+    settings: System.Xml.XmlWriterSettings | null
+  ): System.Xml.XmlWriter;
+  create(output: System.IO.Stream): System.Xml.XmlWriter;
+  create(
+    output: System.IO.Stream,
+    settings: System.Xml.XmlWriterSettings | null
+  ): System.Xml.XmlWriter;
+  create(output: System.IO.TextWriter): System.Xml.XmlWriter;
+  create(
+    output: System.IO.TextWriter,
+    settings: System.Xml.XmlWriterSettings | null
+  ): System.Xml.XmlWriter;
+  create(output: System.Text.StringBuilder): System.Xml.XmlWriter;
+  create(
+    output: System.Text.StringBuilder,
+    settings: System.Xml.XmlWriterSettings | null
+  ): System.Xml.XmlWriter;
+  create(output: System.Xml.XmlWriter): System.Xml.XmlWriter;
+  create(
+    output: System.Xml.XmlWriter,
+    settings: System.Xml.XmlWriterSettings | null
+  ): System.Xml.XmlWriter;
+}
+
+export {};

package/types/System/Xml/XmlWriterSettings.d.ts

@@ -0,0 +1,49 @@
+import type {
+  ClrHostValue,
+  HostType,
+  PublicDefaultConstructorTrait,
+  ReferenceTypeTrait
+} from "../../Microsoft/ClearScript/HostType";
+import type { VoidResult } from "../../Microsoft/ClearScript/VoidResult";
+import "../Text/Encoding";
+import "./ConformanceLevel";
+import "./NamespaceHandling";
+import "./NewLineHandling";
+import "./XmlOutputMethod";
+
+declare const xmlWriterSettingsBrand: unique symbol;
+export interface XmlWriterSettings extends ClrHostValue {
+  readonly [xmlWriterSettingsBrand]: true;
+  async: boolean;
+  checkCharacters: boolean;
+  clone(): System.Xml.XmlWriterSettings;
+  closeOutput: boolean;
+  conformanceLevel: System.Xml.ConformanceLevel;
+  doNotEscapeUriAttributes: boolean;
+  encoding: System.Text.Encoding;
+  indent: boolean;
+  indentChars: string;
+  namespaceHandling: System.Xml.NamespaceHandling;
+  newLineChars: string;
+  newLineHandling: System.Xml.NewLineHandling;
+  newLineOnAttributes: boolean;
+  omitXmlDeclaration: boolean;
+  readonly outputMethod: System.Xml.XmlOutputMethod;
+  reset(): VoidResult;
+  writeEndDocumentOnClose: boolean;
+}
+
+declare global {
+  namespace System.Xml {
+    type XmlWriterSettings = import("./XmlWriterSettings").XmlWriterSettings;
+  }
+}
+
+export interface XmlWriterSettingsHostType extends HostType<
+  XmlWriterSettings,
+  ReferenceTypeTrait & PublicDefaultConstructorTrait
+> {
+  new (): XmlWriterSettings;
+}
+
+export {};

package/types/Vanara/PInvoke/POINT.d.ts

@@ -0,0 +1,42 @@
+import type {
+  ClrHostValue,
+  HostType,
+  Int32Host,
+  StrongNumeric,
+  ValueTypeTrait
+} from "../../Microsoft/ClearScript/HostType";
+import type { VoidResult } from "../../Microsoft/ClearScript/VoidResult";
+import "../../System/IEquatable";
+import "../../System/ValueType";
+import "./SIZE";
+
+declare const pOINTBrand: unique symbol;
+export interface POINT extends ClrHostValue {
+  readonly [pOINTBrand]: true;
+  equals(obj: unknown | null): boolean;
+  equals(other: Vanara.PInvoke.POINT): boolean;
+  getHashCode(): number;
+  offset(dx: number | StrongNumeric<Int32Host>, dy: number | StrongNumeric<Int32Host>): VoidResult;
+  offset(p: Vanara.PInvoke.POINT): VoidResult;
+  readonly isEmpty: boolean;
+  toString(): string;
+  x: number;
+  y: number;
+}
+
+declare global {
+  namespace Vanara.PInvoke {
+    type POINT = import("./POINT").POINT;
+  }
+}
+
+export interface POINTHostType extends HostType<POINT, ValueTypeTrait> {
+  new (x: number | StrongNumeric<Int32Host>, y: number | StrongNumeric<Int32Host>): POINT;
+  new (sz: Vanara.PInvoke.SIZE): POINT;
+  new (dw: number | StrongNumeric<Int32Host>): POINT;
+  readonly empty: Vanara.PInvoke.POINT;
+  add(pt: Vanara.PInvoke.POINT, sz: Vanara.PInvoke.SIZE): Vanara.PInvoke.POINT;
+  subtract(pt: Vanara.PInvoke.POINT, sz: Vanara.PInvoke.SIZE): Vanara.PInvoke.POINT;
+}
+
+export {};

package/types/Vanara/PInvoke/PRECT.d.ts

@@ -0,0 +1,61 @@
+import type {
+  ClrHostValue,
+  HostType,
+  Int32Host,
+  PublicDefaultConstructorTrait,
+  ReferenceTypeTrait,
+  StrongNumeric
+} from "../../Microsoft/ClearScript/HostType";
+import "../../System/Drawing/Rectangle";
+import "../../System/IEquatable";
+import "./POINT";
+import "./RECT";
+import "./SIZE";
+
+declare const pRECTBrand: unique symbol;
+export interface PRECT
+  extends
+    ClrHostValue,
+    System.IEquatableInput<Vanara.PInvoke.RECT>,
+    System.IEquatableInput<System.Drawing.Rectangle> {
+  readonly [pRECTBrand]: true;
+  bottom: number;
+  equals(obj: unknown | null): boolean;
+  equals(r: System.Drawing.Rectangle): boolean;
+  equals(r: Vanara.PInvoke.PRECT | null): boolean;
+  equals(r: Vanara.PInvoke.RECT): boolean;
+  getHashCode(): number;
+  height: number;
+  left: number;
+  location: Vanara.PInvoke.POINT;
+  readonly isEmpty: boolean;
+  right: number;
+  size: Vanara.PInvoke.SIZE;
+  toString(): string;
+  top: number;
+  width: number;
+  x: number;
+  y: number;
+}
+
+declare global {
+  namespace Vanara.PInvoke {
+    type PRECT = import("./PRECT").PRECT;
+  }
+}
+
+export interface PRECTHostType extends HostType<
+  PRECT,
+  ReferenceTypeTrait & PublicDefaultConstructorTrait
+> {
+  new (): PRECT;
+  new (
+    left: number | StrongNumeric<Int32Host>,
+    top: number | StrongNumeric<Int32Host>,
+    right: number | StrongNumeric<Int32Host>,
+    bottom: number | StrongNumeric<Int32Host>
+  ): PRECT;
+  new (r: System.Drawing.Rectangle): PRECT;
+}
+
+export {};

package/types/Vanara/PInvoke/RECT.d.ts

@@ -0,0 +1,58 @@
+import type {
+  ClrHostValue,
+  HostType,
+  Int32Host,
+  StrongNumeric,
+  ValueTypeTrait
+} from "../../Microsoft/ClearScript/HostType";
+import "../../System/Drawing/Rectangle";
+import "../../System/IEquatable";
+import "../../System/ValueType";
+import "./POINT";
+import "./PRECT";
+import "./SIZE";
+
+declare const rECTBrand: unique symbol;
+export interface RECT
+  extends
+    ClrHostValue,
+    System.IEquatableInput<Vanara.PInvoke.PRECT>,
+    System.IEquatableInput<System.Drawing.Rectangle> {
+  readonly [rECTBrand]: true;
+  bottom: number;
+  equals(obj: unknown | null): boolean;
+  equals(r: System.Drawing.Rectangle): boolean;
+  equals(r: Vanara.PInvoke.PRECT | null): boolean;
+  equals(r: Vanara.PInvoke.RECT): boolean;
+  getHashCode(): number;
+  height: number;
+  left: number;
+  location: Vanara.PInvoke.POINT;
+  readonly isEmpty: boolean;
+  right: number;
+  size: Vanara.PInvoke.SIZE;
+  toString(): string;
+  top: number;
+  width: number;
+  x: number;
+  y: number;
+}
+
+declare global {
+  namespace Vanara.PInvoke {
+    type RECT = import("./RECT").RECT;
+  }
+}
+
+export interface RECTHostType extends HostType<RECT, ValueTypeTrait> {
+  new (
+    left: number | StrongNumeric<Int32Host>,
+    top: number | StrongNumeric<Int32Host>,
+    right: number | StrongNumeric<Int32Host>,
+    bottom: number | StrongNumeric<Int32Host>
+  ): RECT;
+  new (r: System.Drawing.Rectangle): RECT;
+  readonly empty: Vanara.PInvoke.RECT;
+}
+
+export {};

package/types/Vanara/PInvoke/SIZE.d.ts

@@ -0,0 +1,38 @@
+import type {
+  ClrHostValue,
+  HostType,
+  Int32Host,
+  StrongNumeric,
+  ValueTypeTrait
+} from "../../Microsoft/ClearScript/HostType";
+import "../../System/Drawing/Size";
+import "../../System/IEquatable";
+import "../../System/ValueType";
+
+declare const sIZEBrand: unique symbol;
+export interface SIZE extends ClrHostValue {
+  readonly [sIZEBrand]: true;
+  cx: number;
+  cy: number;
+  equals(obj: unknown | null): boolean;
+  equals(other: Vanara.PInvoke.SIZE): boolean;
+  getHashCode(): number;
+  height: number;
+  readonly isEmpty: boolean;
+  toSize(): System.Drawing.Size;
+  toString(): string;
+  width: number;
+}
+
+declare global {
+  namespace Vanara.PInvoke {
+    type SIZE = import("./SIZE").SIZE;
+  }
+}
+
+export interface SIZEHostType extends HostType<SIZE, ValueTypeTrait> {
+  new (width: number | StrongNumeric<Int32Host>, height: number | StrongNumeric<Int32Host>): SIZE;
+  readonly empty: Vanara.PInvoke.SIZE;
+}
+
+export {};