@tsonic/dotnet 0.8.0 → 0.8.2

package/System.Security.AccessControl/internal/index.d.ts

@@ -269,24 +269,24 @@ export interface AccessRule_1$instance<T extends unknown> extends AccessRule {
 
 
 export const AccessRule_1: {
-    new<T extends unknown>(identity: IdentityReference, rights: T, type_: AccessControlType): AccessRule_1$instance<T>;
-    new<T extends unknown>(identity: IdentityReference, rights: T, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): AccessRule_1$instance<T>;
-    new<T extends unknown>(identity: string, rights: T, type_: AccessControlType): AccessRule_1$instance<T>;
-    new<T extends unknown>(identity: string, rights: T, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): AccessRule_1$instance<T>;
+    new<T extends unknown>(identity: IdentityReference, rights: T, type_: AccessControlType): AccessRule_1<T>;
+    new<T extends unknown>(identity: IdentityReference, rights: T, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): AccessRule_1<T>;
+    new<T extends unknown>(identity: string, rights: T, type_: AccessControlType): AccessRule_1<T>;
+    new<T extends unknown>(identity: string, rights: T, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): AccessRule_1<T>;
 };
 
 
 export type AccessRule_1<T> = AccessRule_1$instance<T>;
 
 export interface AceEnumerator$instance {
-    readonly current: GenericAce | unknown;
+    readonly current: GenericAce;
     moveNext(): boolean;
     reset(): void;
 }
 
 
 export const AceEnumerator: {
-    new(): AceEnumerator$instance;
+    new(): AceEnumerator;
 };
 
 
@@ -314,10 +314,10 @@ export interface AuditRule_1$instance<T extends unknown> extends AuditRule {
 
 
 export const AuditRule_1: {
-    new<T extends unknown>(identity: IdentityReference, rights: T, flags: AuditFlags): AuditRule_1$instance<T>;
-    new<T extends unknown>(identity: IdentityReference, rights: T, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): AuditRule_1$instance<T>;
-    new<T extends unknown>(identity: string, rights: T, flags: AuditFlags): AuditRule_1$instance<T>;
-    new<T extends unknown>(identity: string, rights: T, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): AuditRule_1$instance<T>;
+    new<T extends unknown>(identity: IdentityReference, rights: T, flags: AuditFlags): AuditRule_1<T>;
+    new<T extends unknown>(identity: IdentityReference, rights: T, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): AuditRule_1<T>;
+    new<T extends unknown>(identity: string, rights: T, flags: AuditFlags): AuditRule_1<T>;
+    new<T extends unknown>(identity: string, rights: T, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): AuditRule_1<T>;
 };
 
 
@@ -339,14 +339,14 @@ export type AuthorizationRule = AuthorizationRule$instance;
 
 export interface AuthorizationRuleCollection$instance extends ReadOnlyCollectionBase {
     readonly item: AuthorizationRule;
-    addRule(rule: AuthorizationRule): void;
+    addRule(rule: AuthorizationRule | undefined): void;
     copyTo(array: ClrArray, index: int): void;
     getEnumerator(): IEnumerator;
 }
 
 
 export const AuthorizationRuleCollection: {
-    new(): AuthorizationRuleCollection$instance;
+    new(): AuthorizationRuleCollection;
 };
 
 
@@ -367,7 +367,7 @@ export interface CommonAce$instance extends QualifiedAce {
 
 
 export const CommonAce: {
-    new(flags: AceFlags, qualifier: AceQualifier, accessMask: int, sid: SecurityIdentifier, isCallback: boolean, opaque: byte[]): CommonAce$instance;
+    new(flags: AceFlags, qualifier: AceQualifier, accessMask: int, sid: SecurityIdentifier, isCallback: boolean, opaque: byte[] | undefined): CommonAce;
     maxOpaqueLength(isCallback: boolean): int;
 };
 
@@ -418,28 +418,28 @@ export type CommonObjectSecurity = CommonObjectSecurity$instance;
 
 export interface CommonSecurityDescriptor$instance extends GenericSecurityDescriptor {
     readonly controlFlags: ControlFlags;
-    discretionaryAcl: DiscretionaryAcl;
+    discretionaryAcl: DiscretionaryAcl | undefined;
     group: SecurityIdentifier;
     readonly isContainer: boolean;
     readonly isDiscretionaryAclCanonical: boolean;
     readonly isDS: boolean;
     readonly isSystemAclCanonical: boolean;
     owner: SecurityIdentifier;
-    systemAcl: SystemAcl;
+    systemAcl: SystemAcl | undefined;
     addDiscretionaryAcl(revision: byte, trusted: int): void;
     addSystemAcl(revision: byte, trusted: int): void;
-    purgeAccessControl(sid: SecurityIdentifier): void;
-    purgeAudit(sid: SecurityIdentifier): void;
+    purgeAccessControl(sid: SecurityIdentifier | undefined): void;
+    purgeAudit(sid: SecurityIdentifier | undefined): void;
     setDiscretionaryAclProtection(isProtected: boolean, preserveInheritance: boolean): void;
     setSystemAclProtection(isProtected: boolean, preserveInheritance: boolean): void;
 }
 
 
 export const CommonSecurityDescriptor: {
-    new(isContainer: boolean, isDS: boolean, binaryForm: byte[], offset: int): CommonSecurityDescriptor$instance;
-    new(isContainer: boolean, isDS: boolean, flags: ControlFlags, owner: SecurityIdentifier, group: SecurityIdentifier, systemAcl: SystemAcl, discretionaryAcl: DiscretionaryAcl): CommonSecurityDescriptor$instance;
-    new(isContainer: boolean, isDS: boolean, rawSecurityDescriptor: RawSecurityDescriptor): CommonSecurityDescriptor$instance;
-    new(isContainer: boolean, isDS: boolean, sddlForm: string): CommonSecurityDescriptor$instance;
+    new(isContainer: boolean, isDS: boolean, binaryForm: byte[] | undefined, offset: int): CommonSecurityDescriptor;
+    new(isContainer: boolean, isDS: boolean, flags: ControlFlags, owner: SecurityIdentifier | undefined, group: SecurityIdentifier | undefined, systemAcl: SystemAcl | undefined, discretionaryAcl: DiscretionaryAcl | undefined): CommonSecurityDescriptor;
+    new(isContainer: boolean, isDS: boolean, rawSecurityDescriptor: RawSecurityDescriptor | undefined): CommonSecurityDescriptor;
+    new(isContainer: boolean, isDS: boolean, sddlForm: string | undefined): CommonSecurityDescriptor;
 };
 
 
@@ -453,7 +453,7 @@ export interface CompoundAce$instance extends KnownAce {
 
 
 export const CompoundAce: {
-    new(flags: AceFlags, accessMask: int, compoundAceType: CompoundAceType, sid: SecurityIdentifier): CompoundAce$instance;
+    new(flags: AceFlags, accessMask: int, compoundAceType: CompoundAceType, sid: SecurityIdentifier): CompoundAce;
 };
 
 
@@ -462,14 +462,14 @@ export type CompoundAce = CompoundAce$instance;
 export interface CustomAce$instance extends GenericAce {
     readonly binaryLength: int;
     readonly opaqueLength: int;
-    getBinaryForm(binaryForm: byte[], offset: int): void;
-    getOpaque(): byte[];
-    setOpaque(opaque: byte[]): void;
+    getBinaryForm(binaryForm: byte[] | undefined, offset: int): void;
+    getOpaque(): byte[] | undefined;
+    setOpaque(opaque: byte[] | undefined): void;
 }
 
 
 export const CustomAce: {
-    new(type_: AceType, flags: AceFlags, opaque: byte[]): CustomAce$instance;
+    new(type_: AceType, flags: AceFlags, opaque: byte[] | undefined): CustomAce;
     readonly maxOpaqueLength: int;
 };
 
@@ -497,8 +497,8 @@ export interface DirectorySecurity$instance extends FileSystemSecurity {
 
 
 export const DirectorySecurity: {
-    new(): DirectorySecurity$instance;
-    new(name: string, includeSections: AccessControlSections): DirectorySecurity$instance;
+    new(): DirectorySecurity;
+    new(name: string, includeSections: AccessControlSections): DirectorySecurity;
 };
 
 
@@ -525,9 +525,9 @@ export interface DiscretionaryAcl$instance extends CommonAcl$instance {
 
 
 export const DiscretionaryAcl: {
-    new(isContainer: boolean, isDS: boolean, revision: byte, capacity: int): DiscretionaryAcl$instance;
-    new(isContainer: boolean, isDS: boolean, capacity: int): DiscretionaryAcl$instance;
-    new(isContainer: boolean, isDS: boolean, rawAcl: RawAcl): DiscretionaryAcl$instance;
+    new(isContainer: boolean, isDS: boolean, revision: byte, capacity: int): DiscretionaryAcl;
+    new(isContainer: boolean, isDS: boolean, capacity: int): DiscretionaryAcl;
+    new(isContainer: boolean, isDS: boolean, rawAcl: RawAcl): DiscretionaryAcl;
 };
 
 
@@ -545,8 +545,8 @@ export interface EventWaitHandleAccessRule$instance extends AccessRule {
 
 
 export const EventWaitHandleAccessRule: {
-    new(identity: IdentityReference, eventRights: EventWaitHandleRights, type_: AccessControlType): EventWaitHandleAccessRule$instance;
-    new(identity: string, eventRights: EventWaitHandleRights, type_: AccessControlType): EventWaitHandleAccessRule$instance;
+    new(identity: IdentityReference, eventRights: EventWaitHandleRights, type_: AccessControlType): EventWaitHandleAccessRule;
+    new(identity: string, eventRights: EventWaitHandleRights, type_: AccessControlType): EventWaitHandleAccessRule;
 };
 
 
@@ -558,7 +558,7 @@ export interface EventWaitHandleAuditRule$instance extends AuditRule {
 
 
 export const EventWaitHandleAuditRule: {
-    new(identity: IdentityReference, eventRights: EventWaitHandleRights, flags: AuditFlags): EventWaitHandleAuditRule$instance;
+    new(identity: IdentityReference, eventRights: EventWaitHandleRights, flags: AuditFlags): EventWaitHandleAuditRule;
 };
 
 
@@ -585,7 +585,7 @@ export interface EventWaitHandleSecurity$instance extends NativeObjectSecurity {
 
 
 export const EventWaitHandleSecurity: {
-    new(): EventWaitHandleSecurity$instance;
+    new(): EventWaitHandleSecurity;
 };
 
 
@@ -596,8 +596,8 @@ export interface FileSecurity$instance extends FileSystemSecurity {
 
 
 export const FileSecurity: {
-    new(): FileSecurity$instance;
-    new(fileName: string, includeSections: AccessControlSections): FileSecurity$instance;
+    new(): FileSecurity;
+    new(fileName: string, includeSections: AccessControlSections): FileSecurity;
 };
 
 
@@ -609,10 +609,10 @@ export interface FileSystemAccessRule$instance extends AccessRule {
 
 
 export const FileSystemAccessRule: {
-    new(identity: IdentityReference, fileSystemRights: FileSystemRights, type_: AccessControlType): FileSystemAccessRule$instance;
-    new(identity: IdentityReference, fileSystemRights: FileSystemRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): FileSystemAccessRule$instance;
-    new(identity: string, fileSystemRights: FileSystemRights, type_: AccessControlType): FileSystemAccessRule$instance;
-    new(identity: string, fileSystemRights: FileSystemRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): FileSystemAccessRule$instance;
+    new(identity: IdentityReference, fileSystemRights: FileSystemRights, type_: AccessControlType): FileSystemAccessRule;
+    new(identity: IdentityReference, fileSystemRights: FileSystemRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): FileSystemAccessRule;
+    new(identity: string, fileSystemRights: FileSystemRights, type_: AccessControlType): FileSystemAccessRule;
+    new(identity: string, fileSystemRights: FileSystemRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): FileSystemAccessRule;
 };
 
 
@@ -624,10 +624,10 @@ export interface FileSystemAuditRule$instance extends AuditRule {
 
 
 export const FileSystemAuditRule: {
-    new(identity: IdentityReference, fileSystemRights: FileSystemRights, flags: AuditFlags): FileSystemAuditRule$instance;
-    new(identity: IdentityReference, fileSystemRights: FileSystemRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): FileSystemAuditRule$instance;
-    new(identity: string, fileSystemRights: FileSystemRights, flags: AuditFlags): FileSystemAuditRule$instance;
-    new(identity: string, fileSystemRights: FileSystemRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): FileSystemAuditRule$instance;
+    new(identity: IdentityReference, fileSystemRights: FileSystemRights, flags: AuditFlags): FileSystemAuditRule;
+    new(identity: IdentityReference, fileSystemRights: FileSystemRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): FileSystemAuditRule;
+    new(identity: string, fileSystemRights: FileSystemRights, flags: AuditFlags): FileSystemAuditRule;
+    new(identity: string, fileSystemRights: FileSystemRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): FileSystemAuditRule;
 };
 
 
@@ -714,8 +714,8 @@ export interface GenericSecurityDescriptor$instance {
     readonly controlFlags: ControlFlags;
     group: SecurityIdentifier;
     owner: SecurityIdentifier;
-    getBinaryForm(binaryForm: byte[], offset: int): void;
-    getSddlForm(includeSections: AccessControlSections): string;
+    getBinaryForm(binaryForm: byte[] | undefined, offset: int): void;
+    getSddlForm(includeSections: AccessControlSections): string | undefined;
 }
 
 
@@ -745,8 +745,8 @@ export interface MutexAccessRule$instance extends AccessRule {
 
 
 export const MutexAccessRule: {
-    new(identity: IdentityReference, eventRights: MutexRights, type_: AccessControlType): MutexAccessRule$instance;
-    new(identity: string, eventRights: MutexRights, type_: AccessControlType): MutexAccessRule$instance;
+    new(identity: IdentityReference, eventRights: MutexRights, type_: AccessControlType): MutexAccessRule;
+    new(identity: string, eventRights: MutexRights, type_: AccessControlType): MutexAccessRule;
 };
 
 
@@ -758,7 +758,7 @@ export interface MutexAuditRule$instance extends AuditRule {
 
 
 export const MutexAuditRule: {
-    new(identity: IdentityReference, eventRights: MutexRights, flags: AuditFlags): MutexAuditRule$instance;
+    new(identity: IdentityReference, eventRights: MutexRights, flags: AuditFlags): MutexAuditRule;
 };
 
 
@@ -785,8 +785,8 @@ export interface MutexSecurity$instance extends NativeObjectSecurity {
 
 
 export const MutexSecurity: {
-    new(): MutexSecurity$instance;
-    new(name: string, includeSections: AccessControlSections): MutexSecurity$instance;
+    new(): MutexSecurity;
+    new(name: string, includeSections: AccessControlSections): MutexSecurity;
 };
 
 
@@ -825,7 +825,7 @@ export interface ObjectAce$instance extends QualifiedAce {
 
 
 export const ObjectAce: {
-    new(aceFlags: AceFlags, qualifier: AceQualifier, accessMask: int, sid: SecurityIdentifier, flags: ObjectAceFlags, type_: Guid, inheritedType: Guid, isCallback: boolean, opaque: byte[]): ObjectAce$instance;
+    new(aceFlags: AceFlags, qualifier: AceQualifier, accessMask: int, sid: SecurityIdentifier, flags: ObjectAceFlags, type_: Guid, inheritedType: Guid, isCallback: boolean, opaque: byte[] | undefined): ObjectAce;
     maxOpaqueLength(isCallback: boolean): int;
 };
 
@@ -855,8 +855,8 @@ export interface ObjectSecurity$instance {
     readonly auditRuleType: Type;
     accessRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): AccessRule;
     auditRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): AuditRule;
-    getGroup(targetType: Type): IdentityReference;
-    getOwner(targetType: Type): IdentityReference;
+    getGroup(targetType: Type): IdentityReference | undefined;
+    getOwner(targetType: Type): IdentityReference | undefined;
     getSecurityDescriptorBinaryForm(): byte[];
     getSecurityDescriptorSddlForm(includeSections: AccessControlSections): string;
     modifyAccessRule(modification: AccessControlModification, rule: AccessRule, modified: boolean): boolean;
@@ -908,15 +908,15 @@ export const ObjectSecurity_1: {
 export type ObjectSecurity_1<T> = ObjectSecurity_1$instance<T>;
 
 export interface PrivilegeNotHeldException$instance extends UnauthorizedAccessException {
-    readonly privilegeName: string;
-    getObjectData(info: SerializationInfo, context: StreamingContext): void;
+    readonly privilegeName: string | undefined;
+    getObjectData(info: SerializationInfo | undefined, context: StreamingContext): void;
 }
 
 
 export const PrivilegeNotHeldException: {
-    new(): PrivilegeNotHeldException$instance;
-    new(privilege: string): PrivilegeNotHeldException$instance;
-    new(privilege: string, inner: Exception): PrivilegeNotHeldException$instance;
+    new(): PrivilegeNotHeldException;
+    new(privilege: string | undefined): PrivilegeNotHeldException;
+    new(privilege: string | undefined, inner: Exception | undefined): PrivilegeNotHeldException;
 };
 
 
@@ -931,8 +931,8 @@ export interface QualifiedAce$instance extends KnownAce {
     readonly aceQualifier: AceQualifier;
     readonly isCallback: boolean;
     readonly opaqueLength: int;
-    getOpaque(): byte[];
-    setOpaque(opaque: byte[]): void;
+    getOpaque(): byte[] | undefined;
+    setOpaque(opaque: byte[] | undefined): void;
 }
 
 
@@ -958,8 +958,8 @@ export interface RawAcl$instance extends GenericAcl$instance {
 
 
 export const RawAcl: {
-    new(revision: byte, capacity: int): RawAcl$instance;
-    new(binaryForm: byte[], offset: int): RawAcl$instance;
+    new(revision: byte, capacity: int): RawAcl;
+    new(binaryForm: byte[], offset: int): RawAcl;
 };
 
 
@@ -973,19 +973,19 @@ export type RawAcl = RawAcl$instance & __RawAcl$views;
 
 export interface RawSecurityDescriptor$instance extends GenericSecurityDescriptor {
     readonly controlFlags: ControlFlags;
-    discretionaryAcl: RawAcl;
+    discretionaryAcl: RawAcl | undefined;
     group: SecurityIdentifier;
     owner: SecurityIdentifier;
     resourceManagerControl: byte;
-    systemAcl: RawAcl;
+    systemAcl: RawAcl | undefined;
     setFlags(flags: ControlFlags): void;
 }
 
 
 export const RawSecurityDescriptor: {
-    new(binaryForm: byte[], offset: int): RawSecurityDescriptor$instance;
-    new(flags: ControlFlags, owner: SecurityIdentifier, group: SecurityIdentifier, systemAcl: RawAcl, discretionaryAcl: RawAcl): RawSecurityDescriptor$instance;
-    new(sddlForm: string): RawSecurityDescriptor$instance;
+    new(binaryForm: byte[] | undefined, offset: int): RawSecurityDescriptor;
+    new(flags: ControlFlags, owner: SecurityIdentifier | undefined, group: SecurityIdentifier | undefined, systemAcl: RawAcl | undefined, discretionaryAcl: RawAcl | undefined): RawSecurityDescriptor;
+    new(sddlForm: string | undefined): RawSecurityDescriptor;
 };
 
 
@@ -997,10 +997,10 @@ export interface RegistryAccessRule$instance extends AccessRule {
 
 
 export const RegistryAccessRule: {
-    new(identity: IdentityReference, registryRights: RegistryRights, type_: AccessControlType): RegistryAccessRule$instance;
-    new(identity: IdentityReference, registryRights: RegistryRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): RegistryAccessRule$instance;
-    new(identity: string, registryRights: RegistryRights, type_: AccessControlType): RegistryAccessRule$instance;
-    new(identity: string, registryRights: RegistryRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): RegistryAccessRule$instance;
+    new(identity: IdentityReference, registryRights: RegistryRights, type_: AccessControlType): RegistryAccessRule;
+    new(identity: IdentityReference, registryRights: RegistryRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): RegistryAccessRule;
+    new(identity: string, registryRights: RegistryRights, type_: AccessControlType): RegistryAccessRule;
+    new(identity: string, registryRights: RegistryRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): RegistryAccessRule;
 };
 
 
@@ -1012,8 +1012,8 @@ export interface RegistryAuditRule$instance extends AuditRule {
 
 
 export const RegistryAuditRule: {
-    new(identity: IdentityReference, registryRights: RegistryRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): RegistryAuditRule$instance;
-    new(identity: string, registryRights: RegistryRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): RegistryAuditRule$instance;
+    new(identity: IdentityReference, registryRights: RegistryRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): RegistryAuditRule;
+    new(identity: string, registryRights: RegistryRights, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): RegistryAuditRule;
 };
 
 
@@ -1040,7 +1040,7 @@ export interface RegistrySecurity$instance extends NativeObjectSecurity {
 
 
 export const RegistrySecurity: {
-    new(): RegistrySecurity$instance;
+    new(): RegistrySecurity;
 };
 
 
@@ -1052,8 +1052,8 @@ export interface SemaphoreAccessRule$instance extends AccessRule {
 
 
 export const SemaphoreAccessRule: {
-    new(identity: IdentityReference, eventRights: SemaphoreRights, type_: AccessControlType): SemaphoreAccessRule$instance;
-    new(identity: string, eventRights: SemaphoreRights, type_: AccessControlType): SemaphoreAccessRule$instance;
+    new(identity: IdentityReference, eventRights: SemaphoreRights, type_: AccessControlType): SemaphoreAccessRule;
+    new(identity: string, eventRights: SemaphoreRights, type_: AccessControlType): SemaphoreAccessRule;
 };
 
 
@@ -1065,7 +1065,7 @@ export interface SemaphoreAuditRule$instance extends AuditRule {
 
 
 export const SemaphoreAuditRule: {
-    new(identity: IdentityReference, eventRights: SemaphoreRights, flags: AuditFlags): SemaphoreAuditRule$instance;
+    new(identity: IdentityReference, eventRights: SemaphoreRights, flags: AuditFlags): SemaphoreAuditRule;
 };
 
 
@@ -1092,8 +1092,8 @@ export interface SemaphoreSecurity$instance extends NativeObjectSecurity {
 
 
 export const SemaphoreSecurity: {
-    new(): SemaphoreSecurity$instance;
-    new(name: string, includeSections: AccessControlSections): SemaphoreSecurity$instance;
+    new(): SemaphoreSecurity;
+    new(name: string, includeSections: AccessControlSections): SemaphoreSecurity;
 };
 
 
@@ -1120,9 +1120,9 @@ export interface SystemAcl$instance extends CommonAcl$instance {
 
 
 export const SystemAcl: {
-    new(isContainer: boolean, isDS: boolean, revision: byte, capacity: int): SystemAcl$instance;
-    new(isContainer: boolean, isDS: boolean, capacity: int): SystemAcl$instance;
-    new(isContainer: boolean, isDS: boolean, rawAcl: RawAcl): SystemAcl$instance;
+    new(isContainer: boolean, isDS: boolean, revision: byte, capacity: int): SystemAcl;
+    new(isContainer: boolean, isDS: boolean, capacity: int): SystemAcl;
+    new(isContainer: boolean, isDS: boolean, rawAcl: RawAcl): SystemAcl;
 };
 
 

package/System.Security.Authentication/internal/index.d.ts

@@ -63,9 +63,9 @@ export interface AuthenticationException$instance extends SystemException {
 
 
 export const AuthenticationException: {
-    new(): AuthenticationException$instance;
-    new(message: string): AuthenticationException$instance;
-    new(message: string, innerException: Exception): AuthenticationException$instance;
+    new(): AuthenticationException;
+    new(message: string | undefined): AuthenticationException;
+    new(message: string | undefined, innerException: Exception | undefined): AuthenticationException;
 };
 
 
@@ -82,9 +82,9 @@ export interface InvalidCredentialException$instance extends AuthenticationExcep
 
 
 export const InvalidCredentialException: {
-    new(): InvalidCredentialException$instance;
-    new(message: string): InvalidCredentialException$instance;
-    new(message: string, innerException: Exception): InvalidCredentialException$instance;
+    new(): InvalidCredentialException;
+    new(message: string | undefined): InvalidCredentialException;
+    new(message: string | undefined, innerException: Exception | undefined): InvalidCredentialException;
 };
 
 

package/System.Security.Authentication.ExtendedProtection/internal/index.d.ts

@@ -56,19 +56,19 @@ export type ChannelBinding = ChannelBinding$instance & __ChannelBinding$views;
 
 
 export interface ExtendedProtectionPolicy$instance {
-    readonly customChannelBinding: ChannelBinding;
-    readonly customServiceNames: ServiceNameCollection;
+    readonly customChannelBinding: ChannelBinding | undefined;
+    readonly customServiceNames: ServiceNameCollection | undefined;
     readonly policyEnforcement: PolicyEnforcement;
     readonly protectionScenario: ProtectionScenario;
-    toString(): string;
+    toString(): string | undefined;
 }
 
 
 export const ExtendedProtectionPolicy: {
-    new(policyEnforcement: PolicyEnforcement, protectionScenario: ProtectionScenario, customServiceNames: ServiceNameCollection): ExtendedProtectionPolicy$instance;
-    new(policyEnforcement: PolicyEnforcement, protectionScenario: ProtectionScenario, customServiceNames: ICollection): ExtendedProtectionPolicy$instance;
-    new(policyEnforcement: PolicyEnforcement, customChannelBinding: ChannelBinding): ExtendedProtectionPolicy$instance;
-    new(policyEnforcement: PolicyEnforcement): ExtendedProtectionPolicy$instance;
+    new(policyEnforcement: PolicyEnforcement, protectionScenario: ProtectionScenario, customServiceNames: ServiceNameCollection | undefined): ExtendedProtectionPolicy;
+    new(policyEnforcement: PolicyEnforcement, protectionScenario: ProtectionScenario, customServiceNames: ICollection | undefined): ExtendedProtectionPolicy;
+    new(policyEnforcement: PolicyEnforcement, customChannelBinding: ChannelBinding | undefined): ExtendedProtectionPolicy;
+    new(policyEnforcement: PolicyEnforcement): ExtendedProtectionPolicy;
     readonly osSupportsExtendedProtection: boolean;
 };
 
@@ -83,15 +83,15 @@ export type ExtendedProtectionPolicy = ExtendedProtectionPolicy$instance & __Ext
 
 
 export interface ExtendedProtectionPolicyTypeConverter$instance extends TypeConverter {
-    canConvertTo(context: ITypeDescriptorContext, destinationType: Type): boolean;
-    canConvertTo(destinationType: Type): boolean;
-    convertTo(context: ITypeDescriptorContext, culture: CultureInfo, value: unknown, destinationType: Type): unknown;
-    convertTo(value: unknown, destinationType: Type): unknown;
+    canConvertTo(context: ITypeDescriptorContext | undefined, destinationType: Type | undefined): boolean;
+    canConvertTo(destinationType: Type | undefined): boolean;
+    convertTo(context: ITypeDescriptorContext | undefined, culture: CultureInfo | undefined, value: unknown | undefined, destinationType: Type): unknown | undefined;
+    convertTo(value: unknown | undefined, destinationType: Type): unknown | undefined;
 }
 
 
 export const ExtendedProtectionPolicyTypeConverter: {
-    new(): ExtendedProtectionPolicyTypeConverter$instance;
+    new(): ExtendedProtectionPolicyTypeConverter;
 };
 
 
@@ -107,7 +107,7 @@ export interface ServiceNameCollection$instance extends ReadOnlyCollectionBase {
 
 
 export const ServiceNameCollection: {
-    new(items: ICollection): ServiceNameCollection$instance;
+    new(items: ICollection): ServiceNameCollection;
 };
 
 

package/System.Security.Claims/internal/index.d.ts

@@ -22,42 +22,42 @@ export interface Claim$instance {
     readonly value: string;
     readonly valueType: string;
     clone(): Claim;
-    clone(identity: ClaimsIdentity): Claim;
+    clone(identity: ClaimsIdentity | undefined): Claim;
     toString(): string;
     writeTo(writer: BinaryWriter): void;
 }
 
 
 export const Claim: {
-    new(reader: BinaryReader): Claim$instance;
-    new(reader: BinaryReader, subject: ClaimsIdentity): Claim$instance;
-    new(type_: string, value: string): Claim$instance;
-    new(type_: string, value: string, valueType: string): Claim$instance;
-    new(type_: string, value: string, valueType: string, issuer: string): Claim$instance;
-    new(type_: string, value: string, valueType: string, issuer: string, originalIssuer: string): Claim$instance;
-    new(type_: string, value: string, valueType: string, issuer: string, originalIssuer: string, subject: ClaimsIdentity): Claim$instance;
+    new(reader: BinaryReader): Claim;
+    new(reader: BinaryReader, subject: ClaimsIdentity | undefined): Claim;
+    new(type_: string, value: string): Claim;
+    new(type_: string, value: string, valueType: string | undefined): Claim;
+    new(type_: string, value: string, valueType: string | undefined, issuer: string | undefined): Claim;
+    new(type_: string, value: string, valueType: string, issuer: string, originalIssuer: string): Claim;
+    new(type_: string, value: string, valueType: string, issuer: string, originalIssuer: string, subject: ClaimsIdentity): Claim;
 };
 
 
 export type Claim = Claim$instance;
 
 export interface ClaimsIdentity$instance {
-    actor: ClaimsIdentity;
-    readonly authenticationType: string;
-    bootstrapContext: unknown;
+    actor: ClaimsIdentity | undefined;
+    readonly authenticationType: string | string | undefined;
+    bootstrapContext: unknown | undefined;
     readonly claims: IEnumerable_1<Claim>;
     readonly isAuthenticated: boolean;
-    label: string;
+    label: string | undefined;
     readonly name: string;
     readonly nameClaimType: string;
     readonly roleClaimType: string;
     addClaim(claim: Claim): void;
-    addClaims(claims: IEnumerable_1<Claim>): void;
+    addClaims(claims: IEnumerable_1<Claim | undefined>): void;
     clone(): ClaimsIdentity;
     findAll(match: Predicate_1<Claim>): IEnumerable_1<Claim>;
     findAll(type_: string): IEnumerable_1<Claim>;
-    findFirst(match: Predicate_1<Claim>): Claim;
-    findFirst(type_: string): Claim;
+    findFirst(match: Predicate_1<Claim>): Claim | undefined;
+    findFirst(type_: string): Claim | undefined;
     hasClaim(match: Predicate_1<Claim>): boolean;
     hasClaim(type_: string, value: string): boolean;
     removeClaim(claim: Claim): void;
@@ -67,18 +67,18 @@ export interface ClaimsIdentity$instance {
 
 
 export const ClaimsIdentity: {
-    new(): ClaimsIdentity$instance;
-    new(identity: IIdentity): ClaimsIdentity$instance;
-    new(claims: IEnumerable_1<Claim>): ClaimsIdentity$instance;
-    new(authenticationType: string): ClaimsIdentity$instance;
-    new(claims: IEnumerable_1<Claim>, authenticationType: string): ClaimsIdentity$instance;
-    new(identity: IIdentity, claims: IEnumerable_1<Claim>): ClaimsIdentity$instance;
-    new(authenticationType: string, nameType: string, roleType: string): ClaimsIdentity$instance;
-    new(claims: IEnumerable_1<Claim>, authenticationType: string, nameType: string, roleType: string): ClaimsIdentity$instance;
-    new(identity: IIdentity, claims: IEnumerable_1<Claim>, authenticationType: string, nameType: string, roleType: string): ClaimsIdentity$instance;
-    new(reader: BinaryReader): ClaimsIdentity$instance;
-    new(reader: BinaryReader, stringComparison: StringComparison): ClaimsIdentity$instance;
-    new(identity: IIdentity, claims: IEnumerable_1<Claim>, authenticationType: string, nameType: string, roleType: string, stringComparison: StringComparison): ClaimsIdentity$instance;
+    new(): ClaimsIdentity;
+    new(identity: IIdentity): ClaimsIdentity;
+    new(claims: IEnumerable_1<Claim> | undefined): ClaimsIdentity;
+    new(authenticationType: string): ClaimsIdentity;
+    new(claims: IEnumerable_1<Claim> | undefined, authenticationType: string): ClaimsIdentity;
+    new(identity: IIdentity, claims: IEnumerable_1<Claim> | undefined): ClaimsIdentity;
+    new(authenticationType: string, nameType: string, roleType: string): ClaimsIdentity;
+    new(claims: IEnumerable_1<Claim> | undefined, authenticationType: string, nameType: string, roleType: string): ClaimsIdentity;
+    new(identity: IIdentity, claims: IEnumerable_1<Claim> | undefined, authenticationType: string, nameType: string, roleType: string): ClaimsIdentity;
+    new(reader: BinaryReader): ClaimsIdentity;
+    new(reader: BinaryReader, stringComparison: StringComparison): ClaimsIdentity;
+    new(identity: IIdentity, claims: IEnumerable_1<Claim> | undefined, authenticationType: string, nameType: string, roleType: string, stringComparison: StringComparison): ClaimsIdentity;
     readonly defaultIssuer: string;
     readonly defaultNameClaimType: string;
     readonly defaultRoleClaimType: string;
@@ -97,14 +97,14 @@ export type ClaimsIdentity = ClaimsIdentity$instance & __ClaimsIdentity$views;
 export interface ClaimsPrincipal$instance {
     readonly claims: IEnumerable_1<Claim>;
     readonly identities: IEnumerable_1<ClaimsIdentity>;
-    readonly identity: IIdentity;
+    readonly identity: IIdentity | IIdentity | undefined;
     addIdentities(identities: IEnumerable_1<ClaimsIdentity>): void;
     addIdentity(identity: ClaimsIdentity): void;
     clone(): ClaimsPrincipal;
     findAll(match: Predicate_1<Claim>): IEnumerable_1<Claim>;
     findAll(type_: string): IEnumerable_1<Claim>;
-    findFirst(match: Predicate_1<Claim>): Claim;
-    findFirst(type_: string): Claim;
+    findFirst(match: Predicate_1<Claim>): Claim | undefined;
+    findFirst(type_: string): Claim | undefined;
     hasClaim(match: Predicate_1<Claim>): boolean;
     hasClaim(type_: string, value: string): boolean;
     isInRole(role: string): boolean;
@@ -113,14 +113,14 @@ export interface ClaimsPrincipal$instance {
 
 
 export const ClaimsPrincipal: {
-    new(): ClaimsPrincipal$instance;
-    new(identities: IEnumerable_1<ClaimsIdentity>): ClaimsPrincipal$instance;
-    new(identity: IIdentity): ClaimsPrincipal$instance;
-    new(principal: IPrincipal): ClaimsPrincipal$instance;
-    new(reader: BinaryReader): ClaimsPrincipal$instance;
-    primaryIdentitySelector: Func_2<IEnumerable_1<ClaimsIdentity>, ClaimsIdentity>;
-    claimsPrincipalSelector: Func_1<ClaimsPrincipal>;
-    readonly current: ClaimsPrincipal;
+    new(): ClaimsPrincipal;
+    new(identities: IEnumerable_1<ClaimsIdentity>): ClaimsPrincipal;
+    new(identity: IIdentity): ClaimsPrincipal;
+    new(principal: IPrincipal): ClaimsPrincipal;
+    new(reader: BinaryReader): ClaimsPrincipal;
+    primaryIdentitySelector: Func_2<IEnumerable_1<ClaimsIdentity>, ClaimsIdentity | undefined>;
+    claimsPrincipalSelector: Func_1<ClaimsPrincipal | undefined> | undefined;
+    readonly current: ClaimsPrincipal | undefined;
 };
 
 
@@ -128,8 +128,6 @@ export interface __ClaimsPrincipal$views {
     As_IPrincipal(): System_Security_Principal_Internal.IPrincipal$instance;
 }
 
-export interface ClaimsPrincipal$instance extends System_Security_Principal_Internal.IPrincipal$instance {}
-
 export type ClaimsPrincipal = ClaimsPrincipal$instance & __ClaimsPrincipal$views;