@tsonic/dotnet-pure/System.Data.SqlTypes/internal/index.d.ts

TypeScript type definitions for .NET 10 BCL (Base Class Library) - CLR naming

// Generated by tsbindgen - Architecture
// Namespace: System.Data.SqlTypes
// Assembly: System.Data.Common

// Branded primitive types are sourced from @tsonic/types
import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/types';

// Import types from other namespaces
import type { IDictionary } from "../../System.Collections/internal/index.js";
import type { CompareInfo, CompareOptions, CultureInfo } from "../../System.Globalization/internal/index.js";
import type { Stream } from "../../System.IO/internal/index.js";
import type { MethodBase } from "../../System.Reflection/internal/index.js";
import * as System_Runtime_Serialization_Internal from "../../System.Runtime.Serialization/internal/index.js";
import type { ISerializable, SerializationInfo, StreamingContext } from "../../System.Runtime.Serialization/internal/index.js";
import type { XmlSchema, XmlSchemaSet } from "../../System.Xml.Schema/internal/index.js";
import * as System_Xml_Serialization_Internal from "../../System.Xml.Serialization/internal/index.js";
import type { IXmlSerializable } from "../../System.Xml.Serialization/internal/index.js";
import type { XmlQualifiedName, XmlReader, XmlWriter } from "../../System.Xml/internal/index.js";
import * as System_Internal from "../../System/internal/index.js";
import type { Boolean as ClrBoolean, Byte, Char, DateTime, Decimal, Double, Enum, Exception, Guid, IComparable, IConvertible, IEquatable_1, IFormatProvider, IFormattable, Int16, Int32, Int64, ISpanFormattable, Object as ClrObject, Single, Span_1, String as ClrString, SystemException, TimeSpan, Type, TypeCode, UInt32, ValueType, Void } from "../../System/internal/index.js";

// CLROf<T> - Maps ergonomic primitives to their CLR types for generic constraints
// This utility is used ONLY in generic type arguments to satisfy CLR interface constraints
// Value positions (parameters, return types) use lowercase primitives for ergonomics
export type CLROf<T> =
    T extends sbyte ? System_Internal.SByte :
    T extends short ? System_Internal.Int16 :
    T extends int ? System_Internal.Int32 :
    T extends long ? System_Internal.Int64 :
    T extends int128 ? System_Internal.Int128 :
    T extends nint ? System_Internal.IntPtr :
    T extends byte ? System_Internal.Byte :
    T extends ushort ? System_Internal.UInt16 :
    T extends uint ? System_Internal.UInt32 :
    T extends ulong ? System_Internal.UInt64 :
    T extends uint128 ? System_Internal.UInt128 :
    T extends nuint ? System_Internal.UIntPtr :
    T extends half ? System_Internal.Half :
    T extends float ? System_Internal.Single :
    T extends double ? System_Internal.Double :
    T extends decimal ? System_Internal.Decimal :
    T extends char ? System_Internal.Char :
    T extends boolean ? System_Internal.Boolean :
    T extends string ? System_Internal.String :
    T; // Identity fallback for non-primitive types

export enum SqlCompareOptions {
    None = 0,
    IgnoreCase = 1,
    IgnoreNonSpace = 2,
    IgnoreKanaType = 8,
    IgnoreWidth = 16,
    BinarySort = 32768,
    BinarySort2 = 16384
}


export enum StorageState {
    Buffer = 0,
    Stream = 1,
    UnmanagedBuffer = 2
}


export interface INullable$instance {
    readonly IsNull: boolean;
}


export type INullable = INullable$instance;

export interface SqlBinary$instance {
    readonly IsNull: boolean;
    readonly Item: byte;
    readonly Length: int;
    readonly Value: byte[];
    CompareTo(value: unknown): int;
    CompareTo(value: SqlBinary): int;
    Equals(value: unknown): boolean;
    Equals(other: SqlBinary): boolean;
    GetHashCode(): int;
    ToSqlGuid(): SqlGuid;
    ToString(): string;
}


export const SqlBinary: {
    new(value: byte[]): SqlBinary$instance;
    readonly Null: SqlBinary;
    Add(x: SqlBinary, y: SqlBinary): SqlBinary;
    Concat(x: SqlBinary, y: SqlBinary): SqlBinary;
    Equals(x: SqlBinary, y: SqlBinary): SqlBoolean;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
    GreaterThan(x: SqlBinary, y: SqlBinary): SqlBoolean;
    GreaterThanOrEqual(x: SqlBinary, y: SqlBinary): SqlBoolean;
    LessThan(x: SqlBinary, y: SqlBinary): SqlBoolean;
    LessThanOrEqual(x: SqlBinary, y: SqlBinary): SqlBoolean;
    NotEquals(x: SqlBinary, y: SqlBinary): SqlBoolean;
    WrapBytes(bytes: byte[]): SqlBinary;
};


export interface __SqlBinary$views {
    As_INullable(): INullable$instance;
    As_IComparable(): System_Internal.IComparable$instance;
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<SqlBinary>;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;

    // Structural method bridges for numeric interface constraints
    Equals(other: SqlBinary): boolean;
    CompareTo(obj: unknown): int;
}

export interface SqlBinary$instance extends INullable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlBinary = SqlBinary$instance & __SqlBinary$views;


export interface SqlBoolean$instance {
    readonly ByteValue: byte;
    readonly IsFalse: boolean;
    readonly IsNull: boolean;
    readonly IsTrue: boolean;
    readonly Value: boolean;
    CompareTo(value: unknown): int;
    CompareTo(value: SqlBoolean): int;
    Equals(value: unknown): boolean;
    Equals(other: SqlBoolean): boolean;
    GetHashCode(): int;
    ToSqlByte(): SqlByte;
    ToSqlDecimal(): SqlDecimal;
    ToSqlDouble(): SqlDouble;
    ToSqlInt16(): SqlInt16;
    ToSqlInt32(): SqlInt32;
    ToSqlInt64(): SqlInt64;
    ToSqlMoney(): SqlMoney;
    ToSqlSingle(): SqlSingle;
    ToSqlString(): SqlString;
    ToString(): string;
}


export const SqlBoolean: {
    new(value: boolean): SqlBoolean$instance;
    new(value: int): SqlBoolean$instance;
    readonly True: SqlBoolean;
    readonly False: SqlBoolean;
    readonly Null: SqlBoolean;
    readonly Zero: SqlBoolean;
    readonly One: SqlBoolean;
    And(x: SqlBoolean, y: SqlBoolean): SqlBoolean;
    Equals(x: SqlBoolean, y: SqlBoolean): SqlBoolean;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
    GreaterThan(x: SqlBoolean, y: SqlBoolean): SqlBoolean;
    GreaterThanOrEquals(x: SqlBoolean, y: SqlBoolean): SqlBoolean;
    LessThan(x: SqlBoolean, y: SqlBoolean): SqlBoolean;
    LessThanOrEquals(x: SqlBoolean, y: SqlBoolean): SqlBoolean;
    NotEquals(x: SqlBoolean, y: SqlBoolean): SqlBoolean;
    OnesComplement(x: SqlBoolean): SqlBoolean;
    Or(x: SqlBoolean, y: SqlBoolean): SqlBoolean;
    Parse(s: string): SqlBoolean;
    Xor(x: SqlBoolean, y: SqlBoolean): SqlBoolean;
};


export interface __SqlBoolean$views {
    As_INullable(): INullable$instance;
    As_IComparable(): System_Internal.IComparable$instance;
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<SqlBoolean>;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;

    // Structural method bridges for numeric interface constraints
    Equals(other: SqlBoolean): boolean;
    CompareTo(obj: unknown): int;
}

export interface SqlBoolean$instance extends INullable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlBoolean = SqlBoolean$instance & __SqlBoolean$views;


export interface SqlByte$instance {
    readonly IsNull: boolean;
    readonly Value: byte;
    CompareTo(value: unknown): int;
    CompareTo(value: SqlByte): int;
    Equals(value: unknown): boolean;
    Equals(other: SqlByte): boolean;
    GetHashCode(): int;
    ToSqlBoolean(): SqlBoolean;
    ToSqlDecimal(): SqlDecimal;
    ToSqlDouble(): SqlDouble;
    ToSqlInt16(): SqlInt16;
    ToSqlInt32(): SqlInt32;
    ToSqlInt64(): SqlInt64;
    ToSqlMoney(): SqlMoney;
    ToSqlSingle(): SqlSingle;
    ToSqlString(): SqlString;
    ToString(): string;
}


export const SqlByte: {
    new(value: byte): SqlByte$instance;
    readonly Null: SqlByte;
    readonly Zero: SqlByte;
    readonly MinValue: SqlByte;
    readonly MaxValue: SqlByte;
    Add(x: SqlByte, y: SqlByte): SqlByte;
    BitwiseAnd(x: SqlByte, y: SqlByte): SqlByte;
    BitwiseOr(x: SqlByte, y: SqlByte): SqlByte;
    Divide(x: SqlByte, y: SqlByte): SqlByte;
    Equals(x: SqlByte, y: SqlByte): SqlBoolean;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
    GreaterThan(x: SqlByte, y: SqlByte): SqlBoolean;
    GreaterThanOrEqual(x: SqlByte, y: SqlByte): SqlBoolean;
    LessThan(x: SqlByte, y: SqlByte): SqlBoolean;
    LessThanOrEqual(x: SqlByte, y: SqlByte): SqlBoolean;
    Mod(x: SqlByte, y: SqlByte): SqlByte;
    Modulus(x: SqlByte, y: SqlByte): SqlByte;
    Multiply(x: SqlByte, y: SqlByte): SqlByte;
    NotEquals(x: SqlByte, y: SqlByte): SqlBoolean;
    OnesComplement(x: SqlByte): SqlByte;
    Parse(s: string): SqlByte;
    Subtract(x: SqlByte, y: SqlByte): SqlByte;
    Xor(x: SqlByte, y: SqlByte): SqlByte;
};


export interface __SqlByte$views {
    As_INullable(): INullable$instance;
    As_IComparable(): System_Internal.IComparable$instance;
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<SqlByte>;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;

    // Structural method bridges for numeric interface constraints
    Equals(other: SqlByte): boolean;
    CompareTo(obj: unknown): int;
}

export interface SqlByte$instance extends INullable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlByte = SqlByte$instance & __SqlByte$views;


export interface SqlDateTime$instance {
    readonly DayTicks: int;
    readonly IsNull: boolean;
    readonly TimeTicks: int;
    readonly Value: DateTime;
    CompareTo(value: unknown): int;
    CompareTo(value: SqlDateTime): int;
    Equals(value: unknown): boolean;
    Equals(other: SqlDateTime): boolean;
    GetHashCode(): int;
    ToSqlString(): SqlString;
    ToString(): string;
}


export const SqlDateTime: {
    new(value: DateTime): SqlDateTime$instance;
    new(year: int, month: int, day: int): SqlDateTime$instance;
    new(year: int, month: int, day: int, hour: int, minute: int, second: int): SqlDateTime$instance;
    new(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: double): SqlDateTime$instance;
    new(year: int, month: int, day: int, hour: int, minute: int, second: int, bilisecond: int): SqlDateTime$instance;
    new(dayTicks: int, timeTicks: int): SqlDateTime$instance;
    readonly SQLTicksPerSecond: int;
    readonly SQLTicksPerMinute: int;
    readonly SQLTicksPerHour: int;
    readonly MinValue: SqlDateTime;
    readonly MaxValue: SqlDateTime;
    readonly Null: SqlDateTime;
    Add(x: SqlDateTime, t: TimeSpan): SqlDateTime;
    Equals(x: SqlDateTime, y: SqlDateTime): SqlBoolean;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
    GreaterThan(x: SqlDateTime, y: SqlDateTime): SqlBoolean;
    GreaterThanOrEqual(x: SqlDateTime, y: SqlDateTime): SqlBoolean;
    LessThan(x: SqlDateTime, y: SqlDateTime): SqlBoolean;
    LessThanOrEqual(x: SqlDateTime, y: SqlDateTime): SqlBoolean;
    NotEquals(x: SqlDateTime, y: SqlDateTime): SqlBoolean;
    Parse(s: string): SqlDateTime;
    Subtract(x: SqlDateTime, t: TimeSpan): SqlDateTime;
};


export interface __SqlDateTime$views {
    As_INullable(): INullable$instance;
    As_IComparable(): System_Internal.IComparable$instance;
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<SqlDateTime>;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;

    // Structural method bridges for numeric interface constraints
    Equals(other: SqlDateTime): boolean;
    CompareTo(obj: unknown): int;
}

export interface SqlDateTime$instance extends INullable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlDateTime = SqlDateTime$instance & __SqlDateTime$views;


export interface SqlDecimal$instance {
    readonly BinData: byte[];
    readonly Data: int[];
    readonly IsNull: boolean;
    readonly IsPositive: boolean;
    readonly Precision: byte;
    readonly Scale: byte;
    readonly Value: decimal;
    CompareTo(value: unknown): int;
    CompareTo(value: SqlDecimal): int;
    Equals(value: unknown): boolean;
    Equals(other: SqlDecimal): boolean;
    GetHashCode(): int;
    ToDouble(): double;
    ToSqlBoolean(): SqlBoolean;
    ToSqlByte(): SqlByte;
    ToSqlDouble(): SqlDouble;
    ToSqlInt16(): SqlInt16;
    ToSqlInt32(): SqlInt32;
    ToSqlInt64(): SqlInt64;
    ToSqlMoney(): SqlMoney;
    ToSqlSingle(): SqlSingle;
    ToSqlString(): SqlString;
    ToString(): string;
    WriteTdsValue(destination: Span_1<CLROf<uint>>): int;
}


export const SqlDecimal: {
    new(value: decimal): SqlDecimal$instance;
    new(value: int): SqlDecimal$instance;
    new(value: long): SqlDecimal$instance;
    new(bPrecision: byte, bScale: byte, fPositive: boolean, bits: int[]): SqlDecimal$instance;
    new(bPrecision: byte, bScale: byte, fPositive: boolean, data1: int, data2: int, data3: int, data4: int): SqlDecimal$instance;
    new(dVal: double): SqlDecimal$instance;
    readonly MaxPrecision: byte;
    readonly MaxScale: byte;
    readonly Null: SqlDecimal;
    readonly MinValue: SqlDecimal;
    readonly MaxValue: SqlDecimal;
    Abs(n: SqlDecimal): SqlDecimal;
    Add(x: SqlDecimal, y: SqlDecimal): SqlDecimal;
    AdjustScale(n: SqlDecimal, digits: int, fRound: boolean): SqlDecimal;
    Ceiling(n: SqlDecimal): SqlDecimal;
    ConvertToPrecScale(n: SqlDecimal, precision: int, scale: int): SqlDecimal;
    Divide(x: SqlDecimal, y: SqlDecimal): SqlDecimal;
    Equals(x: SqlDecimal, y: SqlDecimal): SqlBoolean;
    Floor(n: SqlDecimal): SqlDecimal;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
    GreaterThan(x: SqlDecimal, y: SqlDecimal): SqlBoolean;
    GreaterThanOrEqual(x: SqlDecimal, y: SqlDecimal): SqlBoolean;
    LessThan(x: SqlDecimal, y: SqlDecimal): SqlBoolean;
    LessThanOrEqual(x: SqlDecimal, y: SqlDecimal): SqlBoolean;
    Multiply(x: SqlDecimal, y: SqlDecimal): SqlDecimal;
    NotEquals(x: SqlDecimal, y: SqlDecimal): SqlBoolean;
    Parse(s: string): SqlDecimal;
    Power(n: SqlDecimal, exp: double): SqlDecimal;
    Round(n: SqlDecimal, position: int): SqlDecimal;
    Sign(n: SqlDecimal): SqlInt32;
    Subtract(x: SqlDecimal, y: SqlDecimal): SqlDecimal;
    Truncate(n: SqlDecimal, position: int): SqlDecimal;
};


export interface __SqlDecimal$views {
    As_INullable(): INullable$instance;
    As_IComparable(): System_Internal.IComparable$instance;
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<SqlDecimal>;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;

    // Structural method bridges for numeric interface constraints
    Equals(other: SqlDecimal): boolean;
    CompareTo(obj: unknown): int;
}

export interface SqlDecimal$instance extends INullable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlDecimal = SqlDecimal$instance & __SqlDecimal$views;


export interface SqlDouble$instance {
    readonly IsNull: boolean;
    readonly Value: double;
    CompareTo(value: unknown): int;
    CompareTo(value: SqlDouble): int;
    Equals(value: unknown): boolean;
    Equals(other: SqlDouble): boolean;
    GetHashCode(): int;
    ToSqlBoolean(): SqlBoolean;
    ToSqlByte(): SqlByte;
    ToSqlDecimal(): SqlDecimal;
    ToSqlInt16(): SqlInt16;
    ToSqlInt32(): SqlInt32;
    ToSqlInt64(): SqlInt64;
    ToSqlMoney(): SqlMoney;
    ToSqlSingle(): SqlSingle;
    ToSqlString(): SqlString;
    ToString(): string;
}


export const SqlDouble: {
    new(value: double): SqlDouble$instance;
    readonly Null: SqlDouble;
    readonly Zero: SqlDouble;
    readonly MinValue: SqlDouble;
    readonly MaxValue: SqlDouble;
    Add(x: SqlDouble, y: SqlDouble): SqlDouble;
    Divide(x: SqlDouble, y: SqlDouble): SqlDouble;
    Equals(x: SqlDouble, y: SqlDouble): SqlBoolean;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
    GreaterThan(x: SqlDouble, y: SqlDouble): SqlBoolean;
    GreaterThanOrEqual(x: SqlDouble, y: SqlDouble): SqlBoolean;
    LessThan(x: SqlDouble, y: SqlDouble): SqlBoolean;
    LessThanOrEqual(x: SqlDouble, y: SqlDouble): SqlBoolean;
    Multiply(x: SqlDouble, y: SqlDouble): SqlDouble;
    NotEquals(x: SqlDouble, y: SqlDouble): SqlBoolean;
    Parse(s: string): SqlDouble;
    Subtract(x: SqlDouble, y: SqlDouble): SqlDouble;
};


export interface __SqlDouble$views {
    As_INullable(): INullable$instance;
    As_IComparable(): System_Internal.IComparable$instance;
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<SqlDouble>;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;

    // Structural method bridges for numeric interface constraints
    Equals(other: SqlDouble): boolean;
    CompareTo(obj: unknown): int;
}

export interface SqlDouble$instance extends INullable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlDouble = SqlDouble$instance & __SqlDouble$views;


export interface SqlGuid$instance {
    readonly IsNull: boolean;
    readonly Value: Guid;
    CompareTo(value: unknown): int;
    CompareTo(value: SqlGuid): int;
    Equals(value: unknown): boolean;
    Equals(other: SqlGuid): boolean;
    GetHashCode(): int;
    ToByteArray(): byte[];
    ToSqlBinary(): SqlBinary;
    ToSqlString(): SqlString;
    ToString(): string;
}


export const SqlGuid: {
    new(value: byte[]): SqlGuid$instance;
    new(s: string): SqlGuid$instance;
    new(g: Guid): SqlGuid$instance;
    new(a: int, b: short, c: short, d: byte, e: byte, f: byte, g: byte, h: byte, i: byte, j: byte, k: byte): SqlGuid$instance;
    readonly Null: SqlGuid;
    Equals(x: SqlGuid, y: SqlGuid): SqlBoolean;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
    GreaterThan(x: SqlGuid, y: SqlGuid): SqlBoolean;
    GreaterThanOrEqual(x: SqlGuid, y: SqlGuid): SqlBoolean;
    LessThan(x: SqlGuid, y: SqlGuid): SqlBoolean;
    LessThanOrEqual(x: SqlGuid, y: SqlGuid): SqlBoolean;
    NotEquals(x: SqlGuid, y: SqlGuid): SqlBoolean;
    Parse(s: string): SqlGuid;
};


export interface __SqlGuid$views {
    As_INullable(): INullable$instance;
    As_IComparable(): System_Internal.IComparable$instance;
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<SqlGuid>;
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;

    // Structural method bridges for numeric interface constraints
    Equals(other: SqlGuid): boolean;
    CompareTo(obj: unknown): int;
}

export interface SqlGuid$instance extends INullable$instance, System_Runtime_Serialization_Internal.ISerializable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlGuid = SqlGuid$instance & __SqlGuid$views;


export interface SqlInt16$instance {
    readonly IsNull: boolean;
    readonly Value: short;
    CompareTo(value: unknown): int;
    CompareTo(value: SqlInt16): int;
    Equals(value: unknown): boolean;
    Equals(other: SqlInt16): boolean;
    GetHashCode(): int;
    ToSqlBoolean(): SqlBoolean;
    ToSqlByte(): SqlByte;
    ToSqlDecimal(): SqlDecimal;
    ToSqlDouble(): SqlDouble;
    ToSqlInt32(): SqlInt32;
    ToSqlInt64(): SqlInt64;
    ToSqlMoney(): SqlMoney;
    ToSqlSingle(): SqlSingle;
    ToSqlString(): SqlString;
    ToString(): string;
}


export const SqlInt16: {
    new(value: short): SqlInt16$instance;
    readonly Null: SqlInt16;
    readonly Zero: SqlInt16;
    readonly MinValue: SqlInt16;
    readonly MaxValue: SqlInt16;
    Add(x: SqlInt16, y: SqlInt16): SqlInt16;
    BitwiseAnd(x: SqlInt16, y: SqlInt16): SqlInt16;
    BitwiseOr(x: SqlInt16, y: SqlInt16): SqlInt16;
    Divide(x: SqlInt16, y: SqlInt16): SqlInt16;
    Equals(x: SqlInt16, y: SqlInt16): SqlBoolean;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
    GreaterThan(x: SqlInt16, y: SqlInt16): SqlBoolean;
    GreaterThanOrEqual(x: SqlInt16, y: SqlInt16): SqlBoolean;
    LessThan(x: SqlInt16, y: SqlInt16): SqlBoolean;
    LessThanOrEqual(x: SqlInt16, y: SqlInt16): SqlBoolean;
    Mod(x: SqlInt16, y: SqlInt16): SqlInt16;
    Modulus(x: SqlInt16, y: SqlInt16): SqlInt16;
    Multiply(x: SqlInt16, y: SqlInt16): SqlInt16;
    NotEquals(x: SqlInt16, y: SqlInt16): SqlBoolean;
    OnesComplement(x: SqlInt16): SqlInt16;
    Parse(s: string): SqlInt16;
    Subtract(x: SqlInt16, y: SqlInt16): SqlInt16;
    Xor(x: SqlInt16, y: SqlInt16): SqlInt16;
};


export interface __SqlInt16$views {
    As_INullable(): INullable$instance;
    As_IComparable(): System_Internal.IComparable$instance;
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<SqlInt16>;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;

    // Structural method bridges for numeric interface constraints
    Equals(other: SqlInt16): boolean;
    CompareTo(obj: unknown): int;
}

export interface SqlInt16$instance extends INullable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlInt16 = SqlInt16$instance & __SqlInt16$views;


export interface SqlInt32$instance {
    readonly IsNull: boolean;
    readonly Value: int;
    CompareTo(value: unknown): int;
    CompareTo(value: SqlInt32): int;
    Equals(value: unknown): boolean;
    Equals(other: SqlInt32): boolean;
    GetHashCode(): int;
    ToSqlBoolean(): SqlBoolean;
    ToSqlByte(): SqlByte;
    ToSqlDecimal(): SqlDecimal;
    ToSqlDouble(): SqlDouble;
    ToSqlInt16(): SqlInt16;
    ToSqlInt64(): SqlInt64;
    ToSqlMoney(): SqlMoney;
    ToSqlSingle(): SqlSingle;
    ToSqlString(): SqlString;
    ToString(): string;
}


export const SqlInt32: {
    new(value: int): SqlInt32$instance;
    readonly Null: SqlInt32;
    readonly Zero: SqlInt32;
    readonly MinValue: SqlInt32;
    readonly MaxValue: SqlInt32;
    Add(x: SqlInt32, y: SqlInt32): SqlInt32;
    BitwiseAnd(x: SqlInt32, y: SqlInt32): SqlInt32;
    BitwiseOr(x: SqlInt32, y: SqlInt32): SqlInt32;
    Divide(x: SqlInt32, y: SqlInt32): SqlInt32;
    Equals(x: SqlInt32, y: SqlInt32): SqlBoolean;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
    GreaterThan(x: SqlInt32, y: SqlInt32): SqlBoolean;
    GreaterThanOrEqual(x: SqlInt32, y: SqlInt32): SqlBoolean;
    LessThan(x: SqlInt32, y: SqlInt32): SqlBoolean;
    LessThanOrEqual(x: SqlInt32, y: SqlInt32): SqlBoolean;
    Mod(x: SqlInt32, y: SqlInt32): SqlInt32;
    Modulus(x: SqlInt32, y: SqlInt32): SqlInt32;
    Multiply(x: SqlInt32, y: SqlInt32): SqlInt32;
    NotEquals(x: SqlInt32, y: SqlInt32): SqlBoolean;
    OnesComplement(x: SqlInt32): SqlInt32;
    Parse(s: string): SqlInt32;
    Subtract(x: SqlInt32, y: SqlInt32): SqlInt32;
    Xor(x: SqlInt32, y: SqlInt32): SqlInt32;
};


export interface __SqlInt32$views {
    As_INullable(): INullable$instance;
    As_IComparable(): System_Internal.IComparable$instance;
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<SqlInt32>;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;

    // Structural method bridges for numeric interface constraints
    Equals(other: SqlInt32): boolean;
    CompareTo(obj: unknown): int;
}

export interface SqlInt32$instance extends INullable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlInt32 = SqlInt32$instance & __SqlInt32$views;


export interface SqlInt64$instance {
    readonly IsNull: boolean;
    readonly Value: long;
    CompareTo(value: unknown): int;
    CompareTo(value: SqlInt64): int;
    Equals(value: unknown): boolean;
    Equals(other: SqlInt64): boolean;
    GetHashCode(): int;
    ToSqlBoolean(): SqlBoolean;
    ToSqlByte(): SqlByte;
    ToSqlDecimal(): SqlDecimal;
    ToSqlDouble(): SqlDouble;
    ToSqlInt16(): SqlInt16;
    ToSqlInt32(): SqlInt32;
    ToSqlMoney(): SqlMoney;
    ToSqlSingle(): SqlSingle;
    ToSqlString(): SqlString;
    ToString(): string;
}


export const SqlInt64: {
    new(value: long): SqlInt64$instance;
    readonly Null: SqlInt64;
    readonly Zero: SqlInt64;
    readonly MinValue: SqlInt64;
    readonly MaxValue: SqlInt64;
    Add(x: SqlInt64, y: SqlInt64): SqlInt64;
    BitwiseAnd(x: SqlInt64, y: SqlInt64): SqlInt64;
    BitwiseOr(x: SqlInt64, y: SqlInt64): SqlInt64;
    Divide(x: SqlInt64, y: SqlInt64): SqlInt64;
    Equals(x: SqlInt64, y: SqlInt64): SqlBoolean;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
    GreaterThan(x: SqlInt64, y: SqlInt64): SqlBoolean;
    GreaterThanOrEqual(x: SqlInt64, y: SqlInt64): SqlBoolean;
    LessThan(x: SqlInt64, y: SqlInt64): SqlBoolean;
    LessThanOrEqual(x: SqlInt64, y: SqlInt64): SqlBoolean;
    Mod(x: SqlInt64, y: SqlInt64): SqlInt64;
    Modulus(x: SqlInt64, y: SqlInt64): SqlInt64;
    Multiply(x: SqlInt64, y: SqlInt64): SqlInt64;
    NotEquals(x: SqlInt64, y: SqlInt64): SqlBoolean;
    OnesComplement(x: SqlInt64): SqlInt64;
    Parse(s: string): SqlInt64;
    Subtract(x: SqlInt64, y: SqlInt64): SqlInt64;
    Xor(x: SqlInt64, y: SqlInt64): SqlInt64;
};


export interface __SqlInt64$views {
    As_INullable(): INullable$instance;
    As_IComparable(): System_Internal.IComparable$instance;
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<SqlInt64>;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;

    // Structural method bridges for numeric interface constraints
    Equals(other: SqlInt64): boolean;
    CompareTo(obj: unknown): int;
}

export interface SqlInt64$instance extends INullable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlInt64 = SqlInt64$instance & __SqlInt64$views;


export interface SqlMoney$instance {
    readonly IsNull: boolean;
    readonly Value: decimal;
    CompareTo(value: unknown): int;
    CompareTo(value: SqlMoney): int;
    Equals(value: unknown): boolean;
    Equals(other: SqlMoney): boolean;
    GetHashCode(): int;
    GetTdsValue(): long;
    ToDecimal(): decimal;
    ToDouble(): double;
    ToInt32(): int;
    ToInt64(): long;
    ToSqlBoolean(): SqlBoolean;
    ToSqlByte(): SqlByte;
    ToSqlDecimal(): SqlDecimal;
    ToSqlDouble(): SqlDouble;
    ToSqlInt16(): SqlInt16;
    ToSqlInt32(): SqlInt32;
    ToSqlInt64(): SqlInt64;
    ToSqlSingle(): SqlSingle;
    ToSqlString(): SqlString;
    ToString(): string;
}


export const SqlMoney: {
    new(value: int): SqlMoney$instance;
    new(value: long): SqlMoney$instance;
    new(value: decimal): SqlMoney$instance;
    new(value: double): SqlMoney$instance;
    readonly Null: SqlMoney;
    readonly Zero: SqlMoney;
    readonly MinValue: SqlMoney;
    readonly MaxValue: SqlMoney;
    Add(x: SqlMoney, y: SqlMoney): SqlMoney;
    Divide(x: SqlMoney, y: SqlMoney): SqlMoney;
    Equals(x: SqlMoney, y: SqlMoney): SqlBoolean;
    FromTdsValue(value: long): SqlMoney;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
    GreaterThan(x: SqlMoney, y: SqlMoney): SqlBoolean;
    GreaterThanOrEqual(x: SqlMoney, y: SqlMoney): SqlBoolean;
    LessThan(x: SqlMoney, y: SqlMoney): SqlBoolean;
    LessThanOrEqual(x: SqlMoney, y: SqlMoney): SqlBoolean;
    Multiply(x: SqlMoney, y: SqlMoney): SqlMoney;
    NotEquals(x: SqlMoney, y: SqlMoney): SqlBoolean;
    Parse(s: string): SqlMoney;
    Subtract(x: SqlMoney, y: SqlMoney): SqlMoney;
};


export interface __SqlMoney$views {
    As_INullable(): INullable$instance;
    As_IComparable(): System_Internal.IComparable$instance;
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<SqlMoney>;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;

    // Structural method bridges for numeric interface constraints
    Equals(other: SqlMoney): boolean;
    CompareTo(obj: unknown): int;
}

export interface SqlMoney$instance extends INullable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlMoney = SqlMoney$instance & __SqlMoney$views;


export interface SqlSingle$instance {
    readonly IsNull: boolean;
    readonly Value: float;
    CompareTo(value: unknown): int;
    CompareTo(value: SqlSingle): int;
    Equals(value: unknown): boolean;
    Equals(other: SqlSingle): boolean;
    GetHashCode(): int;
    ToSqlBoolean(): SqlBoolean;
    ToSqlByte(): SqlByte;
    ToSqlDecimal(): SqlDecimal;
    ToSqlDouble(): SqlDouble;
    ToSqlInt16(): SqlInt16;
    ToSqlInt32(): SqlInt32;
    ToSqlInt64(): SqlInt64;
    ToSqlMoney(): SqlMoney;
    ToSqlString(): SqlString;
    ToString(): string;
}


export const SqlSingle: {
    new(value: float): SqlSingle$instance;
    new(value: double): SqlSingle$instance;
    readonly Null: SqlSingle;
    readonly Zero: SqlSingle;
    readonly MinValue: SqlSingle;
    readonly MaxValue: SqlSingle;
    Add(x: SqlSingle, y: SqlSingle): SqlSingle;
    Divide(x: SqlSingle, y: SqlSingle): SqlSingle;
    Equals(x: SqlSingle, y: SqlSingle): SqlBoolean;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
    GreaterThan(x: SqlSingle, y: SqlSingle): SqlBoolean;
    GreaterThanOrEqual(x: SqlSingle, y: SqlSingle): SqlBoolean;
    LessThan(x: SqlSingle, y: SqlSingle): SqlBoolean;
    LessThanOrEqual(x: SqlSingle, y: SqlSingle): SqlBoolean;
    Multiply(x: SqlSingle, y: SqlSingle): SqlSingle;
    NotEquals(x: SqlSingle, y: SqlSingle): SqlBoolean;
    Parse(s: string): SqlSingle;
    Subtract(x: SqlSingle, y: SqlSingle): SqlSingle;
};


export interface __SqlSingle$views {
    As_INullable(): INullable$instance;
    As_IComparable(): System_Internal.IComparable$instance;
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<SqlSingle>;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;

    // Structural method bridges for numeric interface constraints
    Equals(other: SqlSingle): boolean;
    CompareTo(obj: unknown): int;
}

export interface SqlSingle$instance extends INullable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlSingle = SqlSingle$instance & __SqlSingle$views;


export interface SqlString$instance {
    readonly CompareInfo: CompareInfo;
    readonly CultureInfo: CultureInfo;
    readonly IsNull: boolean;
    readonly LCID: int;
    readonly SqlCompareOptions: SqlCompareOptions;
    readonly Value: string;
    Clone(): SqlString;
    CompareTo(value: unknown): int;
    CompareTo(value: SqlString): int;
    Equals(value: unknown): boolean;
    Equals(other: SqlString): boolean;
    GetHashCode(): int;
    GetNonUnicodeBytes(): byte[];
    GetUnicodeBytes(): byte[];
    ToSqlBoolean(): SqlBoolean;
    ToSqlByte(): SqlByte;
    ToSqlDateTime(): SqlDateTime;
    ToSqlDecimal(): SqlDecimal;
    ToSqlDouble(): SqlDouble;
    ToSqlGuid(): SqlGuid;
    ToSqlInt16(): SqlInt16;
    ToSqlInt32(): SqlInt32;
    ToSqlInt64(): SqlInt64;
    ToSqlMoney(): SqlMoney;
    ToSqlSingle(): SqlSingle;
    ToString(): string;
}


export const SqlString: {
    new(lcid: int, compareOptions: SqlCompareOptions, data: byte[], index: int, count: int, fUnicode: boolean): SqlString$instance;
    new(lcid: int, compareOptions: SqlCompareOptions, data: byte[], fUnicode: boolean): SqlString$instance;
    new(lcid: int, compareOptions: SqlCompareOptions, data: byte[], index: int, count: int): SqlString$instance;
    new(lcid: int, compareOptions: SqlCompareOptions, data: byte[]): SqlString$instance;
    new(data: string, lcid: int, compareOptions: SqlCompareOptions): SqlString$instance;
    new(data: string, lcid: int): SqlString$instance;
    new(data: string): SqlString$instance;
    readonly Null: SqlString;
    readonly IgnoreCase: int;
    readonly IgnoreWidth: int;
    readonly IgnoreNonSpace: int;
    readonly IgnoreKanaType: int;
    readonly BinarySort: int;
    readonly BinarySort2: int;
    Add(x: SqlString, y: SqlString): SqlString;
    CompareOptionsFromSqlCompareOptions(compareOptions: SqlCompareOptions): CompareOptions;
    Concat(x: SqlString, y: SqlString): SqlString;
    Equals(x: SqlString, y: SqlString): SqlBoolean;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
    GreaterThan(x: SqlString, y: SqlString): SqlBoolean;
    GreaterThanOrEqual(x: SqlString, y: SqlString): SqlBoolean;
    LessThan(x: SqlString, y: SqlString): SqlBoolean;
    LessThanOrEqual(x: SqlString, y: SqlString): SqlBoolean;
    NotEquals(x: SqlString, y: SqlString): SqlBoolean;
};


export interface __SqlString$views {
    As_INullable(): INullable$instance;
    As_IComparable(): System_Internal.IComparable$instance;
    As_IEquatable_1(): System_Internal.IEquatable_1$instance<SqlString>;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;

    // Structural method bridges for numeric interface constraints
    Equals(other: SqlString): boolean;
    CompareTo(obj: unknown): int;
}

export interface SqlString$instance extends INullable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlString = SqlString$instance & __SqlString$views;


export interface SqlAlreadyFilledException$instance extends SqlTypeException$instance {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const SqlAlreadyFilledException: {
    new(): SqlAlreadyFilledException$instance;
    new(message: string): SqlAlreadyFilledException$instance;
    new(message: string, e: Exception): SqlAlreadyFilledException$instance;
};


export interface __SqlAlreadyFilledException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type SqlAlreadyFilledException = SqlAlreadyFilledException$instance & __SqlAlreadyFilledException$views;


export interface SqlBytes$instance {
    readonly Buffer: byte[];
    readonly IsNull: boolean;
    Item: byte;
    readonly Length: long;
    readonly MaxLength: long;
    readonly Storage: StorageState;
    Stream: Stream;
    readonly Value: byte[];
    Read(offset: long, buffer: byte[], offsetInBuffer: int, count: int): long;
    SetLength(value: long): void;
    SetNull(): void;
    ToSqlBinary(): SqlBinary;
    Write(offset: long, buffer: byte[], offsetInBuffer: int, count: int): void;
}


export const SqlBytes: {
    new(): SqlBytes$instance;
    new(buffer: byte[]): SqlBytes$instance;
    new(value: SqlBinary): SqlBytes$instance;
    new(s: Stream): SqlBytes$instance;
    readonly Null: SqlBytes;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
};


export interface __SqlBytes$views {
    As_INullable(): INullable$instance;
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;
}

export interface SqlBytes$instance extends INullable$instance, System_Runtime_Serialization_Internal.ISerializable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlBytes = SqlBytes$instance & __SqlBytes$views;


export interface SqlChars$instance {
    readonly Buffer: char[];
    readonly IsNull: boolean;
    Item: char;
    readonly Length: long;
    readonly MaxLength: long;
    readonly Storage: StorageState;
    readonly Value: char[];
    Read(offset: long, buffer: char[], offsetInBuffer: int, count: int): long;
    SetLength(value: long): void;
    SetNull(): void;
    ToSqlString(): SqlString;
    Write(offset: long, buffer: char[], offsetInBuffer: int, count: int): void;
}


export const SqlChars: {
    new(): SqlChars$instance;
    new(buffer: char[]): SqlChars$instance;
    new(value: SqlString): SqlChars$instance;
    readonly Null: SqlChars;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
};


export interface __SqlChars$views {
    As_INullable(): INullable$instance;
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;
}

export interface SqlChars$instance extends INullable$instance, System_Runtime_Serialization_Internal.ISerializable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlChars = SqlChars$instance & __SqlChars$views;


export interface SqlNotFilledException$instance extends SqlTypeException$instance {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const SqlNotFilledException: {
    new(): SqlNotFilledException$instance;
    new(message: string): SqlNotFilledException$instance;
    new(message: string, e: Exception): SqlNotFilledException$instance;
};


export interface __SqlNotFilledException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type SqlNotFilledException = SqlNotFilledException$instance & __SqlNotFilledException$views;


export interface SqlNullValueException$instance extends SqlTypeException$instance {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const SqlNullValueException: {
    new(): SqlNullValueException$instance;
    new(message: string): SqlNullValueException$instance;
    new(message: string, e: Exception): SqlNullValueException$instance;
};


export interface __SqlNullValueException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type SqlNullValueException = SqlNullValueException$instance & __SqlNullValueException$views;


export interface SqlTruncateException$instance extends SqlTypeException$instance {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const SqlTruncateException: {
    new(): SqlTruncateException$instance;
    new(message: string): SqlTruncateException$instance;
    new(message: string, e: Exception): SqlTruncateException$instance;
};


export interface __SqlTruncateException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type SqlTruncateException = SqlTruncateException$instance & __SqlTruncateException$views;


export interface SqlTypeException$instance extends SystemException {
    GetObjectData(info: SerializationInfo, context: StreamingContext): void;
}


export const SqlTypeException: {
    new(): SqlTypeException$instance;
    new(message: string): SqlTypeException$instance;
    new(message: string, e: Exception): SqlTypeException$instance;
};


export interface __SqlTypeException$views {
    As_ISerializable(): System_Runtime_Serialization_Internal.ISerializable$instance;
}

export type SqlTypeException = SqlTypeException$instance & __SqlTypeException$views;


export interface SqlXml$instance {
    readonly IsNull: boolean;
    readonly Value: string;
    CreateReader(): XmlReader;
}


export const SqlXml: {
    new(): SqlXml$instance;
    new(value: XmlReader): SqlXml$instance;
    new(value: Stream): SqlXml$instance;
    readonly Null: SqlXml;
    GetXsdType(schemaSet: XmlSchemaSet): XmlQualifiedName;
};


export interface __SqlXml$views {
    As_INullable(): INullable$instance;
    As_IXmlSerializable(): System_Xml_Serialization_Internal.IXmlSerializable$instance;
}

export interface SqlXml$instance extends INullable$instance, System_Xml_Serialization_Internal.IXmlSerializable$instance {}

export type SqlXml = SqlXml$instance & __SqlXml$views;