@tsonic/dotnet-pure/System.Security.AccessControl/internal/index.d.ts

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

// Generated by tsbindgen - Architecture
// Namespace: System.Security.AccessControl
// Assembly: Microsoft.Win32.Registry, System.IO.FileSystem.AccessControl, System.Security.AccessControl, System.Threading.AccessControl

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

// Import support types from @tsonic/types
import type { ptr, ref } from "@tsonic/types";

// Import types from other namespaces
import * as System_Collections_Internal from "../../System.Collections/internal/index.js";
import type { ICollection, IDictionary, IEnumerable, IEnumerator, ReadOnlyCollectionBase } from "../../System.Collections/internal/index.js";
import type { MethodBase } from "../../System.Reflection/internal/index.js";
import * as System_Runtime_Serialization_Internal from "../../System.Runtime.Serialization/internal/index.js";
import type { ISerializable, SerializationInfo, StreamingContext } from "../../System.Runtime.Serialization/internal/index.js";
import type { IdentityReference, SecurityIdentifier } from "../../System.Security.Principal/internal/index.js";
import * as System_Internal from "../../System/internal/index.js";
import type { Array as ClrArray, Boolean as ClrBoolean, Byte, Enum, Exception, Guid, IComparable, IConvertible, IFormatProvider, IFormattable, Int32, ISpanFormattable, Object as ClrObject, String as ClrString, Type, TypeCode, UnauthorizedAccessException, ValueType, Void } from "../../System/internal/index.js";

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

export enum AccessControlActions {
    None = 0,
    View = 1,
    Change = 2
}


export enum AccessControlModification {
    Add = 0,
    Set = 1,
    Reset = 2,
    Remove = 3,
    RemoveAll = 4,
    RemoveSpecific = 5
}


export enum AccessControlSections {
    None = 0,
    Audit = 1,
    Access = 2,
    Owner = 4,
    Group = 8,
    All = 15
}


export enum AccessControlType {
    Allow = 0,
    Deny = 1
}


export enum AceFlags {
    None = 0,
    ObjectInherit = 1,
    ContainerInherit = 2,
    NoPropagateInherit = 4,
    InheritOnly = 8,
    InheritanceFlags = 15,
    Inherited = 16,
    SuccessfulAccess = 64,
    FailedAccess = 128,
    AuditFlags = 192
}


export enum AceQualifier {
    AccessAllowed = 0,
    AccessDenied = 1,
    SystemAudit = 2,
    SystemAlarm = 3
}


export enum AceType {
    AccessAllowed = 0,
    AccessDenied = 1,
    SystemAudit = 2,
    SystemAlarm = 3,
    AccessAllowedCompound = 4,
    AccessAllowedObject = 5,
    AccessDeniedObject = 6,
    SystemAuditObject = 7,
    SystemAlarmObject = 8,
    AccessAllowedCallback = 9,
    AccessDeniedCallback = 10,
    AccessAllowedCallbackObject = 11,
    AccessDeniedCallbackObject = 12,
    SystemAuditCallback = 13,
    SystemAlarmCallback = 14,
    SystemAuditCallbackObject = 15,
    MaxDefinedAceType = 16,
    SystemAlarmCallbackObject = 16
}


export enum AuditFlags {
    None = 0,
    Success = 1,
    Failure = 2
}


export enum CompoundAceType {
    Impersonation = 1
}


export enum ControlFlags {
    None = 0,
    OwnerDefaulted = 1,
    GroupDefaulted = 2,
    DiscretionaryAclPresent = 4,
    DiscretionaryAclDefaulted = 8,
    SystemAclPresent = 16,
    SystemAclDefaulted = 32,
    DiscretionaryAclUntrusted = 64,
    ServerSecurity = 128,
    DiscretionaryAclAutoInheritRequired = 256,
    SystemAclAutoInheritRequired = 512,
    DiscretionaryAclAutoInherited = 1024,
    SystemAclAutoInherited = 2048,
    DiscretionaryAclProtected = 4096,
    SystemAclProtected = 8192,
    RMControlValid = 16384,
    SelfRelative = 32768
}


export enum EventWaitHandleRights {
    Modify = 2,
    Delete = 65536,
    ReadPermissions = 131072,
    ChangePermissions = 262144,
    TakeOwnership = 524288,
    Synchronize = 1048576,
    FullControl = 2031619
}


export enum FileSystemRights {
    ListDirectory = 1,
    ReadData = 1,
    CreateFiles = 2,
    WriteData = 2,
    AppendData = 4,
    CreateDirectories = 4,
    ReadExtendedAttributes = 8,
    WriteExtendedAttributes = 16,
    ExecuteFile = 32,
    Traverse = 32,
    DeleteSubdirectoriesAndFiles = 64,
    ReadAttributes = 128,
    WriteAttributes = 256,
    Write = 278,
    Delete = 65536,
    ReadPermissions = 131072,
    Read = 131209,
    ReadAndExecute = 131241,
    Modify = 197055,
    ChangePermissions = 262144,
    TakeOwnership = 524288,
    Synchronize = 1048576,
    FullControl = 2032127
}


export enum InheritanceFlags {
    None = 0,
    ContainerInherit = 1,
    ObjectInherit = 2
}


export enum MutexRights {
    Modify = 1,
    Delete = 65536,
    ReadPermissions = 131072,
    ChangePermissions = 262144,
    TakeOwnership = 524288,
    Synchronize = 1048576,
    FullControl = 2031617
}


export enum ObjectAceFlags {
    None = 0,
    ObjectAceTypePresent = 1,
    InheritedObjectAceTypePresent = 2
}


export enum PropagationFlags {
    None = 0,
    NoPropagateInherit = 1,
    InheritOnly = 2
}


export enum RegistryRights {
    QueryValues = 1,
    SetValue = 2,
    CreateSubKey = 4,
    EnumerateSubKeys = 8,
    Notify = 16,
    CreateLink = 32,
    Delete = 65536,
    ReadPermissions = 131072,
    WriteKey = 131078,
    ExecuteKey = 131097,
    ReadKey = 131097,
    ChangePermissions = 262144,
    TakeOwnership = 524288,
    FullControl = 983103
}


export enum ResourceType {
    Unknown = 0,
    FileObject = 1,
    Service = 2,
    Printer = 3,
    RegistryKey = 4,
    LMShare = 5,
    KernelObject = 6,
    WindowObject = 7,
    DSObject = 8,
    DSObjectAll = 9,
    ProviderDefined = 10,
    WmiGuidObject = 11,
    RegistryWow6432Key = 12
}


export enum SecurityInfos {
    Owner = 1,
    Group = 2,
    DiscretionaryAcl = 4,
    SystemAcl = 8
}


export enum SemaphoreRights {
    Modify = 2,
    Delete = 65536,
    ReadPermissions = 131072,
    ChangePermissions = 262144,
    TakeOwnership = 524288,
    Synchronize = 1048576,
    FullControl = 2031619
}


export interface AccessRule$instance extends AuthorizationRule {
    readonly AccessControlType: AccessControlType;
}


export const AccessRule: {
};


export type AccessRule = AccessRule$instance;

export interface AccessRule_1$instance<T extends unknown> extends AccessRule {
    readonly Rights: T;
}


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>;
};


export type AccessRule_1<T> = AccessRule_1$instance<T>;

export interface AceEnumerator$instance {
    readonly Current: GenericAce | unknown;
    MoveNext(): boolean;
    Reset(): void;
}


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


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

export type AceEnumerator = AceEnumerator$instance & __AceEnumerator$views;


export interface AuditRule$instance extends AuthorizationRule {
    readonly AuditFlags: AuditFlags;
}


export const AuditRule: {
};


export type AuditRule = AuditRule$instance;

export interface AuditRule_1$instance<T extends unknown> extends AuditRule {
    readonly Rights: T;
}


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>;
};


export type AuditRule_1<T> = AuditRule_1$instance<T>;

export interface AuthorizationRule$instance {
    readonly IdentityReference: IdentityReference;
    readonly InheritanceFlags: InheritanceFlags;
    readonly IsInherited: boolean;
    readonly PropagationFlags: PropagationFlags;
}


export const AuthorizationRule: {
};


export type AuthorizationRule = AuthorizationRule$instance;

export interface AuthorizationRuleCollection$instance extends ReadOnlyCollectionBase {
    readonly Item: AuthorizationRule;
    AddRule(rule: AuthorizationRule): void;
    CopyTo(array: ClrArray, index: int): void;
    GetEnumerator(): IEnumerator;
}


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


export interface __AuthorizationRuleCollection$views {
    As_ICollection(): System_Collections_Internal.ICollection$instance;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
}

export interface AuthorizationRuleCollection$instance extends System_Collections_Internal.ICollection$instance {}

export type AuthorizationRuleCollection = AuthorizationRuleCollection$instance & __AuthorizationRuleCollection$views;


export interface CommonAce$instance extends QualifiedAce {
    readonly BinaryLength: int;
    GetBinaryForm(binaryForm: byte[], offset: int): void;
}


export const CommonAce: {
    new(flags: AceFlags, qualifier: AceQualifier, accessMask: int, sid: SecurityIdentifier, isCallback: boolean, opaque: byte[]): CommonAce$instance;
    MaxOpaqueLength(isCallback: boolean): int;
};


export type CommonAce = CommonAce$instance;

export interface CommonAcl$instance extends GenericAcl$instance {
    readonly BinaryLength: int;
    readonly Count: int;
    readonly IsCanonical: boolean;
    readonly IsContainer: boolean;
    readonly IsDS: boolean;
    Item: GenericAce;
    readonly Revision: byte;
    CopyTo(array: GenericAce[], index: int): void;
    CopyTo(array: ClrArray, index: int): void;
    GetBinaryForm(binaryForm: byte[], offset: int): void;
    GetEnumerator(): AceEnumerator;
    GetEnumerator(): IEnumerator;
    Purge(sid: SecurityIdentifier): void;
    RemoveInheritedAces(): void;
}


export const CommonAcl: {
};


export interface __CommonAcl$views {
    As_ICollection(): System_Collections_Internal.ICollection$instance;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
}

export type CommonAcl = CommonAcl$instance & __CommonAcl$views;


export interface CommonObjectSecurity$instance extends ObjectSecurity {
    GetAccessRules(includeExplicit: boolean, includeInherited: boolean, targetType: Type): AuthorizationRuleCollection;
    GetAuditRules(includeExplicit: boolean, includeInherited: boolean, targetType: Type): AuthorizationRuleCollection;
}


export const CommonObjectSecurity: {
};


export type CommonObjectSecurity = CommonObjectSecurity$instance;

export interface CommonSecurityDescriptor$instance extends GenericSecurityDescriptor {
    readonly ControlFlags: ControlFlags;
    DiscretionaryAcl: DiscretionaryAcl;
    Group: SecurityIdentifier;
    readonly IsContainer: boolean;
    readonly IsDiscretionaryAclCanonical: boolean;
    readonly IsDS: boolean;
    readonly IsSystemAclCanonical: boolean;
    Owner: SecurityIdentifier;
    SystemAcl: SystemAcl;
    AddDiscretionaryAcl(revision: byte, trusted: int): void;
    AddSystemAcl(revision: byte, trusted: int): void;
    PurgeAccessControl(sid: SecurityIdentifier): void;
    PurgeAudit(sid: SecurityIdentifier): 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;
};


export type CommonSecurityDescriptor = CommonSecurityDescriptor$instance;

export interface CompoundAce$instance extends KnownAce {
    readonly BinaryLength: int;
    CompoundAceType: CompoundAceType;
    GetBinaryForm(binaryForm: byte[], offset: int): void;
}


export const CompoundAce: {
    new(flags: AceFlags, accessMask: int, compoundAceType: CompoundAceType, sid: SecurityIdentifier): CompoundAce$instance;
};


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;
}


export const CustomAce: {
    new(type_: AceType, flags: AceFlags, opaque: byte[]): CustomAce$instance;
    readonly MaxOpaqueLength: int;
};


export type CustomAce = CustomAce$instance;

export interface DirectoryObjectSecurity$instance extends ObjectSecurity {
    AccessRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType, objectType: Guid, inheritedObjectType: Guid): AccessRule;
    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, objectType: Guid, inheritedObjectType: Guid): AuditRule;
    AuditRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): AuditRule;
    GetAccessRules(includeExplicit: boolean, includeInherited: boolean, targetType: Type): AuthorizationRuleCollection;
    GetAuditRules(includeExplicit: boolean, includeInherited: boolean, targetType: Type): AuthorizationRuleCollection;
}


export const DirectoryObjectSecurity: {
};


export type DirectoryObjectSecurity = DirectoryObjectSecurity$instance;

export interface DirectorySecurity$instance extends FileSystemSecurity {
}


export const DirectorySecurity: {
    new(): DirectorySecurity$instance;
    new(name: string, includeSections: AccessControlSections): DirectorySecurity$instance;
};


export type DirectorySecurity = DirectorySecurity$instance;

export interface DiscretionaryAcl$instance extends CommonAcl$instance {
    AddAccess(accessType: AccessControlType, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags): void;
    AddAccess(accessType: AccessControlType, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, objectFlags: ObjectAceFlags, objectType: Guid, inheritedObjectType: Guid): void;
    AddAccess(accessType: AccessControlType, sid: SecurityIdentifier, rule: ObjectAccessRule): void;
    CopyTo(array: ClrArray, index: int): void;
    CopyTo(array: GenericAce[], index: int): void;
    GetEnumerator(): IEnumerator;
    GetEnumerator(): AceEnumerator;
    RemoveAccess(accessType: AccessControlType, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags): boolean;
    RemoveAccess(accessType: AccessControlType, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, objectFlags: ObjectAceFlags, objectType: Guid, inheritedObjectType: Guid): boolean;
    RemoveAccess(accessType: AccessControlType, sid: SecurityIdentifier, rule: ObjectAccessRule): boolean;
    RemoveAccessSpecific(accessType: AccessControlType, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags): void;
    RemoveAccessSpecific(accessType: AccessControlType, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, objectFlags: ObjectAceFlags, objectType: Guid, inheritedObjectType: Guid): void;
    RemoveAccessSpecific(accessType: AccessControlType, sid: SecurityIdentifier, rule: ObjectAccessRule): void;
    SetAccess(accessType: AccessControlType, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags): void;
    SetAccess(accessType: AccessControlType, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, objectFlags: ObjectAceFlags, objectType: Guid, inheritedObjectType: Guid): void;
    SetAccess(accessType: AccessControlType, sid: SecurityIdentifier, rule: ObjectAccessRule): void;
}


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;
};


export interface __DiscretionaryAcl$views {
    As_ICollection(): System_Collections_Internal.ICollection$instance;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
}

export type DiscretionaryAcl = DiscretionaryAcl$instance & __DiscretionaryAcl$views;


export interface EventWaitHandleAccessRule$instance extends AccessRule {
    readonly EventWaitHandleRights: EventWaitHandleRights;
}


export const EventWaitHandleAccessRule: {
    new(identity: IdentityReference, eventRights: EventWaitHandleRights, type_: AccessControlType): EventWaitHandleAccessRule$instance;
    new(identity: string, eventRights: EventWaitHandleRights, type_: AccessControlType): EventWaitHandleAccessRule$instance;
};


export type EventWaitHandleAccessRule = EventWaitHandleAccessRule$instance;

export interface EventWaitHandleAuditRule$instance extends AuditRule {
    readonly EventWaitHandleRights: EventWaitHandleRights;
}


export const EventWaitHandleAuditRule: {
    new(identity: IdentityReference, eventRights: EventWaitHandleRights, flags: AuditFlags): EventWaitHandleAuditRule$instance;
};


export type EventWaitHandleAuditRule = EventWaitHandleAuditRule$instance;

export interface EventWaitHandleSecurity$instance extends NativeObjectSecurity {
    readonly AccessRightType: Type;
    readonly AccessRuleType: Type;
    readonly AuditRuleType: Type;
    AccessRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): AccessRule;
    AddAccessRule(rule: EventWaitHandleAccessRule): void;
    AddAuditRule(rule: EventWaitHandleAuditRule): void;
    AuditRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): AuditRule;
    RemoveAccessRule(rule: EventWaitHandleAccessRule): boolean;
    RemoveAccessRuleAll(rule: EventWaitHandleAccessRule): void;
    RemoveAccessRuleSpecific(rule: EventWaitHandleAccessRule): void;
    RemoveAuditRule(rule: EventWaitHandleAuditRule): boolean;
    RemoveAuditRuleAll(rule: EventWaitHandleAuditRule): void;
    RemoveAuditRuleSpecific(rule: EventWaitHandleAuditRule): void;
    ResetAccessRule(rule: EventWaitHandleAccessRule): void;
    SetAccessRule(rule: EventWaitHandleAccessRule): void;
    SetAuditRule(rule: EventWaitHandleAuditRule): void;
}


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


export type EventWaitHandleSecurity = EventWaitHandleSecurity$instance;

export interface FileSecurity$instance extends FileSystemSecurity {
}


export const FileSecurity: {
    new(): FileSecurity$instance;
    new(fileName: string, includeSections: AccessControlSections): FileSecurity$instance;
};


export type FileSecurity = FileSecurity$instance;

export interface FileSystemAccessRule$instance extends AccessRule {
    readonly FileSystemRights: FileSystemRights;
}


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;
};


export type FileSystemAccessRule = FileSystemAccessRule$instance;

export interface FileSystemAuditRule$instance extends AuditRule {
    readonly FileSystemRights: FileSystemRights;
}


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;
};


export type FileSystemAuditRule = FileSystemAuditRule$instance;

export interface FileSystemSecurity$instance extends NativeObjectSecurity {
    readonly AccessRightType: Type;
    readonly AccessRuleType: Type;
    readonly AuditRuleType: Type;
    AccessRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): AccessRule;
    AddAccessRule(rule: FileSystemAccessRule): void;
    AddAuditRule(rule: FileSystemAuditRule): void;
    AuditRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): AuditRule;
    RemoveAccessRule(rule: FileSystemAccessRule): boolean;
    RemoveAccessRuleAll(rule: FileSystemAccessRule): void;
    RemoveAccessRuleSpecific(rule: FileSystemAccessRule): void;
    RemoveAuditRule(rule: FileSystemAuditRule): boolean;
    RemoveAuditRuleAll(rule: FileSystemAuditRule): void;
    RemoveAuditRuleSpecific(rule: FileSystemAuditRule): void;
    ResetAccessRule(rule: FileSystemAccessRule): void;
    SetAccessRule(rule: FileSystemAccessRule): void;
    SetAuditRule(rule: FileSystemAuditRule): void;
}


export const FileSystemSecurity: {
};


export type FileSystemSecurity = FileSystemSecurity$instance;

export interface GenericAce$instance {
    AceFlags: AceFlags;
    readonly AceType: AceType;
    readonly AuditFlags: AuditFlags;
    readonly BinaryLength: int;
    readonly InheritanceFlags: InheritanceFlags;
    readonly IsInherited: boolean;
    readonly PropagationFlags: PropagationFlags;
    Copy(): GenericAce;
    Equals(o: unknown): boolean;
    GetBinaryForm(binaryForm: byte[], offset: int): void;
    GetHashCode(): int;
}


export const GenericAce: {
    CreateFromBinaryForm(binaryForm: byte[], offset: int): GenericAce;
};


export type GenericAce = GenericAce$instance;

export interface GenericAcl$instance {
    readonly BinaryLength: int;
    readonly Count: int;
    readonly IsSynchronized: boolean;
    Item: GenericAce;
    readonly Revision: byte;
    readonly SyncRoot: unknown;
    CopyTo(array: GenericAce[], index: int): void;
    GetBinaryForm(binaryForm: byte[], offset: int): void;
    GetEnumerator(): AceEnumerator;
}


export const GenericAcl: {
    readonly AclRevision: byte;
    readonly AclRevisionDS: byte;
    readonly MaxBinaryLength: int;
};


export interface __GenericAcl$views {
    As_ICollection(): System_Collections_Internal.ICollection$instance;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
}

export type GenericAcl = GenericAcl$instance & __GenericAcl$views;


export interface GenericSecurityDescriptor$instance {
    readonly BinaryLength: int;
    readonly ControlFlags: ControlFlags;
    Group: SecurityIdentifier;
    Owner: SecurityIdentifier;
    GetBinaryForm(binaryForm: byte[], offset: int): void;
    GetSddlForm(includeSections: AccessControlSections): string;
}


export const GenericSecurityDescriptor: {
    readonly Revision: byte;
    IsSddlConversionSupported(): boolean;
};


export type GenericSecurityDescriptor = GenericSecurityDescriptor$instance;

export interface KnownAce$instance extends GenericAce {
    AccessMask: int;
    SecurityIdentifier: SecurityIdentifier;
}


export const KnownAce: {
};


export type KnownAce = KnownAce$instance;

export interface MutexAccessRule$instance extends AccessRule {
    readonly MutexRights: MutexRights;
}


export const MutexAccessRule: {
    new(identity: IdentityReference, eventRights: MutexRights, type_: AccessControlType): MutexAccessRule$instance;
    new(identity: string, eventRights: MutexRights, type_: AccessControlType): MutexAccessRule$instance;
};


export type MutexAccessRule = MutexAccessRule$instance;

export interface MutexAuditRule$instance extends AuditRule {
    readonly MutexRights: MutexRights;
}


export const MutexAuditRule: {
    new(identity: IdentityReference, eventRights: MutexRights, flags: AuditFlags): MutexAuditRule$instance;
};


export type MutexAuditRule = MutexAuditRule$instance;

export interface MutexSecurity$instance extends NativeObjectSecurity {
    readonly AccessRightType: Type;
    readonly AccessRuleType: Type;
    readonly AuditRuleType: Type;
    AccessRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): AccessRule;
    AddAccessRule(rule: MutexAccessRule): void;
    AddAuditRule(rule: MutexAuditRule): void;
    AuditRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): AuditRule;
    RemoveAccessRule(rule: MutexAccessRule): boolean;
    RemoveAccessRuleAll(rule: MutexAccessRule): void;
    RemoveAccessRuleSpecific(rule: MutexAccessRule): void;
    RemoveAuditRule(rule: MutexAuditRule): boolean;
    RemoveAuditRuleAll(rule: MutexAuditRule): void;
    RemoveAuditRuleSpecific(rule: MutexAuditRule): void;
    ResetAccessRule(rule: MutexAccessRule): void;
    SetAccessRule(rule: MutexAccessRule): void;
    SetAuditRule(rule: MutexAuditRule): void;
}


export const MutexSecurity: {
    new(): MutexSecurity$instance;
    new(name: string, includeSections: AccessControlSections): MutexSecurity$instance;
};


export type MutexSecurity = MutexSecurity$instance;

export interface NativeObjectSecurity$instance extends CommonObjectSecurity {
}


export const NativeObjectSecurity: {
};


export type NativeObjectSecurity = NativeObjectSecurity$instance;

export interface ObjectAccessRule$instance extends AccessRule {
    readonly InheritedObjectType: Guid;
    readonly ObjectFlags: ObjectAceFlags;
    readonly ObjectType: Guid;
}


export const ObjectAccessRule: {
};


export type ObjectAccessRule = ObjectAccessRule$instance;

export interface ObjectAce$instance extends QualifiedAce {
    readonly BinaryLength: int;
    InheritedObjectAceType: Guid;
    ObjectAceFlags: ObjectAceFlags;
    ObjectAceType: Guid;
    GetBinaryForm(binaryForm: byte[], offset: int): void;
}


export const ObjectAce: {
    new(aceFlags: AceFlags, qualifier: AceQualifier, accessMask: int, sid: SecurityIdentifier, flags: ObjectAceFlags, type_: Guid, inheritedType: Guid, isCallback: boolean, opaque: byte[]): ObjectAce$instance;
    MaxOpaqueLength(isCallback: boolean): int;
};


export type ObjectAce = ObjectAce$instance;

export interface ObjectAuditRule$instance extends AuditRule {
    readonly InheritedObjectType: Guid;
    readonly ObjectFlags: ObjectAceFlags;
    readonly ObjectType: Guid;
}


export const ObjectAuditRule: {
};


export type ObjectAuditRule = ObjectAuditRule$instance;

export interface ObjectSecurity$instance {
    readonly AccessRightType: Type;
    readonly AccessRuleType: Type;
    readonly AreAccessRulesCanonical: boolean;
    readonly AreAccessRulesProtected: boolean;
    readonly AreAuditRulesCanonical: boolean;
    readonly AreAuditRulesProtected: boolean;
    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;
    GetSecurityDescriptorBinaryForm(): byte[];
    GetSecurityDescriptorSddlForm(includeSections: AccessControlSections): string;
    ModifyAccessRule(modification: AccessControlModification, rule: AccessRule, modified: { value: ref<boolean> }): boolean;
    ModifyAuditRule(modification: AccessControlModification, rule: AuditRule, modified: { value: ref<boolean> }): boolean;
    PurgeAccessRules(identity: IdentityReference): void;
    PurgeAuditRules(identity: IdentityReference): void;
    SetAccessRuleProtection(isProtected: boolean, preserveInheritance: boolean): void;
    SetAuditRuleProtection(isProtected: boolean, preserveInheritance: boolean): void;
    SetGroup(identity: IdentityReference): void;
    SetOwner(identity: IdentityReference): void;
    SetSecurityDescriptorBinaryForm(binaryForm: byte[]): void;
    SetSecurityDescriptorBinaryForm(binaryForm: byte[], includeSections: AccessControlSections): void;
    SetSecurityDescriptorSddlForm(sddlForm: string): void;
    SetSecurityDescriptorSddlForm(sddlForm: string, includeSections: AccessControlSections): void;
}


export const ObjectSecurity: {
    IsSddlConversionSupported(): boolean;
};


export type ObjectSecurity = ObjectSecurity$instance;

export interface ObjectSecurity_1$instance<T extends unknown> extends NativeObjectSecurity {
    readonly AccessRightType: Type;
    readonly AccessRuleType: Type;
    readonly AuditRuleType: Type;
    AccessRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): AccessRule;
    AddAccessRule(rule: AccessRule_1<T>): void;
    AddAuditRule(rule: AuditRule_1<T>): void;
    AuditRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): AuditRule;
    RemoveAccessRule(rule: AccessRule_1<T>): boolean;
    RemoveAccessRuleAll(rule: AccessRule_1<T>): void;
    RemoveAccessRuleSpecific(rule: AccessRule_1<T>): void;
    RemoveAuditRule(rule: AuditRule_1<T>): boolean;
    RemoveAuditRuleAll(rule: AuditRule_1<T>): void;
    RemoveAuditRuleSpecific(rule: AuditRule_1<T>): void;
    ResetAccessRule(rule: AccessRule_1<T>): void;
    SetAccessRule(rule: AccessRule_1<T>): void;
    SetAuditRule(rule: AuditRule_1<T>): void;
}


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;
}


export const PrivilegeNotHeldException: {
    new(): PrivilegeNotHeldException$instance;
    new(privilege: string): PrivilegeNotHeldException$instance;
    new(privilege: string, inner: Exception): PrivilegeNotHeldException$instance;
};


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

export type PrivilegeNotHeldException = PrivilegeNotHeldException$instance & __PrivilegeNotHeldException$views;


export interface QualifiedAce$instance extends KnownAce {
    readonly AceQualifier: AceQualifier;
    readonly IsCallback: boolean;
    readonly OpaqueLength: int;
    GetOpaque(): byte[];
    SetOpaque(opaque: byte[]): void;
}


export const QualifiedAce: {
};


export type QualifiedAce = QualifiedAce$instance;

export interface RawAcl$instance extends GenericAcl$instance {
    readonly BinaryLength: int;
    readonly Count: int;
    Item: GenericAce;
    readonly Revision: byte;
    CopyTo(array: GenericAce[], index: int): void;
    CopyTo(array: ClrArray, index: int): void;
    GetBinaryForm(binaryForm: byte[], offset: int): void;
    GetEnumerator(): AceEnumerator;
    GetEnumerator(): IEnumerator;
    InsertAce(index: int, ace: GenericAce): void;
    RemoveAce(index: int): void;
}


export const RawAcl: {
    new(revision: byte, capacity: int): RawAcl$instance;
    new(binaryForm: byte[], offset: int): RawAcl$instance;
};


export interface __RawAcl$views {
    As_ICollection(): System_Collections_Internal.ICollection$instance;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
}

export type RawAcl = RawAcl$instance & __RawAcl$views;


export interface RawSecurityDescriptor$instance extends GenericSecurityDescriptor {
    readonly ControlFlags: ControlFlags;
    DiscretionaryAcl: RawAcl;
    Group: SecurityIdentifier;
    Owner: SecurityIdentifier;
    ResourceManagerControl: byte;
    SystemAcl: RawAcl;
    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;
};


export type RawSecurityDescriptor = RawSecurityDescriptor$instance;

export interface RegistryAccessRule$instance extends AccessRule {
    readonly RegistryRights: RegistryRights;
}


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;
};


export type RegistryAccessRule = RegistryAccessRule$instance;

export interface RegistryAuditRule$instance extends AuditRule {
    readonly RegistryRights: RegistryRights;
}


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;
};


export type RegistryAuditRule = RegistryAuditRule$instance;

export interface RegistrySecurity$instance extends NativeObjectSecurity {
    readonly AccessRightType: Type;
    readonly AccessRuleType: Type;
    readonly AuditRuleType: Type;
    AccessRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): AccessRule;
    AddAccessRule(rule: RegistryAccessRule): void;
    AddAuditRule(rule: RegistryAuditRule): void;
    AuditRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): AuditRule;
    RemoveAccessRule(rule: RegistryAccessRule): boolean;
    RemoveAccessRuleAll(rule: RegistryAccessRule): void;
    RemoveAccessRuleSpecific(rule: RegistryAccessRule): void;
    RemoveAuditRule(rule: RegistryAuditRule): boolean;
    RemoveAuditRuleAll(rule: RegistryAuditRule): void;
    RemoveAuditRuleSpecific(rule: RegistryAuditRule): void;
    ResetAccessRule(rule: RegistryAccessRule): void;
    SetAccessRule(rule: RegistryAccessRule): void;
    SetAuditRule(rule: RegistryAuditRule): void;
}


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


export type RegistrySecurity = RegistrySecurity$instance;

export interface SemaphoreAccessRule$instance extends AccessRule {
    readonly SemaphoreRights: SemaphoreRights;
}


export const SemaphoreAccessRule: {
    new(identity: IdentityReference, eventRights: SemaphoreRights, type_: AccessControlType): SemaphoreAccessRule$instance;
    new(identity: string, eventRights: SemaphoreRights, type_: AccessControlType): SemaphoreAccessRule$instance;
};


export type SemaphoreAccessRule = SemaphoreAccessRule$instance;

export interface SemaphoreAuditRule$instance extends AuditRule {
    readonly SemaphoreRights: SemaphoreRights;
}


export const SemaphoreAuditRule: {
    new(identity: IdentityReference, eventRights: SemaphoreRights, flags: AuditFlags): SemaphoreAuditRule$instance;
};


export type SemaphoreAuditRule = SemaphoreAuditRule$instance;

export interface SemaphoreSecurity$instance extends NativeObjectSecurity {
    readonly AccessRightType: Type;
    readonly AccessRuleType: Type;
    readonly AuditRuleType: Type;
    AccessRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, type_: AccessControlType): AccessRule;
    AddAccessRule(rule: SemaphoreAccessRule): void;
    AddAuditRule(rule: SemaphoreAuditRule): void;
    AuditRuleFactory(identityReference: IdentityReference, accessMask: int, isInherited: boolean, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, flags: AuditFlags): AuditRule;
    RemoveAccessRule(rule: SemaphoreAccessRule): boolean;
    RemoveAccessRuleAll(rule: SemaphoreAccessRule): void;
    RemoveAccessRuleSpecific(rule: SemaphoreAccessRule): void;
    RemoveAuditRule(rule: SemaphoreAuditRule): boolean;
    RemoveAuditRuleAll(rule: SemaphoreAuditRule): void;
    RemoveAuditRuleSpecific(rule: SemaphoreAuditRule): void;
    ResetAccessRule(rule: SemaphoreAccessRule): void;
    SetAccessRule(rule: SemaphoreAccessRule): void;
    SetAuditRule(rule: SemaphoreAuditRule): void;
}


export const SemaphoreSecurity: {
    new(): SemaphoreSecurity$instance;
    new(name: string, includeSections: AccessControlSections): SemaphoreSecurity$instance;
};


export type SemaphoreSecurity = SemaphoreSecurity$instance;

export interface SystemAcl$instance extends CommonAcl$instance {
    AddAudit(auditFlags: AuditFlags, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags): void;
    AddAudit(auditFlags: AuditFlags, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, objectFlags: ObjectAceFlags, objectType: Guid, inheritedObjectType: Guid): void;
    AddAudit(sid: SecurityIdentifier, rule: ObjectAuditRule): void;
    CopyTo(array: ClrArray, index: int): void;
    CopyTo(array: GenericAce[], index: int): void;
    GetEnumerator(): IEnumerator;
    GetEnumerator(): AceEnumerator;
    RemoveAudit(auditFlags: AuditFlags, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags): boolean;
    RemoveAudit(auditFlags: AuditFlags, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, objectFlags: ObjectAceFlags, objectType: Guid, inheritedObjectType: Guid): boolean;
    RemoveAudit(sid: SecurityIdentifier, rule: ObjectAuditRule): boolean;
    RemoveAuditSpecific(auditFlags: AuditFlags, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags): void;
    RemoveAuditSpecific(auditFlags: AuditFlags, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, objectFlags: ObjectAceFlags, objectType: Guid, inheritedObjectType: Guid): void;
    RemoveAuditSpecific(sid: SecurityIdentifier, rule: ObjectAuditRule): void;
    SetAudit(auditFlags: AuditFlags, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags): void;
    SetAudit(auditFlags: AuditFlags, sid: SecurityIdentifier, accessMask: int, inheritanceFlags: InheritanceFlags, propagationFlags: PropagationFlags, objectFlags: ObjectAceFlags, objectType: Guid, inheritedObjectType: Guid): void;
    SetAudit(sid: SecurityIdentifier, rule: ObjectAuditRule): void;
}


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;
};


export interface __SystemAcl$views {
    As_ICollection(): System_Collections_Internal.ICollection$instance;
    As_IEnumerable(): System_Collections_Internal.IEnumerable$instance;
}

export type SystemAcl = SystemAcl$instance & __SystemAcl$views;