@tsonic/dotnet 0.8.0 → 0.8.2

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

@@ -158,7 +158,7 @@ export enum XmlTypeCode {
 }
 
 
-export type ValidationEventHandler = (sender: unknown, e: ValidationEventArgs) => void;
+export type ValidationEventHandler = (sender: unknown | undefined, e: ValidationEventArgs) => void;
 
 
 export type XmlValueGetter = () => unknown;
@@ -168,10 +168,10 @@ export interface IXmlSchemaInfo$instance {
     readonly validity: XmlSchemaValidity;
     readonly isDefault: boolean;
     readonly isNil: boolean;
-    readonly memberType: XmlSchemaSimpleType;
-    readonly schemaType: XmlSchemaType;
-    readonly schemaElement: XmlSchemaElement;
-    readonly schemaAttribute: XmlSchemaAttribute;
+    readonly memberType: XmlSchemaSimpleType | undefined;
+    readonly schemaType: XmlSchemaType | undefined;
+    readonly schemaElement: XmlSchemaElement | undefined;
+    readonly schemaAttribute: XmlSchemaAttribute | undefined;
 }
 
 
@@ -185,7 +185,7 @@ export interface ValidationEventArgs$instance extends EventArgs {
 
 
 export const ValidationEventArgs: {
-    new(): ValidationEventArgs$instance;
+    new(): ValidationEventArgs;
 };
 
 
@@ -201,16 +201,16 @@ export interface XmlAtomicValue$instance extends XPathItem {
     readonly valueAsInt: int;
     readonly valueAsLong: long;
     readonly valueType: Type;
-    readonly xmlType: XmlSchemaType;
+    readonly xmlType: XmlSchemaType | XmlSchemaType | undefined;
     clone(): XmlAtomicValue;
     toString(): string;
-    valueAs(type_: Type, nsResolver: IXmlNamespaceResolver): unknown;
+    valueAs(type_: Type, nsResolver: IXmlNamespaceResolver | undefined): unknown;
     valueAs(returnType: Type): unknown;
 }
 
 
 export const XmlAtomicValue: {
-    new(): XmlAtomicValue$instance;
+    new(): XmlAtomicValue;
 };
 
 
@@ -236,22 +236,22 @@ export interface XmlSchema$instance extends XmlSchemaObject {
     readonly items: XmlSchemaObjectCollection;
     readonly notations: XmlSchemaObjectTable;
     readonly schemaTypes: XmlSchemaObjectTable;
-    targetNamespace: string;
-    unhandledAttributes: XmlAttribute[];
+    targetNamespace: string | undefined;
+    unhandledAttributes: XmlAttribute[] | undefined;
     version: string;
     compile(validationEventHandler: ValidationEventHandler): void;
     compile(validationEventHandler: ValidationEventHandler, resolver: XmlResolver): void;
     write(stream: Stream): void;
-    write(stream: Stream, namespaceManager: XmlNamespaceManager): void;
+    write(stream: Stream, namespaceManager: XmlNamespaceManager | undefined): void;
     write(writer: TextWriter): void;
-    write(writer: TextWriter, namespaceManager: XmlNamespaceManager): void;
+    write(writer: TextWriter, namespaceManager: XmlNamespaceManager | undefined): void;
     write(writer: XmlWriter): void;
-    write(writer: XmlWriter, namespaceManager: XmlNamespaceManager): void;
+    write(writer: XmlWriter, namespaceManager: XmlNamespaceManager | undefined): void;
 }
 
 
 export const XmlSchema: {
-    new(): XmlSchema$instance;
+    new(): XmlSchema;
     readonly namespace_: string;
     readonly instanceNamespace: string;
     read(stream: Stream, validationEventHandler: ValidationEventHandler): XmlSchema;
@@ -268,21 +268,21 @@ export interface XmlSchemaAll$instance extends XmlSchemaGroupBase {
 
 
 export const XmlSchemaAll: {
-    new(): XmlSchemaAll$instance;
+    new(): XmlSchemaAll;
 };
 
 
 export type XmlSchemaAll = XmlSchemaAll$instance;
 
 export interface XmlSchemaAnnotated$instance extends XmlSchemaObject {
-    annotation: XmlSchemaAnnotation;
+    annotation: XmlSchemaAnnotation | undefined;
     id: string;
-    unhandledAttributes: XmlAttribute[];
+    unhandledAttributes: XmlAttribute[] | undefined;
 }
 
 
 export const XmlSchemaAnnotated: {
-    new(): XmlSchemaAnnotated$instance;
+    new(): XmlSchemaAnnotated;
 };
 
 
@@ -291,12 +291,12 @@ export type XmlSchemaAnnotated = XmlSchemaAnnotated$instance;
 export interface XmlSchemaAnnotation$instance extends XmlSchemaObject {
     id: string;
     readonly items: XmlSchemaObjectCollection;
-    unhandledAttributes: XmlAttribute[];
+    unhandledAttributes: XmlAttribute[] | undefined;
 }
 
 
 export const XmlSchemaAnnotation: {
-    new(): XmlSchemaAnnotation$instance;
+    new(): XmlSchemaAnnotation;
 };
 
 
@@ -309,7 +309,7 @@ export interface XmlSchemaAny$instance extends XmlSchemaParticle {
 
 
 export const XmlSchemaAny: {
-    new(): XmlSchemaAny$instance;
+    new(): XmlSchemaAny;
 };
 
 
@@ -322,58 +322,58 @@ export interface XmlSchemaAnyAttribute$instance extends XmlSchemaAnnotated {
 
 
 export const XmlSchemaAnyAttribute: {
-    new(): XmlSchemaAnyAttribute$instance;
+    new(): XmlSchemaAnyAttribute;
 };
 
 
 export type XmlSchemaAnyAttribute = XmlSchemaAnyAttribute$instance;
 
 export interface XmlSchemaAppInfo$instance extends XmlSchemaObject {
-    markup: XmlNode[];
+    markup: (XmlNode | undefined)[] | undefined;
     source: string;
 }
 
 
 export const XmlSchemaAppInfo: {
-    new(): XmlSchemaAppInfo$instance;
+    new(): XmlSchemaAppInfo;
 };
 
 
 export type XmlSchemaAppInfo = XmlSchemaAppInfo$instance;
 
 export interface XmlSchemaAttribute$instance extends XmlSchemaAnnotated {
-    readonly attributeSchemaType: XmlSchemaSimpleType;
+    readonly attributeSchemaType: XmlSchemaSimpleType | undefined;
     readonly attributeType: unknown;
     defaultValue: string;
-    fixedValue: string;
+    fixedValue: string | undefined;
     form: XmlSchemaForm;
     name: string;
     readonly qualifiedName: XmlQualifiedName;
     refName: XmlQualifiedName;
-    schemaType: XmlSchemaSimpleType;
+    schemaType: XmlSchemaSimpleType | undefined;
     schemaTypeName: XmlQualifiedName;
     use: XmlSchemaUse;
 }
 
 
 export const XmlSchemaAttribute: {
-    new(): XmlSchemaAttribute$instance;
+    new(): XmlSchemaAttribute;
 };
 
 
 export type XmlSchemaAttribute = XmlSchemaAttribute$instance;
 
 export interface XmlSchemaAttributeGroup$instance extends XmlSchemaAnnotated {
-    anyAttribute: XmlSchemaAnyAttribute;
+    anyAttribute: XmlSchemaAnyAttribute | undefined;
     readonly attributes: XmlSchemaObjectCollection;
     name: string;
     readonly qualifiedName: XmlQualifiedName;
-    readonly redefinedAttributeGroup: XmlSchemaAttributeGroup;
+    readonly redefinedAttributeGroup: XmlSchemaAttributeGroup | undefined;
 }
 
 
 export const XmlSchemaAttributeGroup: {
-    new(): XmlSchemaAttributeGroup$instance;
+    new(): XmlSchemaAttributeGroup;
 };
 
 
@@ -385,7 +385,7 @@ export interface XmlSchemaAttributeGroupRef$instance extends XmlSchemaAnnotated
 
 
 export const XmlSchemaAttributeGroupRef: {
-    new(): XmlSchemaAttributeGroupRef$instance;
+    new(): XmlSchemaAttributeGroupRef;
 };
 
 
@@ -397,7 +397,7 @@ export interface XmlSchemaChoice$instance extends XmlSchemaGroupBase {
 
 
 export const XmlSchemaChoice: {
-    new(): XmlSchemaChoice$instance;
+    new(): XmlSchemaChoice;
 };
 
 
@@ -410,7 +410,7 @@ export interface XmlSchemaCollection$instance {
     add(ns: string, uri: string): XmlSchema;
     add(ns: string, reader: XmlReader): XmlSchema;
     add(ns: string, reader: XmlReader, resolver: XmlResolver): XmlSchema;
-    add(schema: XmlSchema): XmlSchema;
+    add(schema: XmlSchema): XmlSchema | undefined;
     add(schema: XmlSchema, resolver: XmlResolver): XmlSchema;
     add(schema: XmlSchemaCollection): void;
     contains(schema: XmlSchema): boolean;
@@ -421,8 +421,8 @@ export interface XmlSchemaCollection$instance {
 
 
 export const XmlSchemaCollection: {
-    new(): XmlSchemaCollection$instance;
-    new(nametable: XmlNameTable): XmlSchemaCollection$instance;
+    new(): XmlSchemaCollection;
+    new(nametable: XmlNameTable): XmlSchemaCollection;
 };
 
 
@@ -435,14 +435,14 @@ export type XmlSchemaCollection = XmlSchemaCollection$instance & __XmlSchemaColl
 
 
 export interface XmlSchemaCollectionEnumerator$instance {
-    readonly current: unknown | XmlSchema;
+    readonly current: XmlSchema;
     moveNext(): boolean;
     reset(): void;
 }
 
 
 export const XmlSchemaCollectionEnumerator: {
-    new(): XmlSchemaCollectionEnumerator$instance;
+    new(): XmlSchemaCollectionEnumerator;
 };
 
 
@@ -459,7 +459,7 @@ export interface XmlSchemaCompilationSettings$instance {
 
 
 export const XmlSchemaCompilationSettings: {
-    new(): XmlSchemaCompilationSettings$instance;
+    new(): XmlSchemaCompilationSettings;
 };
 
 
@@ -472,60 +472,60 @@ export interface XmlSchemaComplexContent$instance extends XmlSchemaContentModel
 
 
 export const XmlSchemaComplexContent: {
-    new(): XmlSchemaComplexContent$instance;
+    new(): XmlSchemaComplexContent;
 };
 
 
 export type XmlSchemaComplexContent = XmlSchemaComplexContent$instance;
 
 export interface XmlSchemaComplexContentExtension$instance extends XmlSchemaContent {
-    anyAttribute: XmlSchemaAnyAttribute;
+    anyAttribute: XmlSchemaAnyAttribute | undefined;
     readonly attributes: XmlSchemaObjectCollection;
     baseTypeName: XmlQualifiedName;
-    particle: XmlSchemaParticle;
+    particle: XmlSchemaParticle | undefined;
 }
 
 
 export const XmlSchemaComplexContentExtension: {
-    new(): XmlSchemaComplexContentExtension$instance;
+    new(): XmlSchemaComplexContentExtension;
 };
 
 
 export type XmlSchemaComplexContentExtension = XmlSchemaComplexContentExtension$instance;
 
 export interface XmlSchemaComplexContentRestriction$instance extends XmlSchemaContent {
-    anyAttribute: XmlSchemaAnyAttribute;
+    anyAttribute: XmlSchemaAnyAttribute | undefined;
     readonly attributes: XmlSchemaObjectCollection;
     baseTypeName: XmlQualifiedName;
-    particle: XmlSchemaParticle;
+    particle: XmlSchemaParticle | undefined;
 }
 
 
 export const XmlSchemaComplexContentRestriction: {
-    new(): XmlSchemaComplexContentRestriction$instance;
+    new(): XmlSchemaComplexContentRestriction;
 };
 
 
 export type XmlSchemaComplexContentRestriction = XmlSchemaComplexContentRestriction$instance;
 
 export interface XmlSchemaComplexType$instance extends XmlSchemaType {
-    anyAttribute: XmlSchemaAnyAttribute;
+    anyAttribute: XmlSchemaAnyAttribute | undefined;
     readonly attributes: XmlSchemaObjectCollection;
     readonly attributeUses: XmlSchemaObjectTable;
-    readonly attributeWildcard: XmlSchemaAnyAttribute;
+    readonly attributeWildcard: XmlSchemaAnyAttribute | undefined;
     block: XmlSchemaDerivationMethod;
     readonly blockResolved: XmlSchemaDerivationMethod;
-    contentModel: XmlSchemaContentModel;
+    contentModel: XmlSchemaContentModel | undefined;
     readonly contentType: XmlSchemaContentType;
     readonly contentTypeParticle: XmlSchemaParticle;
     isAbstract: boolean;
     isMixed: boolean;
-    particle: XmlSchemaParticle;
+    particle: XmlSchemaParticle | undefined;
 }
 
 
 export const XmlSchemaComplexType: {
-    new(): XmlSchemaComplexType$instance;
+    new(): XmlSchemaComplexType;
 };
 
 
@@ -560,7 +560,7 @@ export interface XmlSchemaDatatype$instance {
     changeType(value: unknown, targetType: Type): unknown;
     changeType(value: unknown, targetType: Type, namespaceResolver: IXmlNamespaceResolver): unknown;
     isDerivedFrom(datatype: XmlSchemaDatatype): boolean;
-    parseValue(s: string, nameTable: XmlNameTable, nsmgr: IXmlNamespaceResolver): unknown;
+    parseValue(s: string, nameTable: XmlNameTable | undefined, nsmgr: IXmlNamespaceResolver | undefined): unknown;
 }
 
 
@@ -571,14 +571,14 @@ export const XmlSchemaDatatype: {
 export type XmlSchemaDatatype = XmlSchemaDatatype$instance;
 
 export interface XmlSchemaDocumentation$instance extends XmlSchemaObject {
-    language: string;
-    markup: XmlNode[];
+    language: string | undefined;
+    markup: (XmlNode | undefined)[] | undefined;
     source: string;
 }
 
 
 export const XmlSchemaDocumentation: {
-    new(): XmlSchemaDocumentation$instance;
+    new(): XmlSchemaDocumentation;
 };
 
 
@@ -589,25 +589,25 @@ export interface XmlSchemaElement$instance extends XmlSchemaParticle {
     readonly blockResolved: XmlSchemaDerivationMethod;
     readonly constraints: XmlSchemaObjectCollection;
     defaultValue: string;
-    readonly elementSchemaType: XmlSchemaType;
+    readonly elementSchemaType: XmlSchemaType | undefined;
     readonly elementType: unknown;
     final: XmlSchemaDerivationMethod;
     readonly finalResolved: XmlSchemaDerivationMethod;
-    fixedValue: string;
+    fixedValue: string | undefined;
     form: XmlSchemaForm;
     isAbstract: boolean;
     isNillable: boolean;
     name: string;
     readonly qualifiedName: XmlQualifiedName;
     refName: XmlQualifiedName;
-    schemaType: XmlSchemaType;
+    schemaType: XmlSchemaType | undefined;
     schemaTypeName: XmlQualifiedName;
     substitutionGroup: XmlQualifiedName;
 }
 
 
 export const XmlSchemaElement: {
-    new(): XmlSchemaElement$instance;
+    new(): XmlSchemaElement;
 };
 
 
@@ -618,7 +618,7 @@ export interface XmlSchemaEnumerationFacet$instance extends XmlSchemaFacet {
 
 
 export const XmlSchemaEnumerationFacet: {
-    new(): XmlSchemaEnumerationFacet$instance;
+    new(): XmlSchemaEnumerationFacet;
 };
 
 
@@ -628,17 +628,17 @@ export interface XmlSchemaException$instance extends SystemException {
     readonly lineNumber: int;
     readonly linePosition: int;
     readonly message: string;
-    readonly sourceSchemaObject: XmlSchemaObject;
-    readonly sourceUri: string;
-    getObjectData(info: SerializationInfo, context: StreamingContext): void;
+    readonly sourceSchemaObject: XmlSchemaObject | undefined;
+    readonly sourceUri: string | undefined;
+    getObjectData(info: SerializationInfo | undefined, context: StreamingContext): void;
 }
 
 
 export const XmlSchemaException: {
-    new(): XmlSchemaException$instance;
-    new(message: string): XmlSchemaException$instance;
-    new(message: string, innerException: Exception): XmlSchemaException$instance;
-    new(message: string, innerException: Exception, lineNumber: int, linePosition: int): XmlSchemaException$instance;
+    new(): XmlSchemaException;
+    new(message: string | undefined): XmlSchemaException;
+    new(message: string | undefined, innerException: Exception | undefined): XmlSchemaException;
+    new(message: string | undefined, innerException: Exception | undefined, lineNumber: int, linePosition: int): XmlSchemaException;
 };
 
 
@@ -651,9 +651,9 @@ export type XmlSchemaException = XmlSchemaException$instance & __XmlSchemaExcept
 
 export interface XmlSchemaExternal$instance extends XmlSchemaObject {
     id: string;
-    schema: XmlSchema;
-    schemaLocation: string;
-    unhandledAttributes: XmlAttribute[];
+    schema: XmlSchema | undefined;
+    schemaLocation: string | undefined;
+    unhandledAttributes: XmlAttribute[] | undefined;
 }
 
 
@@ -680,7 +680,7 @@ export interface XmlSchemaFractionDigitsFacet$instance extends XmlSchemaNumericF
 
 
 export const XmlSchemaFractionDigitsFacet: {
-    new(): XmlSchemaFractionDigitsFacet$instance;
+    new(): XmlSchemaFractionDigitsFacet;
 };
 
 
@@ -688,13 +688,13 @@ export type XmlSchemaFractionDigitsFacet = XmlSchemaFractionDigitsFacet$instance
 
 export interface XmlSchemaGroup$instance extends XmlSchemaAnnotated {
     name: string;
-    particle: XmlSchemaGroupBase;
+    particle: XmlSchemaGroupBase | undefined;
     readonly qualifiedName: XmlQualifiedName;
 }
 
 
 export const XmlSchemaGroup: {
-    new(): XmlSchemaGroup$instance;
+    new(): XmlSchemaGroup;
 };
 
 
@@ -712,13 +712,13 @@ export const XmlSchemaGroupBase: {
 export type XmlSchemaGroupBase = XmlSchemaGroupBase$instance;
 
 export interface XmlSchemaGroupRef$instance extends XmlSchemaParticle {
-    readonly particle: XmlSchemaGroupBase;
+    readonly particle: XmlSchemaGroupBase | undefined;
     refName: XmlQualifiedName;
 }
 
 
 export const XmlSchemaGroupRef: {
-    new(): XmlSchemaGroupRef$instance;
+    new(): XmlSchemaGroupRef;
 };
 
 
@@ -728,37 +728,37 @@ export interface XmlSchemaIdentityConstraint$instance extends XmlSchemaAnnotated
     readonly fields: XmlSchemaObjectCollection;
     name: string;
     readonly qualifiedName: XmlQualifiedName;
-    selector: XmlSchemaXPath;
+    selector: XmlSchemaXPath | undefined;
 }
 
 
 export const XmlSchemaIdentityConstraint: {
-    new(): XmlSchemaIdentityConstraint$instance;
+    new(): XmlSchemaIdentityConstraint;
 };
 
 
 export type XmlSchemaIdentityConstraint = XmlSchemaIdentityConstraint$instance;
 
 export interface XmlSchemaImport$instance extends XmlSchemaExternal {
-    annotation: XmlSchemaAnnotation;
+    annotation: XmlSchemaAnnotation | undefined;
     namespace_: string;
 }
 
 
 export const XmlSchemaImport: {
-    new(): XmlSchemaImport$instance;
+    new(): XmlSchemaImport;
 };
 
 
 export type XmlSchemaImport = XmlSchemaImport$instance;
 
 export interface XmlSchemaInclude$instance extends XmlSchemaExternal {
-    annotation: XmlSchemaAnnotation;
+    annotation: XmlSchemaAnnotation | undefined;
 }
 
 
 export const XmlSchemaInclude: {
-    new(): XmlSchemaInclude$instance;
+    new(): XmlSchemaInclude;
 };
 
 
@@ -773,7 +773,7 @@ export interface XmlSchemaInference$instance {
 
 
 export const XmlSchemaInference: {
-    new(): XmlSchemaInference$instance;
+    new(): XmlSchemaInference;
 };
 
 
@@ -785,10 +785,10 @@ export interface XmlSchemaInferenceException$instance extends XmlSchemaException
 
 
 export const XmlSchemaInferenceException: {
-    new(): XmlSchemaInferenceException$instance;
-    new(message: string): XmlSchemaInferenceException$instance;
-    new(message: string, innerException: Exception): XmlSchemaInferenceException$instance;
-    new(message: string, innerException: Exception, lineNumber: int, linePosition: int): XmlSchemaInferenceException$instance;
+    new(): XmlSchemaInferenceException;
+    new(message: string): XmlSchemaInferenceException;
+    new(message: string, innerException: Exception | undefined): XmlSchemaInferenceException;
+    new(message: string, innerException: Exception | undefined, lineNumber: int, linePosition: int): XmlSchemaInferenceException;
 };
 
 
@@ -803,16 +803,16 @@ export interface XmlSchemaInfo$instance {
     contentType: XmlSchemaContentType;
     isDefault: boolean;
     isNil: boolean;
-    memberType: XmlSchemaSimpleType;
-    schemaAttribute: XmlSchemaAttribute;
-    schemaElement: XmlSchemaElement;
-    schemaType: XmlSchemaType;
+    memberType: XmlSchemaSimpleType | undefined;
+    schemaAttribute: XmlSchemaAttribute | undefined;
+    schemaElement: XmlSchemaElement | undefined;
+    schemaType: XmlSchemaType | undefined;
     validity: XmlSchemaValidity;
 }
 
 
 export const XmlSchemaInfo: {
-    new(): XmlSchemaInfo$instance;
+    new(): XmlSchemaInfo;
 };
 
 
@@ -828,7 +828,7 @@ export interface XmlSchemaKey$instance extends XmlSchemaIdentityConstraint {
 
 
 export const XmlSchemaKey: {
-    new(): XmlSchemaKey$instance;
+    new(): XmlSchemaKey;
 };
 
 
@@ -840,7 +840,7 @@ export interface XmlSchemaKeyref$instance extends XmlSchemaIdentityConstraint {
 
 
 export const XmlSchemaKeyref: {
-    new(): XmlSchemaKeyref$instance;
+    new(): XmlSchemaKeyref;
 };
 
 
@@ -851,7 +851,7 @@ export interface XmlSchemaLengthFacet$instance extends XmlSchemaNumericFacet {
 
 
 export const XmlSchemaLengthFacet: {
-    new(): XmlSchemaLengthFacet$instance;
+    new(): XmlSchemaLengthFacet;
 };
 
 
@@ -862,7 +862,7 @@ export interface XmlSchemaMaxExclusiveFacet$instance extends XmlSchemaFacet {
 
 
 export const XmlSchemaMaxExclusiveFacet: {
-    new(): XmlSchemaMaxExclusiveFacet$instance;
+    new(): XmlSchemaMaxExclusiveFacet;
 };
 
 
@@ -873,7 +873,7 @@ export interface XmlSchemaMaxInclusiveFacet$instance extends XmlSchemaFacet {
 
 
 export const XmlSchemaMaxInclusiveFacet: {
-    new(): XmlSchemaMaxInclusiveFacet$instance;
+    new(): XmlSchemaMaxInclusiveFacet;
 };
 
 
@@ -884,7 +884,7 @@ export interface XmlSchemaMaxLengthFacet$instance extends XmlSchemaNumericFacet
 
 
 export const XmlSchemaMaxLengthFacet: {
-    new(): XmlSchemaMaxLengthFacet$instance;
+    new(): XmlSchemaMaxLengthFacet;
 };
 
 
@@ -895,7 +895,7 @@ export interface XmlSchemaMinExclusiveFacet$instance extends XmlSchemaFacet {
 
 
 export const XmlSchemaMinExclusiveFacet: {
-    new(): XmlSchemaMinExclusiveFacet$instance;
+    new(): XmlSchemaMinExclusiveFacet;
 };
 
 
@@ -906,7 +906,7 @@ export interface XmlSchemaMinInclusiveFacet$instance extends XmlSchemaFacet {
 
 
 export const XmlSchemaMinInclusiveFacet: {
-    new(): XmlSchemaMinInclusiveFacet$instance;
+    new(): XmlSchemaMinInclusiveFacet;
 };
 
 
@@ -917,7 +917,7 @@ export interface XmlSchemaMinLengthFacet$instance extends XmlSchemaNumericFacet
 
 
 export const XmlSchemaMinLengthFacet: {
-    new(): XmlSchemaMinLengthFacet$instance;
+    new(): XmlSchemaMinLengthFacet;
 };
 
 
@@ -925,13 +925,13 @@ export type XmlSchemaMinLengthFacet = XmlSchemaMinLengthFacet$instance;
 
 export interface XmlSchemaNotation$instance extends XmlSchemaAnnotated {
     name: string;
-    public_: string;
-    system: string;
+    public_: string | undefined;
+    system: string | undefined;
 }
 
 
 export const XmlSchemaNotation: {
-    new(): XmlSchemaNotation$instance;
+    new(): XmlSchemaNotation;
 };
 
 
@@ -952,7 +952,7 @@ export interface XmlSchemaObject$instance {
     linePosition: int;
     namespaces: XmlSerializerNamespaces;
     parent: XmlSchemaObject;
-    sourceUri: string;
+    sourceUri: string | undefined;
 }
 
 
@@ -964,21 +964,21 @@ export type XmlSchemaObject = XmlSchemaObject$instance;
 
 export interface XmlSchemaObjectCollection$instance extends CollectionBase {
     item: XmlSchemaObject;
-    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(item: XmlSchemaObject): 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;
 }
 
 
 export const XmlSchemaObjectCollection: {
-    new(): XmlSchemaObjectCollection$instance;
-    new(parent: XmlSchemaObject): XmlSchemaObjectCollection$instance;
+    new(): XmlSchemaObjectCollection;
+    new(parent: XmlSchemaObject): XmlSchemaObjectCollection;
 };
 
 
@@ -992,14 +992,14 @@ export type XmlSchemaObjectCollection = XmlSchemaObjectCollection$instance & __X
 
 
 export interface XmlSchemaObjectEnumerator$instance {
-    readonly current: unknown | XmlSchemaObject;
+    readonly current: XmlSchemaObject;
     moveNext(): boolean;
     reset(): void;
 }
 
 
 export const XmlSchemaObjectEnumerator: {
-    new(): XmlSchemaObjectEnumerator$instance;
+    new(): XmlSchemaObjectEnumerator;
 };
 
 
@@ -1012,7 +1012,7 @@ export type XmlSchemaObjectEnumerator = XmlSchemaObjectEnumerator$instance & __X
 
 export interface XmlSchemaObjectTable$instance {
     readonly count: int;
-    readonly item: XmlSchemaObject;
+    readonly item: XmlSchemaObject | undefined;
     readonly names: ICollection;
     readonly values: ICollection;
     contains(name: XmlQualifiedName): boolean;
@@ -1021,7 +1021,7 @@ export interface XmlSchemaObjectTable$instance {
 
 
 export const XmlSchemaObjectTable: {
-    new(): XmlSchemaObjectTable$instance;
+    new(): XmlSchemaObjectTable;
 };
 
 
@@ -1029,9 +1029,9 @@ export type XmlSchemaObjectTable = XmlSchemaObjectTable$instance;
 
 export interface XmlSchemaParticle$instance extends XmlSchemaAnnotated {
     maxOccurs: decimal;
-    maxOccursString: string;
+    maxOccursString: string | undefined;
     minOccurs: decimal;
-    minOccursString: string;
+    minOccursString: string | undefined;
 }
 
 
@@ -1046,7 +1046,7 @@ export interface XmlSchemaPatternFacet$instance extends XmlSchemaFacet {
 
 
 export const XmlSchemaPatternFacet: {
-    new(): XmlSchemaPatternFacet$instance;
+    new(): XmlSchemaPatternFacet;
 };
 
 
@@ -1061,7 +1061,7 @@ export interface XmlSchemaRedefine$instance extends XmlSchemaExternal {
 
 
 export const XmlSchemaRedefine: {
-    new(): XmlSchemaRedefine$instance;
+    new(): XmlSchemaRedefine;
 };
 
 
@@ -1073,7 +1073,7 @@ export interface XmlSchemaSequence$instance extends XmlSchemaGroupBase {
 
 
 export const XmlSchemaSequence: {
-    new(): XmlSchemaSequence$instance;
+    new(): XmlSchemaSequence;
 };
 
 
@@ -1091,22 +1091,22 @@ export interface XmlSchemaSet$instance {
     add(targetNamespace: string, schemaUri: string): XmlSchema;
     add(targetNamespace: string, schemaDocument: XmlReader): XmlSchema;
     add(schemas: XmlSchemaSet): void;
-    add(schema: XmlSchema): XmlSchema;
+    add(schema: XmlSchema): XmlSchema | undefined;
     compile(): void;
     contains(targetNamespace: string): boolean;
     contains(schema: XmlSchema): boolean;
     copyTo(schemas: XmlSchema[], index: int): void;
-    remove(schema: XmlSchema): XmlSchema;
+    remove(schema: XmlSchema): XmlSchema | undefined;
     removeRecursive(schemaToRemove: XmlSchema): boolean;
     reprocess(schema: XmlSchema): XmlSchema;
     schemas(): ICollection;
-    schemas(targetNamespace: string): ICollection;
+    schemas(targetNamespace: string | undefined): ICollection;
 }
 
 
 export const XmlSchemaSet: {
-    new(): XmlSchemaSet$instance;
-    new(nameTable: XmlNameTable): XmlSchemaSet$instance;
+    new(): XmlSchemaSet;
+    new(nameTable: XmlNameTable): XmlSchemaSet;
 };
 
 
@@ -1118,37 +1118,37 @@ export interface XmlSchemaSimpleContent$instance extends XmlSchemaContentModel {
 
 
 export const XmlSchemaSimpleContent: {
-    new(): XmlSchemaSimpleContent$instance;
+    new(): XmlSchemaSimpleContent;
 };
 
 
 export type XmlSchemaSimpleContent = XmlSchemaSimpleContent$instance;
 
 export interface XmlSchemaSimpleContentExtension$instance extends XmlSchemaContent {
-    anyAttribute: XmlSchemaAnyAttribute;
+    anyAttribute: XmlSchemaAnyAttribute | undefined;
     readonly attributes: XmlSchemaObjectCollection;
     baseTypeName: XmlQualifiedName;
 }
 
 
 export const XmlSchemaSimpleContentExtension: {
-    new(): XmlSchemaSimpleContentExtension$instance;
+    new(): XmlSchemaSimpleContentExtension;
 };
 
 
 export type XmlSchemaSimpleContentExtension = XmlSchemaSimpleContentExtension$instance;
 
 export interface XmlSchemaSimpleContentRestriction$instance extends XmlSchemaContent {
-    anyAttribute: XmlSchemaAnyAttribute;
+    anyAttribute: XmlSchemaAnyAttribute | undefined;
     readonly attributes: XmlSchemaObjectCollection;
-    baseType: XmlSchemaSimpleType;
+    baseType: XmlSchemaSimpleType | undefined;
     baseTypeName: XmlQualifiedName;
     readonly facets: XmlSchemaObjectCollection;
 }
 
 
 export const XmlSchemaSimpleContentRestriction: {
-    new(): XmlSchemaSimpleContentRestriction$instance;
+    new(): XmlSchemaSimpleContentRestriction;
 };
 
 
@@ -1160,7 +1160,7 @@ export interface XmlSchemaSimpleType$instance extends XmlSchemaType {
 
 
 export const XmlSchemaSimpleType: {
-    new(): XmlSchemaSimpleType$instance;
+    new(): XmlSchemaSimpleType;
 };
 
 
@@ -1177,42 +1177,42 @@ export const XmlSchemaSimpleTypeContent: {
 export type XmlSchemaSimpleTypeContent = XmlSchemaSimpleTypeContent$instance;
 
 export interface XmlSchemaSimpleTypeList$instance extends XmlSchemaSimpleTypeContent {
-    baseItemType: XmlSchemaSimpleType;
-    itemType: XmlSchemaSimpleType;
+    baseItemType: XmlSchemaSimpleType | undefined;
+    itemType: XmlSchemaSimpleType | undefined;
     itemTypeName: XmlQualifiedName;
 }
 
 
 export const XmlSchemaSimpleTypeList: {
-    new(): XmlSchemaSimpleTypeList$instance;
+    new(): XmlSchemaSimpleTypeList;
 };
 
 
 export type XmlSchemaSimpleTypeList = XmlSchemaSimpleTypeList$instance;
 
 export interface XmlSchemaSimpleTypeRestriction$instance extends XmlSchemaSimpleTypeContent {
-    baseType: XmlSchemaSimpleType;
+    baseType: XmlSchemaSimpleType | undefined;
     baseTypeName: XmlQualifiedName;
     readonly facets: XmlSchemaObjectCollection;
 }
 
 
 export const XmlSchemaSimpleTypeRestriction: {
-    new(): XmlSchemaSimpleTypeRestriction$instance;
+    new(): XmlSchemaSimpleTypeRestriction;
 };
 
 
 export type XmlSchemaSimpleTypeRestriction = XmlSchemaSimpleTypeRestriction$instance;
 
 export interface XmlSchemaSimpleTypeUnion$instance extends XmlSchemaSimpleTypeContent {
-    readonly baseMemberTypes: XmlSchemaSimpleType[];
+    readonly baseMemberTypes: XmlSchemaSimpleType[] | undefined;
     readonly baseTypes: XmlSchemaObjectCollection;
-    memberTypes: XmlQualifiedName[];
+    memberTypes: XmlQualifiedName[] | undefined;
 }
 
 
 export const XmlSchemaSimpleTypeUnion: {
-    new(): XmlSchemaSimpleTypeUnion$instance;
+    new(): XmlSchemaSimpleTypeUnion;
 };
 
 
@@ -1223,16 +1223,16 @@ export interface XmlSchemaTotalDigitsFacet$instance extends XmlSchemaNumericFace
 
 
 export const XmlSchemaTotalDigitsFacet: {
-    new(): XmlSchemaTotalDigitsFacet$instance;
+    new(): XmlSchemaTotalDigitsFacet;
 };
 
 
 export type XmlSchemaTotalDigitsFacet = XmlSchemaTotalDigitsFacet$instance;
 
 export interface XmlSchemaType$instance extends XmlSchemaAnnotated {
-    readonly baseSchemaType: unknown;
-    readonly baseXmlSchemaType: XmlSchemaType;
-    readonly datatype: XmlSchemaDatatype;
+    readonly baseSchemaType: unknown | undefined;
+    readonly baseXmlSchemaType: XmlSchemaType | undefined;
+    readonly datatype: XmlSchemaDatatype | undefined;
     readonly derivedBy: XmlSchemaDerivationMethod;
     final: XmlSchemaDerivationMethod;
     readonly finalResolved: XmlSchemaDerivationMethod;
@@ -1244,12 +1244,12 @@ export interface XmlSchemaType$instance extends XmlSchemaAnnotated {
 
 
 export const XmlSchemaType: {
-    new(): XmlSchemaType$instance;
-    getBuiltInComplexType(typeCode: XmlTypeCode): XmlSchemaComplexType;
-    getBuiltInComplexType(qualifiedName: XmlQualifiedName): XmlSchemaComplexType;
-    getBuiltInSimpleType(typeCode: XmlTypeCode): XmlSchemaSimpleType;
-    getBuiltInSimpleType(qualifiedName: XmlQualifiedName): XmlSchemaSimpleType;
-    isDerivedFrom(derivedType: XmlSchemaType, baseType: XmlSchemaType, except: XmlSchemaDerivationMethod): boolean;
+    new(): XmlSchemaType;
+    getBuiltInComplexType(typeCode: XmlTypeCode): XmlSchemaComplexType | undefined;
+    getBuiltInComplexType(qualifiedName: XmlQualifiedName | undefined): XmlSchemaComplexType | undefined;
+    getBuiltInSimpleType(typeCode: XmlTypeCode): XmlSchemaSimpleType | undefined;
+    getBuiltInSimpleType(qualifiedName: XmlQualifiedName | undefined): XmlSchemaSimpleType | undefined;
+    isDerivedFrom(derivedType: XmlSchemaType | undefined, baseType: XmlSchemaType | undefined, except: XmlSchemaDerivationMethod): boolean;
 };
 
 
@@ -1260,23 +1260,23 @@ export interface XmlSchemaUnique$instance extends XmlSchemaIdentityConstraint {
 
 
 export const XmlSchemaUnique: {
-    new(): XmlSchemaUnique$instance;
+    new(): XmlSchemaUnique;
 };
 
 
 export type XmlSchemaUnique = XmlSchemaUnique$instance;
 
 export interface XmlSchemaValidationException$instance extends XmlSchemaException$instance {
-    readonly sourceObject: unknown;
-    getObjectData(info: SerializationInfo, context: StreamingContext): void;
+    readonly sourceObject: unknown | undefined;
+    getObjectData(info: SerializationInfo | undefined, context: StreamingContext): void;
 }
 
 
 export const XmlSchemaValidationException: {
-    new(): XmlSchemaValidationException$instance;
-    new(message: string): XmlSchemaValidationException$instance;
-    new(message: string, innerException: Exception): XmlSchemaValidationException$instance;
-    new(message: string, innerException: Exception, lineNumber: int, linePosition: int): XmlSchemaValidationException$instance;
+    new(): XmlSchemaValidationException;
+    new(message: string | undefined): XmlSchemaValidationException;
+    new(message: string | undefined, innerException: Exception | undefined): XmlSchemaValidationException;
+    new(message: string | undefined, innerException: Exception | undefined, lineNumber: int, linePosition: int): XmlSchemaValidationException;
 };
 
 
@@ -1289,7 +1289,7 @@ export type XmlSchemaValidationException = XmlSchemaValidationException$instance
 
 export interface XmlSchemaValidator$instance {
     lineInfoProvider: IXmlLineInfo;
-    sourceUri: Uri;
+    sourceUri: Uri | undefined;
     validationEventSender: unknown;
     xmlResolver: XmlResolver;
     addSchema(schema: XmlSchema): void;
@@ -1300,9 +1300,9 @@ export interface XmlSchemaValidator$instance {
     initialize(): void;
     initialize(partialValidationType: XmlSchemaObject): void;
     skipToEndElement(schemaInfo: XmlSchemaInfo): void;
-    validateAttribute(localName: string, namespaceUri: string, attributeValue: string, schemaInfo: XmlSchemaInfo): unknown;
-    validateAttribute(localName: string, namespaceUri: string, attributeValue: XmlValueGetter, schemaInfo: XmlSchemaInfo): unknown;
-    validateElement(localName: string, namespaceUri: string, schemaInfo: XmlSchemaInfo): void;
+    validateAttribute(localName: string, namespaceUri: string, attributeValue: string, schemaInfo: XmlSchemaInfo | undefined): unknown | undefined;
+    validateAttribute(localName: string, namespaceUri: string, attributeValue: XmlValueGetter, schemaInfo: XmlSchemaInfo | undefined): unknown | undefined;
+    validateElement(localName: string, namespaceUri: string, schemaInfo: XmlSchemaInfo | undefined): void;
     validateElement(localName: string, namespaceUri: string, schemaInfo: XmlSchemaInfo, xsiType: string, xsiNil: string, xsiSchemaLocation: string, xsiNoNamespaceSchemaLocation: string): void;
     validateEndElement(schemaInfo: XmlSchemaInfo): unknown;
     validateEndElement(schemaInfo: XmlSchemaInfo, typedValue: unknown): unknown;
@@ -1315,7 +1315,7 @@ export interface XmlSchemaValidator$instance {
 
 
 export const XmlSchemaValidator: {
-    new(nameTable: XmlNameTable, schemas: XmlSchemaSet, namespaceResolver: IXmlNamespaceResolver, validationFlags: XmlSchemaValidationFlags): XmlSchemaValidator$instance;
+    new(nameTable: XmlNameTable, schemas: XmlSchemaSet, namespaceResolver: IXmlNamespaceResolver, validationFlags: XmlSchemaValidationFlags): XmlSchemaValidator;
 };
 
 
@@ -1326,33 +1326,33 @@ export interface XmlSchemaWhiteSpaceFacet$instance extends XmlSchemaFacet {
 
 
 export const XmlSchemaWhiteSpaceFacet: {
-    new(): XmlSchemaWhiteSpaceFacet$instance;
+    new(): XmlSchemaWhiteSpaceFacet;
 };
 
 
 export type XmlSchemaWhiteSpaceFacet = XmlSchemaWhiteSpaceFacet$instance;
 
 export interface XmlSchemaXPath$instance extends XmlSchemaAnnotated {
-    xPath: string;
+    xPath: string | undefined;
 }
 
 
 export const XmlSchemaXPath: {
-    new(): XmlSchemaXPath$instance;
+    new(): XmlSchemaXPath;
 };
 
 
 export type XmlSchemaXPath = XmlSchemaXPath$instance;
 
 export abstract class Extensions$instance {
-    static getSchemaInfo(source: XAttribute): IXmlSchemaInfo;
-    static getSchemaInfo(source: XElement): IXmlSchemaInfo;
-    static validate(source: XAttribute, partialValidationType: XmlSchemaObject, schemas: XmlSchemaSet, validationEventHandler: ValidationEventHandler, addSchemaInfo: boolean): void;
-    static validate(source: XAttribute, partialValidationType: XmlSchemaObject, schemas: XmlSchemaSet, validationEventHandler: ValidationEventHandler): void;
-    static validate(source: XDocument, schemas: XmlSchemaSet, validationEventHandler: ValidationEventHandler, addSchemaInfo: boolean): void;
-    static validate(source: XDocument, schemas: XmlSchemaSet, validationEventHandler: ValidationEventHandler): void;
-    static validate(source: XElement, partialValidationType: XmlSchemaObject, schemas: XmlSchemaSet, validationEventHandler: ValidationEventHandler, addSchemaInfo: boolean): void;
-    static validate(source: XElement, partialValidationType: XmlSchemaObject, schemas: XmlSchemaSet, validationEventHandler: ValidationEventHandler): void;
+    static getSchemaInfo(source: XAttribute): IXmlSchemaInfo | undefined;
+    static getSchemaInfo(source: XElement): IXmlSchemaInfo | undefined;
+    static validate(source: XAttribute, partialValidationType: XmlSchemaObject, schemas: XmlSchemaSet, validationEventHandler: ValidationEventHandler | undefined, addSchemaInfo: boolean): void;
+    static validate(source: XAttribute, partialValidationType: XmlSchemaObject, schemas: XmlSchemaSet, validationEventHandler: ValidationEventHandler | undefined): void;
+    static validate(source: XDocument, schemas: XmlSchemaSet, validationEventHandler: ValidationEventHandler | undefined, addSchemaInfo: boolean): void;
+    static validate(source: XDocument, schemas: XmlSchemaSet, validationEventHandler: ValidationEventHandler | undefined): void;
+    static validate(source: XElement, partialValidationType: XmlSchemaObject, schemas: XmlSchemaSet, validationEventHandler: ValidationEventHandler | undefined, addSchemaInfo: boolean): void;
+    static validate(source: XElement, partialValidationType: XmlSchemaObject, schemas: XmlSchemaSet, validationEventHandler: ValidationEventHandler | undefined): void;
 }