@tsonic/dotnet 0.8.0 → 0.8.2

package/System.Xml.Serialization/internal/index.d.ts

@@ -38,16 +38,16 @@ export enum XmlMappingAccess {
 }
 
 
-export type UnreferencedObjectEventHandler = (sender: unknown, e: UnreferencedObjectEventArgs) => void;
+export type UnreferencedObjectEventHandler = (sender: unknown | undefined, e: UnreferencedObjectEventArgs) => void;
 
 
-export type XmlAttributeEventHandler = (sender: unknown, e: XmlAttributeEventArgs) => void;
+export type XmlAttributeEventHandler = (sender: unknown | undefined, e: XmlAttributeEventArgs) => void;
 
 
-export type XmlElementEventHandler = (sender: unknown, e: XmlElementEventArgs) => void;
+export type XmlElementEventHandler = (sender: unknown | undefined, e: XmlElementEventArgs) => void;
 
 
-export type XmlNodeEventHandler = (sender: unknown, e: XmlNodeEventArgs) => void;
+export type XmlNodeEventHandler = (sender: unknown | undefined, e: XmlNodeEventArgs) => void;
 
 
 export type XmlSerializationCollectionFixupCallback = (collection: unknown, collectionItems: unknown) => void;
@@ -80,15 +80,15 @@ export interface IXmlTextParser$instance {
 export type IXmlTextParser = IXmlTextParser$instance;
 
 export interface XmlDeserializationEvents$instance {
-    onUnknownAttribute: XmlAttributeEventHandler;
-    onUnknownElement: XmlElementEventHandler;
-    onUnknownNode: XmlNodeEventHandler;
-    onUnreferencedObject: UnreferencedObjectEventHandler;
+    onUnknownAttribute: XmlAttributeEventHandler | undefined;
+    onUnknownElement: XmlElementEventHandler | undefined;
+    onUnknownNode: XmlNodeEventHandler | undefined;
+    onUnreferencedObject: UnreferencedObjectEventHandler | undefined;
 }
 
 
 export const XmlDeserializationEvents: {
-    new(): XmlDeserializationEvents$instance;
+    new(): XmlDeserializationEvents;
 };
 
 
@@ -99,7 +99,7 @@ export interface CodeIdentifier$instance {
 
 
 export const CodeIdentifier: {
-    new(): CodeIdentifier$instance;
+    new(): CodeIdentifier;
     makeCamel(identifier: string): string;
     makePascal(identifier: string): string;
     makeValid(identifier: string): string;
@@ -110,9 +110,9 @@ export type CodeIdentifier = CodeIdentifier$instance;
 
 export interface CodeIdentifiers$instance {
     useCamelCasing: boolean;
-    add(identifier: string, value: unknown): void;
+    add(identifier: string, value: unknown | undefined): void;
     addReserved(identifier: string): void;
-    addUnique(identifier: string, value: unknown): string;
+    addUnique(identifier: string, value: unknown | undefined): string;
     clear(): void;
     isInUse(identifier: string): boolean;
     makeRightCase(identifier: string): string;
@@ -124,8 +124,8 @@ export interface CodeIdentifiers$instance {
 
 
 export const CodeIdentifiers: {
-    new(): CodeIdentifiers$instance;
-    new(caseSensitive: boolean): CodeIdentifiers$instance;
+    new(): CodeIdentifiers;
+    new(caseSensitive: boolean): CodeIdentifiers;
 };
 
 
@@ -139,7 +139,7 @@ export interface ImportContext$instance {
 
 
 export const ImportContext: {
-    new(identifiers: CodeIdentifiers, shareTypes: boolean): ImportContext$instance;
+    new(identifiers: CodeIdentifiers, shareTypes: boolean): ImportContext;
 };
 
 
@@ -163,41 +163,41 @@ export interface SoapAttributeAttribute$instance extends Attribute {
 
 
 export const SoapAttributeAttribute: {
-    new(): SoapAttributeAttribute$instance;
-    new(attributeName: string): SoapAttributeAttribute$instance;
+    new(): SoapAttributeAttribute;
+    new(attributeName: string): SoapAttributeAttribute;
 };
 
 
 export type SoapAttributeAttribute = SoapAttributeAttribute$instance;
 
 export interface SoapAttributeOverrides$instance {
-    add(type_: Type, attributes: SoapAttributes): void;
-    add(type_: Type, member: string, attributes: SoapAttributes): void;
-    get_Item(type_: Type): SoapAttributes;
-    get_Item(type_: Type, member: string): SoapAttributes;
+    add(type_: Type, attributes: SoapAttributes | undefined): void;
+    add(type_: Type, member: string, attributes: SoapAttributes | undefined): void;
+    get_Item(type_: Type): SoapAttributes | undefined;
+    get_Item(type_: Type, member: string): SoapAttributes | undefined;
 }
 
 
 export const SoapAttributeOverrides: {
-    new(): SoapAttributeOverrides$instance;
+    new(): SoapAttributeOverrides;
 };
 
 
 export type SoapAttributeOverrides = SoapAttributeOverrides$instance;
 
 export interface SoapAttributes$instance {
-    soapAttribute: SoapAttributeAttribute;
-    soapDefaultValue: unknown;
-    soapElement: SoapElementAttribute;
-    soapEnum: SoapEnumAttribute;
+    soapAttribute: SoapAttributeAttribute | undefined;
+    soapDefaultValue: unknown | undefined;
+    soapElement: SoapElementAttribute | undefined;
+    soapEnum: SoapEnumAttribute | undefined;
     soapIgnore: boolean;
-    soapType: SoapTypeAttribute;
+    soapType: SoapTypeAttribute | undefined;
 }
 
 
 export const SoapAttributes: {
-    new(): SoapAttributes$instance;
-    new(provider: ICustomAttributeProvider): SoapAttributes$instance;
+    new(): SoapAttributes;
+    new(provider: ICustomAttributeProvider | undefined): SoapAttributes;
 };
 
 
@@ -211,8 +211,8 @@ export interface SoapElementAttribute$instance extends Attribute {
 
 
 export const SoapElementAttribute: {
-    new(): SoapElementAttribute$instance;
-    new(elementName: string): SoapElementAttribute$instance;
+    new(): SoapElementAttribute;
+    new(elementName: string): SoapElementAttribute;
 };
 
 
@@ -224,8 +224,8 @@ export interface SoapEnumAttribute$instance extends Attribute {
 
 
 export const SoapEnumAttribute: {
-    new(): SoapEnumAttribute$instance;
-    new(name: string): SoapEnumAttribute$instance;
+    new(): SoapEnumAttribute;
+    new(name: string): SoapEnumAttribute;
 };
 
 
@@ -236,7 +236,7 @@ export interface SoapIgnoreAttribute$instance extends Attribute {
 
 
 export const SoapIgnoreAttribute: {
-    new(): SoapIgnoreAttribute$instance;
+    new(): SoapIgnoreAttribute;
 };
 
 
@@ -248,29 +248,29 @@ export interface SoapIncludeAttribute$instance extends Attribute {
 
 
 export const SoapIncludeAttribute: {
-    new(type_: Type): SoapIncludeAttribute$instance;
+    new(type_: Type): SoapIncludeAttribute;
 };
 
 
 export type SoapIncludeAttribute = SoapIncludeAttribute$instance;
 
 export interface SoapReflectionImporter$instance {
-    importMembersMapping(elementName: string, ns: string, members: XmlReflectionMember[]): XmlMembersMapping;
-    importMembersMapping(elementName: string, ns: string, members: XmlReflectionMember[], hasWrapperElement: boolean, writeAccessors: boolean): XmlMembersMapping;
-    importMembersMapping(elementName: string, ns: string, members: XmlReflectionMember[], hasWrapperElement: boolean, writeAccessors: boolean, validate: boolean): XmlMembersMapping;
-    importMembersMapping(elementName: string, ns: string, members: XmlReflectionMember[], hasWrapperElement: boolean, writeAccessors: boolean, validate: boolean, access: XmlMappingAccess): XmlMembersMapping;
+    importMembersMapping(elementName: string | undefined, ns: string | undefined, members: XmlReflectionMember[]): XmlMembersMapping;
+    importMembersMapping(elementName: string | undefined, ns: string | undefined, members: XmlReflectionMember[], hasWrapperElement: boolean, writeAccessors: boolean): XmlMembersMapping;
+    importMembersMapping(elementName: string | undefined, ns: string | undefined, members: XmlReflectionMember[], hasWrapperElement: boolean, writeAccessors: boolean, validate: boolean): XmlMembersMapping;
+    importMembersMapping(elementName: string | undefined, ns: string | undefined, members: XmlReflectionMember[], hasWrapperElement: boolean, writeAccessors: boolean, validate: boolean, access: XmlMappingAccess): XmlMembersMapping;
     importTypeMapping(type_: Type): XmlTypeMapping;
-    importTypeMapping(type_: Type, defaultNamespace: string): XmlTypeMapping;
+    importTypeMapping(type_: Type, defaultNamespace: string | undefined): XmlTypeMapping;
     includeType(type_: Type): void;
     includeTypes(provider: ICustomAttributeProvider): void;
 }
 
 
 export const SoapReflectionImporter: {
-    new(): SoapReflectionImporter$instance;
-    new(defaultNamespace: string): SoapReflectionImporter$instance;
-    new(attributeOverrides: SoapAttributeOverrides): SoapReflectionImporter$instance;
-    new(attributeOverrides: SoapAttributeOverrides, defaultNamespace: string): SoapReflectionImporter$instance;
+    new(): SoapReflectionImporter;
+    new(defaultNamespace: string): SoapReflectionImporter;
+    new(attributeOverrides: SoapAttributeOverrides): SoapReflectionImporter;
+    new(attributeOverrides: SoapAttributeOverrides, defaultNamespace: string): SoapReflectionImporter;
 };
 
 
@@ -278,12 +278,12 @@ export type SoapReflectionImporter = SoapReflectionImporter$instance;
 
 export interface SoapSchemaMember$instance {
     memberName: string;
-    memberType: XmlQualifiedName;
+    memberType: XmlQualifiedName | undefined;
 }
 
 
 export const SoapSchemaMember: {
-    new(): SoapSchemaMember$instance;
+    new(): SoapSchemaMember;
 };
 
 
@@ -297,22 +297,22 @@ export interface SoapTypeAttribute$instance extends Attribute {
 
 
 export const SoapTypeAttribute: {
-    new(): SoapTypeAttribute$instance;
-    new(typeName: string): SoapTypeAttribute$instance;
-    new(typeName: string, ns: string): SoapTypeAttribute$instance;
+    new(): SoapTypeAttribute;
+    new(typeName: string | undefined): SoapTypeAttribute;
+    new(typeName: string | undefined, ns: string | undefined): SoapTypeAttribute;
 };
 
 
 export type SoapTypeAttribute = SoapTypeAttribute$instance;
 
 export interface UnreferencedObjectEventArgs$instance extends EventArgs {
-    readonly unreferencedId: string;
-    readonly unreferencedObject: unknown;
+    readonly unreferencedId: string | undefined;
+    readonly unreferencedObject: unknown | undefined;
 }
 
 
 export const UnreferencedObjectEventArgs: {
-    new(o: unknown, id: string): UnreferencedObjectEventArgs$instance;
+    new(o: unknown | undefined, id: string | undefined): UnreferencedObjectEventArgs;
 };
 
 
@@ -323,7 +323,7 @@ export interface XmlAnyAttributeAttribute$instance extends Attribute {
 
 
 export const XmlAnyAttributeAttribute: {
-    new(): XmlAnyAttributeAttribute$instance;
+    new(): XmlAnyAttributeAttribute;
 };
 
 
@@ -337,9 +337,9 @@ export interface XmlAnyElementAttribute$instance extends Attribute {
 
 
 export const XmlAnyElementAttribute: {
-    new(): XmlAnyElementAttribute$instance;
-    new(name: string): XmlAnyElementAttribute$instance;
-    new(name: string, ns: string): XmlAnyElementAttribute$instance;
+    new(): XmlAnyElementAttribute;
+    new(name: string | undefined): XmlAnyElementAttribute;
+    new(name: string | undefined, ns: string | undefined): XmlAnyElementAttribute;
 };
 
 
@@ -347,20 +347,20 @@ export type XmlAnyElementAttribute = XmlAnyElementAttribute$instance;
 
 export interface XmlAnyElementAttributes$instance extends CollectionBase {
     item: XmlAnyElementAttribute;
-    add(value: unknown): int;
+    add(value: unknown | undefined): int;
     clear(): void;
-    contains(value: unknown): boolean;
+    contains(value: unknown | undefined): boolean;
     copyTo(array: ClrArray, index: int): void;
     getEnumerator(): IEnumerator;
-    indexOf(attribute: XmlAnyElementAttribute): int;
-    insert(index: int, value: unknown): void;
-    remove(value: unknown): void;
+    indexOf(attribute: XmlAnyElementAttribute | undefined): int;
+    insert(index: int, value: unknown | undefined): void;
+    remove(value: unknown | undefined): void;
     removeAt(index: int): void;
 }
 
 
 export const XmlAnyElementAttributes: {
-    new(): XmlAnyElementAttributes$instance;
+    new(): XmlAnyElementAttributes;
 };
 
 
@@ -383,8 +383,8 @@ export interface XmlArrayAttribute$instance extends Attribute {
 
 
 export const XmlArrayAttribute: {
-    new(): XmlArrayAttribute$instance;
-    new(elementName: string): XmlArrayAttribute$instance;
+    new(): XmlArrayAttribute;
+    new(elementName: string | undefined): XmlArrayAttribute;
 };
 
 
@@ -402,10 +402,10 @@ export interface XmlArrayItemAttribute$instance extends Attribute {
 
 
 export const XmlArrayItemAttribute: {
-    new(): XmlArrayItemAttribute$instance;
-    new(elementName: string): XmlArrayItemAttribute$instance;
-    new(type_: Type): XmlArrayItemAttribute$instance;
-    new(elementName: string, type_: Type): XmlArrayItemAttribute$instance;
+    new(): XmlArrayItemAttribute;
+    new(elementName: string | undefined): XmlArrayItemAttribute;
+    new(type_: Type | undefined): XmlArrayItemAttribute;
+    new(elementName: string | undefined, type_: Type | undefined): XmlArrayItemAttribute;
 };
 
 
@@ -413,20 +413,20 @@ export type XmlArrayItemAttribute = XmlArrayItemAttribute$instance;
 
 export interface XmlArrayItemAttributes$instance extends CollectionBase {
     item: XmlArrayItemAttribute;
-    add(value: unknown): int;
+    add(value: unknown | undefined): int;
     clear(): void;
-    contains(value: unknown): boolean;
+    contains(value: unknown | undefined): boolean;
     copyTo(array: ClrArray, index: int): void;
     getEnumerator(): IEnumerator;
-    indexOf(attribute: XmlArrayItemAttribute): int;
-    insert(index: int, value: unknown): void;
-    remove(value: unknown): void;
+    indexOf(attribute: XmlArrayItemAttribute | undefined): int;
+    insert(index: int, value: unknown | undefined): void;
+    remove(value: unknown | undefined): void;
     removeAt(index: int): void;
 }
 
 
 export const XmlArrayItemAttributes: {
-    new(): XmlArrayItemAttributes$instance;
+    new(): XmlArrayItemAttributes;
 };
 
 
@@ -449,10 +449,10 @@ export interface XmlAttributeAttribute$instance extends Attribute {
 
 
 export const XmlAttributeAttribute: {
-    new(): XmlAttributeAttribute$instance;
-    new(attributeName: string): XmlAttributeAttribute$instance;
-    new(type_: Type): XmlAttributeAttribute$instance;
-    new(attributeName: string, type_: Type): XmlAttributeAttribute$instance;
+    new(): XmlAttributeAttribute;
+    new(attributeName: string | undefined): XmlAttributeAttribute;
+    new(type_: Type | undefined): XmlAttributeAttribute;
+    new(attributeName: string | undefined, type_: Type | undefined): XmlAttributeAttribute;
 };
 
 
@@ -463,12 +463,12 @@ export interface XmlAttributeEventArgs$instance extends EventArgs {
     readonly expectedAttributes: string;
     readonly lineNumber: int;
     readonly linePosition: int;
-    readonly objectBeingDeserialized: unknown;
+    readonly objectBeingDeserialized: unknown | undefined;
 }
 
 
 export const XmlAttributeEventArgs: {
-    new(): XmlAttributeEventArgs$instance;
+    new(): XmlAttributeEventArgs;
 };
 
 
@@ -476,40 +476,40 @@ export type XmlAttributeEventArgs = XmlAttributeEventArgs$instance;
 
 export interface XmlAttributeOverrides$instance {
     add(type_: Type, attributes: XmlAttributes): void;
-    add(type_: Type, member: string, attributes: XmlAttributes): void;
-    get_Item(type_: Type): XmlAttributes;
-    get_Item(type_: Type, member: string): XmlAttributes;
+    add(type_: Type, member: string, attributes: XmlAttributes | undefined): void;
+    get_Item(type_: Type): XmlAttributes | undefined;
+    get_Item(type_: Type, member: string): XmlAttributes | undefined;
 }
 
 
 export const XmlAttributeOverrides: {
-    new(): XmlAttributeOverrides$instance;
+    new(): XmlAttributeOverrides;
 };
 
 
 export type XmlAttributeOverrides = XmlAttributeOverrides$instance;
 
 export interface XmlAttributes$instance {
-    xmlAnyAttribute: XmlAnyAttributeAttribute;
+    xmlAnyAttribute: XmlAnyAttributeAttribute | undefined;
     readonly xmlAnyElements: XmlAnyElementAttributes;
-    xmlArray: XmlArrayAttribute;
+    xmlArray: XmlArrayAttribute | undefined;
     readonly xmlArrayItems: XmlArrayItemAttributes;
-    xmlAttribute: XmlAttributeAttribute;
-    readonly xmlChoiceIdentifier: XmlChoiceIdentifierAttribute;
-    xmlDefaultValue: unknown;
+    xmlAttribute: XmlAttributeAttribute | undefined;
+    readonly xmlChoiceIdentifier: XmlChoiceIdentifierAttribute | undefined;
+    xmlDefaultValue: unknown | undefined;
     readonly xmlElements: XmlElementAttributes;
-    xmlEnum: XmlEnumAttribute;
+    xmlEnum: XmlEnumAttribute | undefined;
     xmlIgnore: boolean;
     xmlns: boolean;
-    xmlRoot: XmlRootAttribute;
-    xmlText: XmlTextAttribute;
-    xmlType: XmlTypeAttribute;
+    xmlRoot: XmlRootAttribute | undefined;
+    xmlText: XmlTextAttribute | undefined;
+    xmlType: XmlTypeAttribute | undefined;
 }
 
 
 export const XmlAttributes: {
-    new(): XmlAttributes$instance;
-    new(provider: ICustomAttributeProvider): XmlAttributes$instance;
+    new(): XmlAttributes;
+    new(provider: ICustomAttributeProvider | undefined): XmlAttributes;
 };
 
 
@@ -521,8 +521,8 @@ export interface XmlChoiceIdentifierAttribute$instance extends Attribute {
 
 
 export const XmlChoiceIdentifierAttribute: {
-    new(): XmlChoiceIdentifierAttribute$instance;
-    new(name: string): XmlChoiceIdentifierAttribute$instance;
+    new(): XmlChoiceIdentifierAttribute;
+    new(name: string): XmlChoiceIdentifierAttribute;
 };
 
 
@@ -540,10 +540,10 @@ export interface XmlElementAttribute$instance extends Attribute {
 
 
 export const XmlElementAttribute: {
-    new(): XmlElementAttribute$instance;
-    new(elementName: string): XmlElementAttribute$instance;
-    new(type_: Type): XmlElementAttribute$instance;
-    new(elementName: string, type_: Type): XmlElementAttribute$instance;
+    new(): XmlElementAttribute;
+    new(elementName: string | undefined): XmlElementAttribute;
+    new(type_: Type | undefined): XmlElementAttribute;
+    new(elementName: string | undefined, type_: Type | undefined): XmlElementAttribute;
 };
 
 
@@ -551,20 +551,20 @@ export type XmlElementAttribute = XmlElementAttribute$instance;
 
 export interface XmlElementAttributes$instance extends CollectionBase {
     item: XmlElementAttribute;
-    add(value: unknown): int;
+    add(value: unknown | undefined): int;
     clear(): void;
-    contains(value: unknown): boolean;
+    contains(value: unknown | undefined): boolean;
     copyTo(array: ClrArray, index: int): void;
     getEnumerator(): IEnumerator;
-    indexOf(attribute: XmlElementAttribute): int;
-    insert(index: int, value: unknown): void;
-    remove(value: unknown): void;
+    indexOf(attribute: XmlElementAttribute | undefined): int;
+    insert(index: int, value: unknown | undefined): void;
+    remove(value: unknown | undefined): void;
     removeAt(index: int): void;
 }
 
 
 export const XmlElementAttributes: {
-    new(): XmlElementAttributes$instance;
+    new(): XmlElementAttributes;
 };
 
 
@@ -582,12 +582,12 @@ export interface XmlElementEventArgs$instance extends EventArgs {
     readonly expectedElements: string;
     readonly lineNumber: int;
     readonly linePosition: int;
-    readonly objectBeingDeserialized: unknown;
+    readonly objectBeingDeserialized: unknown | undefined;
 }
 
 
 export const XmlElementEventArgs: {
-    new(): XmlElementEventArgs$instance;
+    new(): XmlElementEventArgs;
 };
 
 
@@ -599,8 +599,8 @@ export interface XmlEnumAttribute$instance extends Attribute {
 
 
 export const XmlEnumAttribute: {
-    new(): XmlEnumAttribute$instance;
-    new(name: string): XmlEnumAttribute$instance;
+    new(): XmlEnumAttribute;
+    new(name: string | undefined): XmlEnumAttribute;
 };
 
 
@@ -611,7 +611,7 @@ export interface XmlIgnoreAttribute$instance extends Attribute {
 
 
 export const XmlIgnoreAttribute: {
-    new(): XmlIgnoreAttribute$instance;
+    new(): XmlIgnoreAttribute;
 };
 
 
@@ -623,7 +623,7 @@ export interface XmlIncludeAttribute$instance extends Attribute {
 
 
 export const XmlIncludeAttribute: {
-    new(type_: Type): XmlIncludeAttribute$instance;
+    new(type_: Type | undefined): XmlIncludeAttribute;
 };
 
 
@@ -651,13 +651,13 @@ export interface XmlMemberMapping$instance {
     readonly namespace_: string;
     readonly typeFullName: string;
     readonly typeName: string;
-    readonly typeNamespace: string;
+    readonly typeNamespace: string | undefined;
     readonly xsdElementName: string;
 }
 
 
 export const XmlMemberMapping: {
-    new(): XmlMemberMapping$instance;
+    new(): XmlMemberMapping;
 };
 
 
@@ -667,12 +667,12 @@ export interface XmlMembersMapping$instance extends XmlMapping {
     readonly count: int;
     readonly item: XmlMemberMapping;
     readonly typeName: string;
-    readonly typeNamespace: string;
+    readonly typeNamespace: string | undefined;
 }
 
 
 export const XmlMembersMapping: {
-    new(): XmlMembersMapping$instance;
+    new(): XmlMembersMapping;
 };
 
 
@@ -683,7 +683,7 @@ export interface XmlNamespaceDeclarationsAttribute$instance extends Attribute {
 
 
 export const XmlNamespaceDeclarationsAttribute: {
-    new(): XmlNamespaceDeclarationsAttribute$instance;
+    new(): XmlNamespaceDeclarationsAttribute;
 };
 
 
@@ -696,37 +696,37 @@ export interface XmlNodeEventArgs$instance extends EventArgs {
     readonly name: string;
     readonly namespaceURI: string;
     readonly nodeType: XmlNodeType;
-    readonly objectBeingDeserialized: unknown;
+    readonly objectBeingDeserialized: unknown | undefined;
     readonly text: string;
 }
 
 
 export const XmlNodeEventArgs: {
-    new(): XmlNodeEventArgs$instance;
+    new(): XmlNodeEventArgs;
 };
 
 
 export type XmlNodeEventArgs = XmlNodeEventArgs$instance;
 
 export interface XmlReflectionImporter$instance {
-    importMembersMapping(elementName: string, ns: string, members: XmlReflectionMember[], hasWrapperElement: boolean): XmlMembersMapping;
-    importMembersMapping(elementName: string, ns: string, members: XmlReflectionMember[], hasWrapperElement: boolean, rpc: boolean): XmlMembersMapping;
-    importMembersMapping(elementName: string, ns: string, members: XmlReflectionMember[], hasWrapperElement: boolean, rpc: boolean, openModel: boolean): XmlMembersMapping;
-    importMembersMapping(elementName: string, ns: string, members: XmlReflectionMember[], hasWrapperElement: boolean, rpc: boolean, openModel: boolean, access: XmlMappingAccess): XmlMembersMapping;
+    importMembersMapping(elementName: string | undefined, ns: string | undefined, members: XmlReflectionMember[], hasWrapperElement: boolean): XmlMembersMapping;
+    importMembersMapping(elementName: string | undefined, ns: string | undefined, members: XmlReflectionMember[], hasWrapperElement: boolean, rpc: boolean): XmlMembersMapping;
+    importMembersMapping(elementName: string | undefined, ns: string | undefined, members: XmlReflectionMember[], hasWrapperElement: boolean, rpc: boolean, openModel: boolean): XmlMembersMapping;
+    importMembersMapping(elementName: string | undefined, ns: string | undefined, members: XmlReflectionMember[], hasWrapperElement: boolean, rpc: boolean, openModel: boolean, access: XmlMappingAccess): XmlMembersMapping;
     importTypeMapping(type_: Type): XmlTypeMapping;
-    importTypeMapping(type_: Type, defaultNamespace: string): XmlTypeMapping;
-    importTypeMapping(type_: Type, root: XmlRootAttribute): XmlTypeMapping;
-    importTypeMapping(type_: Type, root: XmlRootAttribute, defaultNamespace: string): XmlTypeMapping;
+    importTypeMapping(type_: Type, defaultNamespace: string | undefined): XmlTypeMapping;
+    importTypeMapping(type_: Type, root: XmlRootAttribute | undefined): XmlTypeMapping;
+    importTypeMapping(type_: Type, root: XmlRootAttribute | undefined, defaultNamespace: string | undefined): XmlTypeMapping;
     includeType(type_: Type): void;
     includeTypes(provider: ICustomAttributeProvider): void;
 }
 
 
 export const XmlReflectionImporter: {
-    new(): XmlReflectionImporter$instance;
-    new(defaultNamespace: string): XmlReflectionImporter$instance;
-    new(attributeOverrides: XmlAttributeOverrides): XmlReflectionImporter$instance;
-    new(attributeOverrides: XmlAttributeOverrides, defaultNamespace: string): XmlReflectionImporter$instance;
+    new(): XmlReflectionImporter;
+    new(defaultNamespace: string): XmlReflectionImporter;
+    new(attributeOverrides: XmlAttributeOverrides): XmlReflectionImporter;
+    new(attributeOverrides: XmlAttributeOverrides, defaultNamespace: string): XmlReflectionImporter;
 };
 
 
@@ -735,7 +735,7 @@ export type XmlReflectionImporter = XmlReflectionImporter$instance;
 export interface XmlReflectionMember$instance {
     isReturnValue: boolean;
     memberName: string;
-    memberType: Type;
+    memberType: Type | undefined;
     overrideIsNullable: boolean;
     soapAttributes: SoapAttributes;
     xmlAttributes: XmlAttributes;
@@ -743,7 +743,7 @@ export interface XmlReflectionMember$instance {
 
 
 export const XmlReflectionMember: {
-    new(): XmlReflectionMember$instance;
+    new(): XmlReflectionMember;
 };
 
 
@@ -758,8 +758,8 @@ export interface XmlRootAttribute$instance extends Attribute {
 
 
 export const XmlRootAttribute: {
-    new(): XmlRootAttribute$instance;
-    new(elementName: string): XmlRootAttribute$instance;
+    new(): XmlRootAttribute;
+    new(elementName: string): XmlRootAttribute;
 };
 
 
@@ -774,7 +774,7 @@ export interface XmlSchemaEnumerator$instance extends IDisposable {
 
 
 export const XmlSchemaEnumerator: {
-    new(list: XmlSchemas): XmlSchemaEnumerator$instance;
+    new(list: XmlSchemas): XmlSchemaEnumerator;
 };
 
 
@@ -787,40 +787,40 @@ export type XmlSchemaEnumerator = XmlSchemaEnumerator$instance & __XmlSchemaEnum
 
 
 export interface XmlSchemaExporter$instance {
-    exportAnyType(ns: string): string;
-    exportAnyType(members: XmlMembersMapping): string;
+    exportAnyType(ns: string | undefined): string;
+    exportAnyType(members: XmlMembersMapping): string | undefined;
     exportMembersMapping(xmlMembersMapping: XmlMembersMapping): void;
     exportMembersMapping(xmlMembersMapping: XmlMembersMapping, exportEnclosingType: boolean): void;
     exportTypeMapping(xmlTypeMapping: XmlTypeMapping): void;
-    exportTypeMapping(xmlMembersMapping: XmlMembersMapping): XmlQualifiedName;
+    exportTypeMapping(xmlMembersMapping: XmlMembersMapping): XmlQualifiedName | undefined;
 }
 
 
 export const XmlSchemaExporter: {
-    new(schemas: XmlSchemas): XmlSchemaExporter$instance;
+    new(schemas: XmlSchemas): XmlSchemaExporter;
 };
 
 
 export type XmlSchemaExporter = XmlSchemaExporter$instance;
 
 export interface XmlSchemaImporter$instance extends SchemaImporter {
-    importAnyType(typeName: XmlQualifiedName, elementName: string): XmlMembersMapping;
-    importDerivedTypeMapping(name: XmlQualifiedName, baseType: Type): XmlTypeMapping;
-    importDerivedTypeMapping(name: XmlQualifiedName, baseType: Type, baseTypeCanBeIndirect: boolean): XmlTypeMapping;
+    importAnyType(typeName: XmlQualifiedName, elementName: string): XmlMembersMapping | undefined;
+    importDerivedTypeMapping(name: XmlQualifiedName, baseType: Type | undefined): XmlTypeMapping;
+    importDerivedTypeMapping(name: XmlQualifiedName, baseType: Type | undefined, baseTypeCanBeIndirect: boolean): XmlTypeMapping;
     importMembersMapping(name: XmlQualifiedName): XmlMembersMapping;
     importMembersMapping(names: XmlQualifiedName[]): XmlMembersMapping;
-    importMembersMapping(names: XmlQualifiedName[], baseType: Type, baseTypeCanBeIndirect: boolean): XmlMembersMapping;
-    importMembersMapping(name: string, ns: string, members: SoapSchemaMember[]): XmlMembersMapping;
+    importMembersMapping(names: XmlQualifiedName[], baseType: Type | undefined, baseTypeCanBeIndirect: boolean): XmlMembersMapping;
+    importMembersMapping(name: string, ns: string | undefined, members: SoapSchemaMember[]): XmlMembersMapping;
     importSchemaType(typeName: XmlQualifiedName): XmlTypeMapping;
-    importSchemaType(typeName: XmlQualifiedName, baseType: Type): XmlTypeMapping;
-    importSchemaType(typeName: XmlQualifiedName, baseType: Type, baseTypeCanBeIndirect: boolean): XmlTypeMapping;
+    importSchemaType(typeName: XmlQualifiedName, baseType: Type | undefined): XmlTypeMapping;
+    importSchemaType(typeName: XmlQualifiedName, baseType: Type | undefined, baseTypeCanBeIndirect: boolean): XmlTypeMapping;
     importTypeMapping(name: XmlQualifiedName): XmlTypeMapping;
 }
 
 
 export const XmlSchemaImporter: {
-    new(schemas: XmlSchemas): XmlSchemaImporter$instance;
-    new(schemas: XmlSchemas, typeIdentifiers: CodeIdentifiers): XmlSchemaImporter$instance;
+    new(schemas: XmlSchemas): XmlSchemaImporter;
+    new(schemas: XmlSchemas, typeIdentifiers: CodeIdentifiers | undefined): XmlSchemaImporter;
 };
 
 
@@ -833,7 +833,7 @@ export interface XmlSchemaProviderAttribute$instance extends Attribute {
 
 
 export const XmlSchemaProviderAttribute: {
-    new(methodName: string): XmlSchemaProviderAttribute$instance;
+    new(methodName: string | undefined): XmlSchemaProviderAttribute;
 };
 
 
@@ -842,28 +842,28 @@ export type XmlSchemaProviderAttribute = XmlSchemaProviderAttribute$instance;
 export interface XmlSchemas$instance extends CollectionBase {
     readonly isCompiled: boolean;
     add(schemas: XmlSchemas): void;
-    add(value: unknown): int;
+    add(value: unknown | undefined): int;
     addReference(schema: XmlSchema): void;
     clear(): void;
     compile(handler: ValidationEventHandler, fullCompile: boolean): void;
     contains(schema: XmlSchema): boolean;
-    contains(value: unknown): boolean;
+    contains(value: unknown | undefined): boolean;
     copyTo(array: ClrArray, index: int): void;
-    find(name: XmlQualifiedName, type_: Type): unknown;
+    find(name: XmlQualifiedName, type_: Type): unknown | undefined;
     get_Item(index: int): XmlSchema;
     get_Item(ns: string): XmlSchema;
     getEnumerator(): IEnumerator;
-    getSchemas(ns: string): IList;
+    getSchemas(ns: string | undefined): IList;
     indexOf(schema: XmlSchema): int;
-    insert(index: int, value: unknown): void;
-    remove(value: unknown): void;
+    insert(index: int, value: unknown | undefined): void;
+    remove(value: unknown | undefined): void;
     removeAt(index: int): void;
     set_Item(index: int, value: XmlSchema): void;
 }
 
 
 export const XmlSchemas: {
-    new(): XmlSchemas$instance;
+    new(): XmlSchemas;
     isDataSet(schema: XmlSchema): boolean;
 };
 
@@ -911,16 +911,16 @@ export type XmlSerializationWriter = XmlSerializationWriter$instance;
 export interface XmlSerializer$instance {
     canDeserialize(xmlReader: XmlReader): boolean;
     deserialize(stream: Stream): unknown;
-    deserialize(textReader: TextReader): unknown;
-    deserialize(xmlReader: XmlReader): unknown;
-    deserialize(xmlReader: XmlReader, events: XmlDeserializationEvents): unknown;
+    deserialize(textReader: TextReader): unknown | undefined;
+    deserialize(xmlReader: XmlReader): unknown | undefined;
+    deserialize(xmlReader: XmlReader, events: XmlDeserializationEvents): unknown | undefined;
     deserialize(xmlReader: XmlReader, encodingStyle: string): unknown;
     deserialize(xmlReader: XmlReader, encodingStyle: string, events: XmlDeserializationEvents): unknown;
-    serialize(textWriter: TextWriter, o: unknown): void;
+    serialize(textWriter: TextWriter, o: unknown | undefined): void;
     serialize(textWriter: TextWriter, o: unknown, namespaces: XmlSerializerNamespaces): void;
-    serialize(stream: Stream, o: unknown): void;
+    serialize(stream: Stream, o: unknown | undefined): void;
     serialize(stream: Stream, o: unknown, namespaces: XmlSerializerNamespaces): void;
-    serialize(xmlWriter: XmlWriter, o: unknown): void;
+    serialize(xmlWriter: XmlWriter, o: unknown | undefined): void;
     serialize(xmlWriter: XmlWriter, o: unknown, namespaces: XmlSerializerNamespaces): void;
     serialize(xmlWriter: XmlWriter, o: unknown, namespaces: XmlSerializerNamespaces, encodingStyle: string): void;
     serialize(xmlWriter: XmlWriter, o: unknown, namespaces: XmlSerializerNamespaces, encodingStyle: string, id: string): void;
@@ -928,18 +928,18 @@ export interface XmlSerializer$instance {
 
 
 export const XmlSerializer: {
-    new(type_: Type, overrides: XmlAttributeOverrides, extraTypes: Type[], root: XmlRootAttribute, defaultNamespace: string): XmlSerializer$instance;
-    new(type_: Type, root: XmlRootAttribute): XmlSerializer$instance;
-    new(type_: Type, extraTypes: Type[]): XmlSerializer$instance;
-    new(type_: Type, overrides: XmlAttributeOverrides): XmlSerializer$instance;
-    new(xmlTypeMapping: XmlTypeMapping): XmlSerializer$instance;
-    new(type_: Type): XmlSerializer$instance;
-    new(type_: Type, defaultNamespace: string): XmlSerializer$instance;
-    new(type_: Type, overrides: XmlAttributeOverrides, extraTypes: Type[], root: XmlRootAttribute, defaultNamespace: string, location: string): XmlSerializer$instance;
-    fromMappings(mappings: XmlMapping[], type_: Type): XmlSerializer[];
-    fromMappings(mappings: XmlMapping[]): XmlSerializer[];
-    fromTypes(types: Type[]): XmlSerializer[];
-    getXmlSerializerAssemblyName(type_: Type, defaultNamespace: string): string;
+    new(type_: Type, overrides: XmlAttributeOverrides, extraTypes: Type[] | undefined, root: XmlRootAttribute, defaultNamespace: string): XmlSerializer;
+    new(type_: Type, root: XmlRootAttribute | undefined): XmlSerializer;
+    new(type_: Type, extraTypes: Type[] | undefined): XmlSerializer;
+    new(type_: Type, overrides: XmlAttributeOverrides | undefined): XmlSerializer;
+    new(xmlTypeMapping: XmlTypeMapping): XmlSerializer;
+    new(type_: Type): XmlSerializer;
+    new(type_: Type, defaultNamespace: string | undefined): XmlSerializer;
+    new(type_: Type, overrides: XmlAttributeOverrides, extraTypes: Type[] | undefined, root: XmlRootAttribute, defaultNamespace: string, location: string): XmlSerializer;
+    fromMappings(mappings: XmlMapping[] | undefined, type_: Type): (XmlSerializer | undefined)[];
+    fromMappings(mappings: XmlMapping[] | undefined): (XmlSerializer | undefined)[];
+    fromTypes(types: Type[] | undefined): (XmlSerializer | undefined)[];
+    getXmlSerializerAssemblyName(type_: Type, defaultNamespace: string | undefined): string;
     getXmlSerializerAssemblyName(type_: Type): string;
 };
 
@@ -948,33 +948,33 @@ export type XmlSerializer = XmlSerializer$instance;
 
 export interface XmlSerializerAssemblyAttribute$instance extends Attribute {
     assemblyName: string;
-    codeBase: string;
+    codeBase: string | undefined;
 }
 
 
 export const XmlSerializerAssemblyAttribute: {
-    new(): XmlSerializerAssemblyAttribute$instance;
-    new(assemblyName: string): XmlSerializerAssemblyAttribute$instance;
-    new(assemblyName: string, codeBase: string): XmlSerializerAssemblyAttribute$instance;
+    new(): XmlSerializerAssemblyAttribute;
+    new(assemblyName: string | undefined): XmlSerializerAssemblyAttribute;
+    new(assemblyName: string | undefined, codeBase: string | undefined): XmlSerializerAssemblyAttribute;
 };
 
 
 export type XmlSerializerAssemblyAttribute = XmlSerializerAssemblyAttribute$instance;
 
 export interface XmlSerializerFactory$instance {
-    createSerializer(type_: Type, overrides: XmlAttributeOverrides, extraTypes: Type[], root: XmlRootAttribute, defaultNamespace: string): XmlSerializer;
-    createSerializer(type_: Type, root: XmlRootAttribute): XmlSerializer;
-    createSerializer(type_: Type, extraTypes: Type[]): XmlSerializer;
-    createSerializer(type_: Type, overrides: XmlAttributeOverrides): XmlSerializer;
+    createSerializer(type_: Type, overrides: XmlAttributeOverrides, extraTypes: Type[] | undefined, root: XmlRootAttribute, defaultNamespace: string): XmlSerializer;
+    createSerializer(type_: Type, root: XmlRootAttribute | undefined): XmlSerializer;
+    createSerializer(type_: Type, extraTypes: Type[] | undefined): XmlSerializer;
+    createSerializer(type_: Type, overrides: XmlAttributeOverrides | undefined): XmlSerializer;
     createSerializer(xmlTypeMapping: XmlTypeMapping): XmlSerializer;
     createSerializer(type_: Type): XmlSerializer;
-    createSerializer(type_: Type, defaultNamespace: string): XmlSerializer;
-    createSerializer(type_: Type, overrides: XmlAttributeOverrides, extraTypes: Type[], root: XmlRootAttribute, defaultNamespace: string, location: string): XmlSerializer;
+    createSerializer(type_: Type, defaultNamespace: string | undefined): XmlSerializer;
+    createSerializer(type_: Type, overrides: XmlAttributeOverrides, extraTypes: Type[] | undefined, root: XmlRootAttribute, defaultNamespace: string, location: string): XmlSerializer;
 }
 
 
 export const XmlSerializerFactory: {
-    new(): XmlSerializerFactory$instance;
+    new(): XmlSerializerFactory;
 };
 
 
@@ -999,15 +999,15 @@ export type XmlSerializerImplementation = XmlSerializerImplementation$instance;
 
 export interface XmlSerializerNamespaces$instance {
     readonly count: int;
-    add(prefix: string, ns: string): void;
+    add(prefix: string, ns: string | undefined): void;
     toArray(): XmlQualifiedName[];
 }
 
 
 export const XmlSerializerNamespaces: {
-    new(): XmlSerializerNamespaces$instance;
-    new(namespaces: XmlSerializerNamespaces): XmlSerializerNamespaces$instance;
-    new(namespaces: XmlQualifiedName[]): XmlSerializerNamespaces$instance;
+    new(): XmlSerializerNamespaces;
+    new(namespaces: XmlSerializerNamespaces): XmlSerializerNamespaces;
+    new(namespaces: XmlQualifiedName[]): XmlSerializerNamespaces;
 };
 
 
@@ -1015,15 +1015,15 @@ export type XmlSerializerNamespaces = XmlSerializerNamespaces$instance;
 
 export interface XmlSerializerVersionAttribute$instance extends Attribute {
     namespace_: string;
-    parentAssemblyId: string;
+    parentAssemblyId: string | undefined;
     type_: Type;
     version: string;
 }
 
 
 export const XmlSerializerVersionAttribute: {
-    new(): XmlSerializerVersionAttribute$instance;
-    new(type_: Type): XmlSerializerVersionAttribute$instance;
+    new(): XmlSerializerVersionAttribute;
+    new(type_: Type | undefined): XmlSerializerVersionAttribute;
 };
 
 
@@ -1036,8 +1036,8 @@ export interface XmlTextAttribute$instance extends Attribute {
 
 
 export const XmlTextAttribute: {
-    new(): XmlTextAttribute$instance;
-    new(type_: Type): XmlTextAttribute$instance;
+    new(): XmlTextAttribute;
+    new(type_: Type | undefined): XmlTextAttribute;
 };
 
 
@@ -1052,8 +1052,8 @@ export interface XmlTypeAttribute$instance extends Attribute {
 
 
 export const XmlTypeAttribute: {
-    new(): XmlTypeAttribute$instance;
-    new(typeName: string): XmlTypeAttribute$instance;
+    new(): XmlTypeAttribute;
+    new(typeName: string | undefined): XmlTypeAttribute;
 };
 
 
@@ -1062,13 +1062,13 @@ export type XmlTypeAttribute = XmlTypeAttribute$instance;
 export interface XmlTypeMapping$instance extends XmlMapping {
     readonly typeFullName: string;
     readonly typeName: string;
-    readonly xsdTypeName: string;
-    readonly xsdTypeNamespace: string;
+    readonly xsdTypeName: string | undefined;
+    readonly xsdTypeNamespace: string | undefined;
 }
 
 
 export const XmlTypeMapping: {
-    new(): XmlTypeMapping$instance;
+    new(): XmlTypeMapping;
 };