@tsonic/dotnet-pure/System.Runtime.Serialization/internal/index.d.ts

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

// Generated by tsbindgen - Architecture
// Namespace: System.Runtime.Serialization
// Assembly: System.Private.CoreLib, System.Private.DataContractSerialization, System.Runtime.Serialization.Formatters, System.Runtime.Serialization.Primitives

// 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 support types from @tsonic/types
import type { ptr, ref } from "@tsonic/types";

// Import types from other namespaces
import type { ICollection_1, IEnumerable_1 } from "../../System.Collections.Generic/internal/index.js";
import type { Collection_1, ReadOnlyCollection_1 } from "../../System.Collections.ObjectModel/internal/index.js";
import * as System_Collections_Internal from "../../System.Collections/internal/index.js";
import type { IDictionary, IEnumerator } from "../../System.Collections/internal/index.js";
import type { DateTimeStyles } from "../../System.Globalization/internal/index.js";
import type { Stream } from "../../System.IO/internal/index.js";
import type { Assembly, ConstructorInfo, MemberInfo, MethodBase, MethodInfo, PropertyInfo } from "../../System.Reflection/internal/index.js";
import type { TypeFilterLevel } from "../../System.Runtime.Serialization.Formatters/internal/index.js";
import type { StringBuilder } from "../../System.Text/internal/index.js";
import type { XmlSchemaSet, XmlSchemaType } from "../../System.Xml.Schema/internal/index.js";
import type { XmlDictionaryReader, XmlDictionaryString, XmlDictionaryWriter, XmlNamespaceManager, XmlNode, XmlQualifiedName, XmlReader, XmlWriter } from "../../System.Xml/internal/index.js";
import * as System_Internal from "../../System/internal/index.js";
import type { AsyncCallback, Attribute, Boolean as ClrBoolean, Byte, Char, DateTime, Decimal, Delegate, Double, Enum, EventArgs, Exception, IAsyncResult, ICloneable, IComparable, IConvertible, IDisposable, IFormatProvider, IFormattable, Int16, Int32, Int64, IntPtr, ISpanFormattable, MulticastDelegate, Object as ClrObject, SByte, Single, String as ClrString, SystemException, Type, TypeCode, UInt16, UInt32, UInt64, 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 EmitTypeInformation {
    AsNeeded = 0,
    Always = 1,
    Never = 2
}


export enum StreamingContextStates {
    CrossProcess = 1,
    CrossMachine = 2,
    File = 4,
    Persistence = 8,
    Remoting = 16,
    Other = 32,
    Clone = 64,
    CrossAppDomain = 128,
    All = 255
}


export type SerializationEventHandler = (context: StreamingContext) => void;


export interface IDeserializationCallback$instance {
    OnDeserialization(sender: unknown): void;
}


export type IDeserializationCallback = IDeserializationCallback$instance;

export interface IExtensibleDataObject$instance {
    ExtensionData: ExtensionDataObject;
}


export type IExtensibleDataObject = IExtensibleDataObject$instance;

export interface IFormatter$instance {
    SurrogateSelector: ISurrogateSelector;
    Binder: SerializationBinder;
    Context: StreamingContext;
    Deserialize(serializationStream: Stream): unknown;
    Serialize(serializationStream: Stream, graph: unknown): void;
}


export type IFormatter = IFormatter$instance;

export interface IFormatterConverter$instance {
    Convert(value: unknown, type_: Type): unknown;
    Convert(value: unknown, typeCode: TypeCode): unknown;
    ToBoolean(value: unknown): boolean;
    ToByte(value: unknown): byte;
    ToChar(value: unknown): char;
    ToDateTime(value: unknown): DateTime;
    ToDecimal(value: unknown): decimal;
    ToDouble(value: unknown): double;
    ToInt16(value: unknown): short;
    ToInt32(value: unknown): int;
    ToInt64(value: unknown): long;
    ToSByte(value: unknown): sbyte;
    ToSingle(value: unknown): float;
    ToString(value: unknown): string;
    ToUInt16(value: unknown): ushort;
    ToUInt32(value: unknown): uint;
    ToUInt64(value: unknown): ulong;
}


export type IFormatterConverter = IFormatterConverter$instance;

export interface IObjectReference$instance {
    GetRealObject(context: StreamingContext): unknown;
}


export type IObjectReference = IObjectReference$instance;

export interface ISafeSerializationData$instance {
    CompleteDeserialization(deserialized: unknown): void;
}


export type ISafeSerializationData = ISafeSerializationData$instance;

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


export type ISerializable = ISerializable$instance;

export interface ISerializationSurrogate$instance {
    GetObjectData(obj: unknown, info: SerializationInfo, context: StreamingContext): void;
    SetObjectData(obj: unknown, info: SerializationInfo, context: StreamingContext, selector: ISurrogateSelector): unknown;
}


export type ISerializationSurrogate = ISerializationSurrogate$instance;

export interface ISerializationSurrogateProvider$instance {
    GetObjectToSerialize(obj: unknown, targetType: Type): unknown;
    GetSurrogateType(type_: Type): Type;
}


export type ISerializationSurrogateProvider = ISerializationSurrogateProvider$instance;

export interface ISerializationSurrogateProvider2$instance extends ISerializationSurrogateProvider {
    GetCustomDataToExport(memberInfo: MemberInfo, dataContractType: Type): unknown;
    GetCustomDataToExport(runtimeType: Type, dataContractType: Type): unknown;
    GetKnownCustomDataTypes(customDataTypes: Collection_1<Type>): void;
    GetObjectToSerialize(obj: unknown, targetType: Type): unknown;
    GetReferencedTypeOnImport(typeName: string, typeNamespace: string, customData: unknown): Type;
    GetSurrogateType(type_: Type): Type;
}


export interface ISerializationSurrogateProvider2$instance extends ISerializationSurrogateProvider$instance {}

export type ISerializationSurrogateProvider2 = ISerializationSurrogateProvider2$instance;

export interface ISurrogateSelector$instance {
    ChainSelector(selector: ISurrogateSelector): void;
    GetNextSelector(): ISurrogateSelector;
    GetSurrogate(type_: Type, context: StreamingContext, selector: { value: ref<ISurrogateSelector> }): ISerializationSurrogate;
}


export type ISurrogateSelector = ISurrogateSelector$instance;

export interface DeserializationToken$instance {
    Dispose(): void;
}


export const DeserializationToken: {
    new(): DeserializationToken$instance;
};


export interface __DeserializationToken$views {
    As_IDisposable(): System_Internal.IDisposable$instance;
}

export interface DeserializationToken$instance extends System_Internal.IDisposable$instance {}

export type DeserializationToken = DeserializationToken$instance & __DeserializationToken$views;


export interface SerializationEntry$instance {
    readonly Name: string;
    readonly ObjectType: Type;
    readonly Value: unknown;
}


export const SerializationEntry: {
    new(): SerializationEntry$instance;
};


export type SerializationEntry = SerializationEntry$instance;

export interface StreamingContext$instance {
    readonly Context: unknown;
    readonly State: StreamingContextStates;
    Equals(obj: unknown): boolean;
    GetHashCode(): int;
}


export const StreamingContext: {
    new(state: StreamingContextStates): StreamingContext$instance;
    new(state: StreamingContextStates, additional: unknown): StreamingContext$instance;
};


export type StreamingContext = StreamingContext$instance;

export interface CollectionDataContractAttribute$instance extends Attribute {
    readonly IsItemNameSetExplicitly: boolean;
    readonly IsKeyNameSetExplicitly: boolean;
    readonly IsNameSetExplicitly: boolean;
    readonly IsNamespaceSetExplicitly: boolean;
    IsReference: boolean;
    readonly IsReferenceSetExplicitly: boolean;
    readonly IsValueNameSetExplicitly: boolean;
    ItemName: string;
    KeyName: string;
    Name: string;
    Namespace: string;
    ValueName: string;
}


export const CollectionDataContractAttribute: {
    new(): CollectionDataContractAttribute$instance;
};


export type CollectionDataContractAttribute = CollectionDataContractAttribute$instance;

export interface ContractNamespaceAttribute$instance extends Attribute {
    ClrNamespace: string;
    readonly ContractNamespace: string;
}


export const ContractNamespaceAttribute: {
    new(contractNamespace: string): ContractNamespaceAttribute$instance;
};


export type ContractNamespaceAttribute = ContractNamespaceAttribute$instance;

export interface DataContractAttribute$instance extends Attribute {
    readonly IsNameSetExplicitly: boolean;
    readonly IsNamespaceSetExplicitly: boolean;
    IsReference: boolean;
    readonly IsReferenceSetExplicitly: boolean;
    Name: string;
    Namespace: string;
}


export const DataContractAttribute: {
    new(): DataContractAttribute$instance;
};


export type DataContractAttribute = DataContractAttribute$instance;

export interface DataContractResolver$instance {
    ResolveName(typeName: string, typeNamespace: string, declaredType: Type, knownTypeResolver: DataContractResolver): Type;
    TryResolveType(type_: Type, declaredType: Type, knownTypeResolver: DataContractResolver, typeName: { value: ref<XmlDictionaryString> }, typeNamespace: { value: ref<XmlDictionaryString> }): boolean;
}


export const DataContractResolver: {
};


export type DataContractResolver = DataContractResolver$instance;

export interface DataContractSerializer$instance extends XmlObjectSerializer {
    readonly DataContractResolver: DataContractResolver;
    readonly IgnoreExtensionDataObject: boolean;
    readonly KnownTypes: ReadOnlyCollection_1<Type>;
    readonly MaxItemsInObjectGraph: int;
    readonly PreserveObjectReferences: boolean;
    readonly SerializeReadOnlyTypes: boolean;
    IsStartObject(reader: XmlReader): boolean;
    IsStartObject(reader: XmlDictionaryReader): boolean;
    ReadObject(reader: XmlReader): unknown;
    ReadObject(reader: XmlReader, verifyObjectName: boolean): unknown;
    ReadObject(reader: XmlDictionaryReader, verifyObjectName: boolean): unknown;
    ReadObject(reader: XmlDictionaryReader, verifyObjectName: boolean, dataContractResolver: DataContractResolver): unknown;
    ReadObject(stream: Stream): unknown;
    ReadObject(reader: XmlDictionaryReader): unknown;
    WriteEndObject(writer: XmlWriter): void;
    WriteEndObject(writer: XmlDictionaryWriter): void;
    WriteObject(writer: XmlWriter, graph: unknown): void;
    WriteObject(writer: XmlDictionaryWriter, graph: unknown, dataContractResolver: DataContractResolver): void;
    WriteObject(stream: Stream, graph: unknown): void;
    WriteObject(writer: XmlDictionaryWriter, graph: unknown): void;
    WriteObjectContent(writer: XmlWriter, graph: unknown): void;
    WriteObjectContent(writer: XmlDictionaryWriter, graph: unknown): void;
    WriteStartObject(writer: XmlWriter, graph: unknown): void;
    WriteStartObject(writer: XmlDictionaryWriter, graph: unknown): void;
}


export const DataContractSerializer: {
    new(type_: Type): DataContractSerializer$instance;
    new(type_: Type, knownTypes: IEnumerable_1<Type>): DataContractSerializer$instance;
    new(type_: Type, rootName: string, rootNamespace: string): DataContractSerializer$instance;
    new(type_: Type, rootName: string, rootNamespace: string, knownTypes: IEnumerable_1<Type>): DataContractSerializer$instance;
    new(type_: Type, rootName: XmlDictionaryString, rootNamespace: XmlDictionaryString): DataContractSerializer$instance;
    new(type_: Type, rootName: XmlDictionaryString, rootNamespace: XmlDictionaryString, knownTypes: IEnumerable_1<Type>): DataContractSerializer$instance;
    new(type_: Type, settings: DataContractSerializerSettings): DataContractSerializer$instance;
};


export type DataContractSerializer = DataContractSerializer$instance;

export interface DataContractSerializerSettings$instance {
    DataContractResolver: DataContractResolver;
    IgnoreExtensionDataObject: boolean;
    KnownTypes: IEnumerable_1<Type>;
    MaxItemsInObjectGraph: int;
    PreserveObjectReferences: boolean;
    RootName: XmlDictionaryString;
    RootNamespace: XmlDictionaryString;
    SerializeReadOnlyTypes: boolean;
}


export const DataContractSerializerSettings: {
    new(): DataContractSerializerSettings$instance;
};


export type DataContractSerializerSettings = DataContractSerializerSettings$instance;

export interface DataMemberAttribute$instance extends Attribute {
    EmitDefaultValue: boolean;
    readonly IsNameSetExplicitly: boolean;
    IsRequired: boolean;
    Name: string;
    Order: int;
}


export const DataMemberAttribute: {
    new(): DataMemberAttribute$instance;
};


export type DataMemberAttribute = DataMemberAttribute$instance;

export interface DateTimeFormat$instance {
    DateTimeStyles: DateTimeStyles;
    readonly FormatProvider: IFormatProvider;
    readonly FormatString: string;
}


export const DateTimeFormat: {
    new(formatString: string): DateTimeFormat$instance;
    new(formatString: string, formatProvider: IFormatProvider): DateTimeFormat$instance;
};


export type DateTimeFormat = DateTimeFormat$instance;

export interface EnumMemberAttribute$instance extends Attribute {
    readonly IsValueSetExplicitly: boolean;
    Value: string;
}


export const EnumMemberAttribute: {
    new(): EnumMemberAttribute$instance;
};


export type EnumMemberAttribute = EnumMemberAttribute$instance;

export interface ExportOptions$instance {
    DataContractSurrogate: ISerializationSurrogateProvider;
    readonly KnownTypes: Collection_1<Type>;
}


export const ExportOptions: {
    new(): ExportOptions$instance;
};


export type ExportOptions = ExportOptions$instance;

export interface ExtensionDataObject$instance {
}


export const ExtensionDataObject: {
    new(): ExtensionDataObject$instance;
};


export type ExtensionDataObject = ExtensionDataObject$instance;

export interface Formatter$instance {
    Binder: SerializationBinder;
    Context: StreamingContext;
    SurrogateSelector: ISurrogateSelector;
    Deserialize(serializationStream: Stream): unknown;
    Serialize(serializationStream: Stream, graph: unknown): void;
}


export const Formatter: {
};


export interface __Formatter$views {
    As_IFormatter(): IFormatter$instance;
}

export interface Formatter$instance extends IFormatter$instance {}

export type Formatter = Formatter$instance & __Formatter$views;


export interface FormatterConverter$instance {
    Convert(value: unknown, type_: Type): unknown;
    Convert(value: unknown, typeCode: TypeCode): unknown;
    ToBoolean(value: unknown): boolean;
    ToByte(value: unknown): byte;
    ToChar(value: unknown): char;
    ToDateTime(value: unknown): DateTime;
    ToDecimal(value: unknown): decimal;
    ToDouble(value: unknown): double;
    ToInt16(value: unknown): short;
    ToInt32(value: unknown): int;
    ToInt64(value: unknown): long;
    ToSByte(value: unknown): sbyte;
    ToSingle(value: unknown): float;
    ToString(value: unknown): string;
    ToUInt16(value: unknown): ushort;
    ToUInt32(value: unknown): uint;
    ToUInt64(value: unknown): ulong;
}


export const FormatterConverter: {
    new(): FormatterConverter$instance;
};


export interface __FormatterConverter$views {
    As_IFormatterConverter(): IFormatterConverter$instance;
}

export type FormatterConverter = FormatterConverter$instance & __FormatterConverter$views;


export interface IgnoreDataMemberAttribute$instance extends Attribute {
}


export const IgnoreDataMemberAttribute: {
    new(): IgnoreDataMemberAttribute$instance;
};


export type IgnoreDataMemberAttribute = IgnoreDataMemberAttribute$instance;

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


export const InvalidDataContractException: {
    new(): InvalidDataContractException$instance;
    new(message: string): InvalidDataContractException$instance;
    new(message: string, innerException: Exception): InvalidDataContractException$instance;
};


export interface __InvalidDataContractException$views {
    As_ISerializable(): ISerializable$instance;
}

export type InvalidDataContractException = InvalidDataContractException$instance & __InvalidDataContractException$views;


export interface KnownTypeAttribute$instance extends Attribute {
    readonly MethodName: string;
    readonly Type: Type;
}


export const KnownTypeAttribute: {
    new(type_: Type): KnownTypeAttribute$instance;
    new(methodName: string): KnownTypeAttribute$instance;
};


export type KnownTypeAttribute = KnownTypeAttribute$instance;

export interface ObjectIDGenerator$instance {
    GetId(obj: unknown, firstTime: { value: ref<boolean> }): long;
    HasId(obj: unknown, firstTime: { value: ref<boolean> }): long;
}


export const ObjectIDGenerator: {
    new(): ObjectIDGenerator$instance;
};


export type ObjectIDGenerator = ObjectIDGenerator$instance;

export interface ObjectManager$instance {
    DoFixups(): void;
    GetObject(objectID: long): unknown;
    RaiseDeserializationEvent(): void;
    RaiseOnDeserializingEvent(obj: unknown): void;
    RecordArrayElementFixup(arrayToBeFixed: long, index: int, objectRequired: long): void;
    RecordArrayElementFixup(arrayToBeFixed: long, indices: int[], objectRequired: long): void;
    RecordDelayedFixup(objectToBeFixed: long, memberName: string, objectRequired: long): void;
    RecordFixup(objectToBeFixed: long, member: MemberInfo, objectRequired: long): void;
    RegisterObject(obj: unknown, objectID: long): void;
    RegisterObject(obj: unknown, objectID: long, info: SerializationInfo): void;
    RegisterObject(obj: unknown, objectID: long, info: SerializationInfo, idOfContainingObj: long, member: MemberInfo): void;
    RegisterObject(obj: unknown, objectID: long, info: SerializationInfo, idOfContainingObj: long, member: MemberInfo, arrayIndex: int[]): void;
}


export const ObjectManager: {
    new(selector: ISurrogateSelector, context: StreamingContext): ObjectManager$instance;
};


export type ObjectManager = ObjectManager$instance;

export interface OnDeserializedAttribute$instance extends Attribute {
}


export const OnDeserializedAttribute: {
    new(): OnDeserializedAttribute$instance;
};


export type OnDeserializedAttribute = OnDeserializedAttribute$instance;

export interface OnDeserializingAttribute$instance extends Attribute {
}


export const OnDeserializingAttribute: {
    new(): OnDeserializingAttribute$instance;
};


export type OnDeserializingAttribute = OnDeserializingAttribute$instance;

export interface OnSerializedAttribute$instance extends Attribute {
}


export const OnSerializedAttribute: {
    new(): OnSerializedAttribute$instance;
};


export type OnSerializedAttribute = OnSerializedAttribute$instance;

export interface OnSerializingAttribute$instance extends Attribute {
}


export const OnSerializingAttribute: {
    new(): OnSerializingAttribute$instance;
};


export type OnSerializingAttribute = OnSerializingAttribute$instance;

export interface OptionalFieldAttribute$instance extends Attribute {
    VersionAdded: int;
}


export const OptionalFieldAttribute: {
    new(): OptionalFieldAttribute$instance;
};


export type OptionalFieldAttribute = OptionalFieldAttribute$instance;

export interface SafeSerializationEventArgs$instance extends EventArgs {
    readonly StreamingContext: StreamingContext;
    AddSerializedState(serializedState: ISafeSerializationData): void;
}


export const SafeSerializationEventArgs: {
    new(): SafeSerializationEventArgs$instance;
};


export type SafeSerializationEventArgs = SafeSerializationEventArgs$instance;

export interface SerializationBinder$instance {
    BindToName(serializedType: Type, assemblyName: { value: ref<string> }, typeName: { value: ref<string> }): void;
    BindToType(assemblyName: string, typeName: string): Type;
}


export const SerializationBinder: {
};


export type SerializationBinder = SerializationBinder$instance;

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


export const SerializationException: {
    new(): SerializationException$instance;
    new(message: string): SerializationException$instance;
    new(message: string, innerException: Exception): SerializationException$instance;
};


export interface __SerializationException$views {
    As_ISerializable(): ISerializable$instance;
}

export type SerializationException = SerializationException$instance & __SerializationException$views;


export interface SerializationInfo$instance {
    AssemblyName: string;
    FullTypeName: string;
    readonly IsAssemblyNameSetExplicit: boolean;
    readonly IsFullTypeNameSetExplicit: boolean;
    readonly MemberCount: int;
    readonly ObjectType: Type;
    AddValue(name: string, value: unknown, type_: Type): void;
    AddValue(name: string, value: unknown): void;
    AddValue(name: string, value: boolean): void;
    AddValue(name: string, value: char): void;
    AddValue(name: string, value: sbyte): void;
    AddValue(name: string, value: byte): void;
    AddValue(name: string, value: short): void;
    AddValue(name: string, value: ushort): void;
    AddValue(name: string, value: int): void;
    AddValue(name: string, value: uint): void;
    AddValue(name: string, value: long): void;
    AddValue(name: string, value: ulong): void;
    AddValue(name: string, value: float): void;
    AddValue(name: string, value: double): void;
    AddValue(name: string, value: decimal): void;
    AddValue(name: string, value: DateTime): void;
    GetBoolean(name: string): boolean;
    GetByte(name: string): byte;
    GetChar(name: string): char;
    GetDateTime(name: string): DateTime;
    GetDecimal(name: string): decimal;
    GetDouble(name: string): double;
    GetEnumerator(): SerializationInfoEnumerator;
    GetInt16(name: string): short;
    GetInt32(name: string): int;
    GetInt64(name: string): long;
    GetSByte(name: string): sbyte;
    GetSingle(name: string): float;
    GetString(name: string): string;
    GetUInt16(name: string): ushort;
    GetUInt32(name: string): uint;
    GetUInt64(name: string): ulong;
    GetValue(name: string, type_: Type): unknown;
    SetType(type_: Type): void;
}


export const SerializationInfo: {
    new(type_: Type, converter: IFormatterConverter): SerializationInfo$instance;
    new(type_: Type, converter: IFormatterConverter, requireSameTokenInPartialTrust: boolean): SerializationInfo$instance;
    StartDeserialization(): DeserializationToken;
};


export type SerializationInfo = SerializationInfo$instance;

export interface SerializationInfoEnumerator$instance {
    readonly Current: SerializationEntry | unknown;
    readonly Name: string;
    readonly ObjectType: Type;
    readonly Value: unknown;
    MoveNext(): boolean;
    Reset(): void;
}


export const SerializationInfoEnumerator: {
    new(): SerializationInfoEnumerator$instance;
};


export interface __SerializationInfoEnumerator$views {
    As_IEnumerator(): System_Collections_Internal.IEnumerator$instance;
}

export type SerializationInfoEnumerator = SerializationInfoEnumerator$instance & __SerializationInfoEnumerator$views;


export interface SerializationObjectManager$instance {
    RaiseOnSerializedEvent(): void;
    RegisterObject(obj: unknown): void;
}


export const SerializationObjectManager: {
    new(context: StreamingContext): SerializationObjectManager$instance;
};


export type SerializationObjectManager = SerializationObjectManager$instance;

export interface SurrogateSelector$instance {
    AddSurrogate(type_: Type, context: StreamingContext, surrogate: ISerializationSurrogate): void;
    ChainSelector(selector: ISurrogateSelector): void;
    GetNextSelector(): ISurrogateSelector;
    GetSurrogate(type_: Type, context: StreamingContext, selector: { value: ref<ISurrogateSelector> }): ISerializationSurrogate;
    RemoveSurrogate(type_: Type, context: StreamingContext): void;
}


export const SurrogateSelector: {
    new(): SurrogateSelector$instance;
};


export interface __SurrogateSelector$views {
    As_ISurrogateSelector(): ISurrogateSelector$instance;
}

export interface SurrogateSelector$instance extends ISurrogateSelector$instance {}

export type SurrogateSelector = SurrogateSelector$instance & __SurrogateSelector$views;


export interface TypeLoadExceptionHolder$instance {
}


export const TypeLoadExceptionHolder: {
    new(): TypeLoadExceptionHolder$instance;
};


export type TypeLoadExceptionHolder = TypeLoadExceptionHolder$instance;

export interface XmlObjectSerializer$instance {
    IsStartObject(reader: XmlReader): boolean;
    IsStartObject(reader: XmlDictionaryReader): boolean;
    ReadObject(stream: Stream): unknown;
    ReadObject(reader: XmlReader): unknown;
    ReadObject(reader: XmlDictionaryReader): unknown;
    ReadObject(reader: XmlReader, verifyObjectName: boolean): unknown;
    ReadObject(reader: XmlDictionaryReader, verifyObjectName: boolean): unknown;
    WriteEndObject(writer: XmlDictionaryWriter): void;
    WriteEndObject(writer: XmlWriter): void;
    WriteObject(stream: Stream, graph: unknown): void;
    WriteObject(writer: XmlWriter, graph: unknown): void;
    WriteObject(writer: XmlDictionaryWriter, graph: unknown): void;
    WriteObjectContent(writer: XmlDictionaryWriter, graph: unknown): void;
    WriteObjectContent(writer: XmlWriter, graph: unknown): void;
    WriteStartObject(writer: XmlDictionaryWriter, graph: unknown): void;
    WriteStartObject(writer: XmlWriter, graph: unknown): void;
}


export const XmlObjectSerializer: {
};


export type XmlObjectSerializer = XmlObjectSerializer$instance;

export interface XsdDataContractExporter$instance {
    Options: ExportOptions;
    readonly Schemas: XmlSchemaSet;
    CanExport(assemblies: ICollection_1<Assembly>): boolean;
    CanExport(types: ICollection_1<Type>): boolean;
    CanExport(type_: Type): boolean;
    Export(assemblies: ICollection_1<Assembly>): void;
    Export(types: ICollection_1<Type>): void;
    Export(type_: Type): void;
    GetRootElementName(type_: Type): XmlQualifiedName;
    GetSchemaType(type_: Type): XmlSchemaType;
    GetSchemaTypeName(type_: Type): XmlQualifiedName;
}


export const XsdDataContractExporter: {
    new(): XsdDataContractExporter$instance;
    new(schemas: XmlSchemaSet): XsdDataContractExporter$instance;
};


export type XsdDataContractExporter = XsdDataContractExporter$instance;

export abstract class DataContractSerializerExtensions$instance {
    static GetSerializationSurrogateProvider(serializer: DataContractSerializer): ISerializationSurrogateProvider;
    static SetSerializationSurrogateProvider(serializer: DataContractSerializer, provider: ISerializationSurrogateProvider): void;
}


export type DataContractSerializerExtensions = DataContractSerializerExtensions$instance;

export abstract class FormatterServices$instance {
    static CheckTypeSecurity(t: Type, securityLevel: TypeFilterLevel): void;
    static GetObjectData(obj: unknown, members: MemberInfo[]): unknown[];
    static GetSafeUninitializedObject(type_: Type): unknown;
    static GetSerializableMembers(type_: Type, context: StreamingContext): MemberInfo[];
    static GetSerializableMembers(type_: Type): MemberInfo[];
    static GetSurrogateForCyclicalReference(innerSurrogate: ISerializationSurrogate): ISerializationSurrogate;
    static GetTypeFromAssembly(assem: Assembly, name: string): Type;
    static GetUninitializedObject(type_: Type): unknown;
    static PopulateObjectMembers(obj: unknown, members: MemberInfo[], data: unknown[]): unknown;
}


export type FormatterServices = FormatterServices$instance;

export abstract class JsonFormatGeneratorStatics$instance {
    static readonly BoxPointer: MethodInfo;
    static readonly CollectionItemNameProperty: PropertyInfo;
    static readonly ExtensionDataObjectCtor: ConstructorInfo;
    static readonly ExtensionDataProperty: PropertyInfo;
    static readonly GetCurrentMethod: MethodInfo;
    static readonly GetItemContractMethod: MethodInfo;
    static readonly GetJsonDataContractMethod: MethodInfo;
    static readonly GetJsonMemberIndexMethod: MethodInfo;
    static readonly GetRevisedItemContractMethod: MethodInfo;
    static readonly GetUninitializedObjectMethod: MethodInfo;
    static readonly IsStartElementMethod0: MethodInfo;
    static readonly IsStartElementMethod2: MethodInfo;
    static readonly LocalNameProperty: PropertyInfo;
    static readonly NamespaceProperty: PropertyInfo;
    static readonly MoveNextMethod: MethodInfo;
    static readonly MoveToContentMethod: MethodInfo;
    static readonly NodeTypeProperty: PropertyInfo;
    static readonly OnDeserializationMethod: MethodInfo;
    static readonly ReadJsonValueMethod: MethodInfo;
    static readonly SerializationExceptionCtor: ConstructorInfo;
    static readonly SerInfoCtorArgs: Type[];
    static readonly ThrowDuplicateMemberExceptionMethod: MethodInfo;
    static readonly ThrowMissingRequiredMembersMethod: MethodInfo;
    static readonly TypeHandleProperty: PropertyInfo;
    static readonly UnboxPointer: MethodInfo;
    static readonly UseSimpleDictionaryFormatReadProperty: PropertyInfo;
    static readonly UseSimpleDictionaryFormatWriteProperty: PropertyInfo;
    static readonly WriteAttributeStringMethod: MethodInfo;
    static readonly WriteEndElementMethod: MethodInfo;
    static readonly WriteJsonISerializableMethod: MethodInfo;
    static readonly WriteJsonNameWithMappingMethod: MethodInfo;
    static readonly WriteJsonValueMethod: MethodInfo;
    static readonly WriteStartElementMethod: MethodInfo;
    static readonly WriteStartElementStringMethod: MethodInfo;
    static readonly ParseEnumMethod: MethodInfo;
    static readonly GetJsonMemberNameMethod: MethodInfo;
}


export type JsonFormatGeneratorStatics = JsonFormatGeneratorStatics$instance;

export abstract class XmlSerializableServices$instance {
    static AddDefaultSchema(schemas: XmlSchemaSet, typeQName: XmlQualifiedName): void;
    static ReadNodes(xmlReader: XmlReader): XmlNode[];
    static WriteNodes(xmlWriter: XmlWriter, nodes: XmlNode[]): void;
}


export type XmlSerializableServices = XmlSerializableServices$instance;

export abstract class XPathQueryGenerator$instance {
    static CreateFromDataContractSerializer(type_: Type, pathToMember: MemberInfo[], rootElementXpath: StringBuilder, namespaces: { value: ref<XmlNamespaceManager> }): string;
    static CreateFromDataContractSerializer(type_: Type, pathToMember: MemberInfo[], namespaces: { value: ref<XmlNamespaceManager> }): string;
}


export type XPathQueryGenerator = XPathQueryGenerator$instance;