## API Report File for "@azure/arm-avs"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

// @public
export type ActionType = string;

// @public
export interface Addon extends ProxyResource {
    properties?: AddonPropertiesUnion;
}

// @public
export interface AddonArcProperties extends AddonProperties {
    addonType: "Arc";
    vCenter?: string;
}

// @public
export interface AddonHcxProperties extends AddonProperties {
    addonType: "HCX";
    managementNetwork?: string;
    offer: string;
    uplinkNetwork?: string;
}

// @public
export interface AddonProperties {
    addonType: AddonType;
    readonly provisioningState?: AddonProvisioningState;
}

// @public
export type AddonPropertiesUnion = AddonSrmProperties | AddonVrProperties | AddonHcxProperties | AddonArcProperties | AddonProperties;

// @public
export type AddonProvisioningState = string;

// @public
export interface AddonSrmProperties extends AddonProperties {
    addonType: "SRM";
    licenseKey?: string;
}

// @public
export type AddonType = string;

// @public
export interface AddonVrProperties extends AddonProperties {
    addonType: "VR";
    vrsCount: number;
}

// @public
export interface AdminCredentials {
    readonly nsxtPassword?: string;
    readonly nsxtUsername?: string;
    readonly vcenterPassword?: string;
    readonly vcenterUsername?: string;
}

// @public
export type AffinityStrength = string;

// @public
export type AffinityType = string;

// @public
export interface AvailabilityProperties {
    secondaryZone?: number;
    strategy?: AvailabilityStrategy;
    zone?: number;
}

// @public
export type AvailabilityStrategy = string;

// @public
export interface AvailableWindowForMaintenanceWhileRescheduleOperation extends RescheduleOperationConstraint {
    readonly endsAt: Date;
    kind: "AvailableWindowForMaintenance";
    readonly startsAt: Date;
}

// @public
export interface AvailableWindowForMaintenanceWhileScheduleOperation extends ScheduleOperationConstraint {
    readonly endsAt: Date;
    kind: "AvailableWindowForMaintenance";
    readonly startsAt: Date;
}

// @public
export type AzureHybridBenefitType = string;

// @public
export type BlockedDatesConstraintCategory = string;

// @public
export interface BlockedDatesConstraintTimeRange {
    readonly endsAt: Date;
    readonly reason?: string;
    readonly startsAt: Date;
}

// @public
export interface BlockedWhileRescheduleOperation extends RescheduleOperationConstraint {
    readonly category: BlockedDatesConstraintCategory;
    kind: "Blocked";
    readonly timeRanges?: BlockedDatesConstraintTimeRange[];
}

// @public
export interface BlockedWhileScheduleOperation extends ScheduleOperationConstraint {
    readonly category: BlockedDatesConstraintCategory;
    kind: "Blocked";
    readonly timeRanges?: BlockedDatesConstraintTimeRange[];
}

// @public
export interface Circuit {
    readonly expressRouteID?: string;
    readonly expressRoutePrivatePeeringID?: string;
    readonly primarySubnet?: string;
    readonly secondarySubnet?: string;
}

// @public
export interface CloudLink extends ProxyResource {
    properties?: CloudLinkProperties;
}

// @public
export interface CloudLinkProperties {
    linkedCloud?: string;
    readonly provisioningState?: CloudLinkProvisioningState;
    readonly status?: CloudLinkStatus;
}

// @public
export type CloudLinkProvisioningState = string;

// @public
export type CloudLinkStatus = string;

// @public
export interface Cluster extends ProxyResource {
    properties?: ClusterProperties;
    sku: Sku;
}

// @public
export interface ClusterProperties {
    readonly clusterId?: number;
    clusterSize?: number;
    hosts?: string[];
    readonly provisioningState?: ClusterProvisioningState;
    vsanDatastoreName?: string;
}

// @public
export type ClusterProvisioningState = string;

// @public
export interface ClusterUpdate {
    properties?: ClusterUpdateProperties;
    sku?: Sku;
}

// @public
export interface ClusterUpdateProperties {
    clusterSize?: number;
    hosts?: string[];
}

// @public
export interface ClusterZone {
    readonly hosts?: string[];
    readonly zone?: string;
}

// @public
export interface ClusterZoneList {
    zones?: ClusterZone[];
}

// @public
export type CreatedByType = string;

// @public
export interface Datastore extends ProxyResource {
    properties?: DatastoreProperties;
}

// @public
export interface DatastoreProperties {
    diskPoolVolume?: DiskPoolVolume;
    elasticSanVolume?: ElasticSanVolume;
    netAppVolume?: NetAppVolume;
    readonly provisioningState?: DatastoreProvisioningState;
    pureStorageVolume?: PureStorageVolume;
    readonly status?: DatastoreStatus;
}

// @public
export type DatastoreProvisioningState = string;

// @public
export type DatastoreStatus = string;

// @public
export type DhcpTypeEnum = string;

// @public
export interface DiskPoolVolume {
    lunName: string;
    mountOption?: MountOptionEnum;
    readonly path?: string;
    targetId: string;
}

// @public
export type DnsServiceLogLevelEnum = string;

// @public
export type DnsServiceStatusEnum = string;

// @public
export type DnsZoneType = string;

// @public
export interface ElasticSanVolume {
    targetId: string;
}

// @public
export interface Encryption {
    keyVaultProperties?: EncryptionKeyVaultProperties;
    status?: EncryptionState;
}

// @public
export type EncryptionKeyStatus = string;

// @public
export interface EncryptionKeyVaultProperties {
    readonly autoDetectedKeyVersion?: string;
    keyName?: string;
    readonly keyState?: EncryptionKeyStatus;
    keyVaultUrl?: string;
    keyVersion?: string;
    readonly versionType?: EncryptionVersionType;
}

// @public
export type EncryptionState = string;

// @public
export type EncryptionVersionType = string;

// @public
export interface Endpoints {
    readonly hcxCloudManager?: string;
    readonly hcxCloudManagerIp?: string;
    readonly nsxtManager?: string;
    readonly nsxtManagerIp?: string;
    readonly vcenterIp?: string;
    readonly vcsa?: string;
}

// @public
export interface ErrorAdditionalInfo {
    readonly info?: any;
    readonly type?: string;
}

// @public
export interface ErrorDetail {
    readonly additionalInfo?: ErrorAdditionalInfo[];
    readonly code?: string;
    readonly details?: ErrorDetail[];
    readonly message?: string;
    readonly target?: string;
}

// @public
export interface ErrorResponse {
    error?: ErrorDetail;
}

// @public
export interface ExpressRouteAuthorization extends ProxyResource {
    properties?: ExpressRouteAuthorizationProperties;
}

// @public
export interface ExpressRouteAuthorizationProperties {
    readonly expressRouteAuthorizationId?: string;
    readonly expressRouteAuthorizationKey?: string;
    expressRouteId?: string;
    readonly provisioningState?: ExpressRouteAuthorizationProvisioningState;
}

// @public
export type ExpressRouteAuthorizationProvisioningState = string;

// @public
export interface GeneralHostProperties extends HostProperties {
    kind: "General";
}

// @public
export interface GlobalReachConnection extends ProxyResource {
    properties?: GlobalReachConnectionProperties;
}

// @public
export interface GlobalReachConnectionProperties {
    readonly addressPrefix?: string;
    authorizationKey?: string;
    readonly circuitConnectionStatus?: GlobalReachConnectionStatus;
    expressRouteId?: string;
    peerExpressRouteCircuit?: string;
    readonly provisioningState?: GlobalReachConnectionProvisioningState;
}

// @public
export type GlobalReachConnectionProvisioningState = string;

// @public
export type GlobalReachConnectionStatus = string;

// @public
export interface HcxEnterpriseSite extends ProxyResource {
    properties?: HcxEnterpriseSiteProperties;
}

// @public
export interface HcxEnterpriseSiteProperties {
    readonly activationKey?: string;
    readonly provisioningState?: HcxEnterpriseSiteProvisioningState;
    readonly status?: HcxEnterpriseSiteStatus;
}

// @public
export type HcxEnterpriseSiteProvisioningState = string;

// @public
export type HcxEnterpriseSiteStatus = string;

// @public
export interface Host extends ProxyResource {
    properties?: HostPropertiesUnion;
    sku?: Sku;
    zones?: string[];
}

// @public
export type HostKind = string;

// @public
export type HostMaintenance = string;

// @public
export interface HostProperties {
    displayName?: string;
    // (undocumented)
    readonly faultDomain?: string;
    readonly fqdn?: string;
    kind: HostKind;
    maintenance?: HostMaintenance;
    readonly moRefId?: string;
    readonly provisioningState?: HostProvisioningState;
}

// @public
export type HostPropertiesUnion = GeneralHostProperties | SpecializedHostProperties | HostProperties;

// @public
export type HostProvisioningState = string;

// @public
export interface IdentitySource {
    alias?: string;
    baseGroupDN?: string;
    baseUserDN?: string;
    domain?: string;
    name?: string;
    password?: string;
    primaryServer?: string;
    secondaryServer?: string;
    ssl?: SslEnum;
    username?: string;
}

// @public
export interface ImpactedMaintenanceResource {
    readonly errors?: ImpactedMaintenanceResourceError[];
    readonly id?: string;
}

// @public
export interface ImpactedMaintenanceResourceError {
    readonly actionRequired?: boolean;
    readonly details?: string;
    readonly errorCode?: string;
    readonly name?: string;
    readonly resolutionSteps?: string[];
}

// @public
export type InternetEnum = string;

// @public
export interface IscsiPath extends ProxyResource {
    properties?: IscsiPathProperties;
}

// @public
export interface IscsiPathProperties {
    networkBlock: string;
    readonly provisioningState?: IscsiPathProvisioningState;
}

// @public
export type IscsiPathProvisioningState = string;

// @public
export enum KnownActionType {
    Internal = "Internal"
}

// @public
export enum KnownAddonProvisioningState {
    Building = "Building",
    Canceled = "Canceled",
    Cancelled = "Cancelled",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownAddonType {
    Arc = "Arc",
    HCX = "HCX",
    SRM = "SRM",
    VR = "VR"
}

// @public
export enum KnownAffinityStrength {
    Must = "Must",
    Should = "Should"
}

// @public
export enum KnownAffinityType {
    Affinity = "Affinity",
    AntiAffinity = "AntiAffinity"
}

// @public
export enum KnownAvailabilityStrategy {
    DualZone = "DualZone",
    SingleZone = "SingleZone"
}

// @public
export enum KnownAzureHybridBenefitType {
    None = "None",
    SqlHost = "SqlHost"
}

// @public
export enum KnownBlockedDatesConstraintCategory {
    HiPriorityEvent = "HiPriorityEvent",
    Holiday = "Holiday",
    QuotaExhausted = "QuotaExhausted"
}

// @public
export enum KnownCloudLinkProvisioningState {
    Canceled = "Canceled",
    Failed = "Failed",
    Succeeded = "Succeeded"
}

// @public
export enum KnownCloudLinkStatus {
    Active = "Active",
    Building = "Building",
    Deleting = "Deleting",
    Disconnected = "Disconnected",
    Failed = "Failed"
}

// @public
export enum KnownClusterProvisioningState {
    Canceled = "Canceled",
    Cancelled = "Cancelled",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownCreatedByType {
    Application = "Application",
    Key = "Key",
    ManagedIdentity = "ManagedIdentity",
    User = "User"
}

// @public
export enum KnownDatastoreProvisioningState {
    Canceled = "Canceled",
    Cancelled = "Cancelled",
    Creating = "Creating",
    Deleting = "Deleting",
    Failed = "Failed",
    Pending = "Pending",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownDatastoreStatus {
    Accessible = "Accessible",
    Attached = "Attached",
    DeadOrError = "DeadOrError",
    Detached = "Detached",
    Inaccessible = "Inaccessible",
    LostCommunication = "LostCommunication",
    Unknown = "Unknown"
}

// @public
export enum KnownDhcpTypeEnum {
    Relay = "RELAY",
    Server = "SERVER"
}

// @public
export enum KnownDnsServiceLogLevelEnum {
    Debug = "DEBUG",
    Error = "ERROR",
    Fatal = "FATAL",
    Info = "INFO",
    Warning = "WARNING"
}

// @public
export enum KnownDnsServiceStatusEnum {
    Failure = "FAILURE",
    Success = "SUCCESS"
}

// @public
export enum KnownDnsZoneType {
    Private = "Private",
    Public = "Public"
}

// @public
export enum KnownEncryptionKeyStatus {
    AccessDenied = "AccessDenied",
    Connected = "Connected"
}

// @public
export enum KnownEncryptionState {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownEncryptionVersionType {
    AutoDetected = "AutoDetected",
    Fixed = "Fixed"
}

// @public
export enum KnownExpressRouteAuthorizationProvisioningState {
    Canceled = "Canceled",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownGlobalReachConnectionProvisioningState {
    Canceled = "Canceled",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownGlobalReachConnectionStatus {
    Connected = "Connected",
    Connecting = "Connecting",
    Disconnected = "Disconnected"
}

// @public
export enum KnownHcxEnterpriseSiteProvisioningState {
    Canceled = "Canceled",
    Failed = "Failed",
    Succeeded = "Succeeded"
}

// @public
export enum KnownHcxEnterpriseSiteStatus {
    Available = "Available",
    Consumed = "Consumed",
    Deactivated = "Deactivated",
    Deleted = "Deleted"
}

// @public
export enum KnownHostKind {
    General = "General",
    Specialized = "Specialized"
}

// @public
export enum KnownHostMaintenance {
    Replacement = "Replacement",
    Upgrade = "Upgrade"
}

// @public
export enum KnownHostProvisioningState {
    Canceled = "Canceled",
    Failed = "Failed",
    Succeeded = "Succeeded"
}

// @public
export enum KnownInternetEnum {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownIscsiPathProvisioningState {
    Building = "Building",
    Canceled = "Canceled",
    Deleting = "Deleting",
    Failed = "Failed",
    Pending = "Pending",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownLicenseKind {
    VmwareFirewall = "VmwareFirewall"
}

// @public
export enum KnownLicenseName {
    VmwareFirewall = "VmwareFirewall"
}

// @public
export enum KnownLicenseProvisioningState {
    Canceled = "Canceled",
    Failed = "Failed",
    Succeeded = "Succeeded"
}

// @public
export enum KnownMaintenanceCheckType {
    Precheck = "Precheck",
    Preflight = "Preflight"
}

// @public
export enum KnownMaintenanceManagementOperationKind {
    MaintenanceReadinessRefresh = "MaintenanceReadinessRefresh",
    Reschedule = "Reschedule",
    Schedule = "Schedule"
}

// @public
export enum KnownMaintenanceProvisioningState {
    Canceled = "Canceled",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownMaintenanceReadinessRefreshOperationStatus {
    Failed = "Failed",
    InProgress = "InProgress",
    NotApplicable = "NotApplicable",
    NotStarted = "NotStarted"
}

// @public
export enum KnownMaintenanceReadinessStatus {
    DataNotAvailable = "DataNotAvailable",
    NotApplicable = "NotApplicable",
    NotReady = "NotReady",
    Ready = "Ready"
}

// @public
export enum KnownMaintenanceStateName {
    Canceled = "Canceled",
    Failed = "Failed",
    InProgress = "InProgress",
    NotScheduled = "NotScheduled",
    Scheduled = "Scheduled",
    Success = "Success"
}

// @public
export enum KnownMaintenanceStatusFilter {
    Active = "Active",
    Inactive = "Inactive"
}

// @public
export enum KnownMaintenanceType {
    Esxi = "ESXI",
    Nsxt = "NSXT",
    Vcsa = "VCSA"
}

// @public
export enum KnownMountOptionEnum {
    Attach = "ATTACH",
    Mount = "MOUNT"
}

// @public
export enum KnownNsxPublicIpQuotaRaisedEnum {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownOptionalParamEnum {
    Optional = "Optional",
    Required = "Required"
}

// @public
export enum KnownOrigin {
    System = "system",
    User = "user",
    UserSystem = "user,system"
}

// @public
export enum KnownPlacementPolicyProvisioningState {
    Building = "Building",
    Canceled = "Canceled",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownPlacementPolicyState {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownPlacementPolicyType {
    VmHost = "VmHost",
    VmVm = "VmVm"
}

// @public
export enum KnownPortMirroringDirectionEnum {
    Bidirectional = "BIDIRECTIONAL",
    Egress = "EGRESS",
    Ingress = "INGRESS"
}

// @public
export enum KnownPortMirroringStatusEnum {
    Failure = "FAILURE",
    Success = "SUCCESS"
}

// @public
export enum KnownPrivateCloudProvisioningState {
    Building = "Building",
    Canceled = "Canceled",
    Cancelled = "Cancelled",
    Deleting = "Deleting",
    Failed = "Failed",
    Pending = "Pending",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownProvisionedNetworkProvisioningState {
    Canceled = "Canceled",
    Failed = "Failed",
    Succeeded = "Succeeded"
}

// @public
export enum KnownProvisionedNetworkTypes {
    EsxManagement = "esxManagement",
    EsxReplication = "esxReplication",
    HcxManagement = "hcxManagement",
    HcxUplink = "hcxUplink",
    VcenterManagement = "vcenterManagement",
    Vmotion = "vmotion",
    Vsan = "vsan"
}

// @public
export enum KnownPureStoragePolicyProvisioningState {
    Canceled = "Canceled",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownQuotaEnabled {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownRescheduleOperationConstraintKind {
    AvailableWindowForMaintenanceWhileRescheduleOperation = "AvailableWindowForMaintenance",
    BlockedWhileRescheduleOperation = "Blocked"
}

// @public
export enum KnownResourceIdentityType {
    None = "None",
    SystemAssigned = "SystemAssigned"
}

// @public
export enum KnownResourceSkuResourceType {
    PrivateClouds = "privateClouds",
    PrivateCloudsClusters = "privateClouds/clusters"
}

// @public
export enum KnownResourceSkuRestrictionsReasonCode {
    NotAvailableForSubscription = "NotAvailableForSubscription",
    QuotaId = "QuotaId"
}

// @public
export enum KnownResourceSkuRestrictionsType {
    Location = "Location",
    Zone = "Zone"
}

// @public
export enum KnownScheduleOperationConstraintKind {
    AvailableWindowForMaintenanceWhileScheduleOperation = "AvailableWindowForMaintenance",
    BlockedWhileScheduleOperation = "Blocked",
    SchedulingWindow = "SchedulingWindow"
}

// @public
export enum KnownScriptCmdletAudience {
    Any = "Any",
    Automation = "Automation"
}

// @public
export enum KnownScriptCmdletProvisioningState {
    Canceled = "Canceled",
    Failed = "Failed",
    Succeeded = "Succeeded"
}

// @public
export enum KnownScriptExecutionParameterType {
    Credential = "Credential",
    SecureValue = "SecureValue",
    Value = "Value"
}

// @public
export enum KnownScriptExecutionProvisioningState {
    Canceled = "Canceled",
    Cancelled = "Cancelled",
    Cancelling = "Cancelling",
    Deleting = "Deleting",
    Failed = "Failed",
    Pending = "Pending",
    Running = "Running",
    Succeeded = "Succeeded"
}

// @public
export enum KnownScriptOutputStreamType {
    Error = "Error",
    Information = "Information",
    Output = "Output",
    Warning = "Warning"
}

// @public
export enum KnownScriptPackageProvisioningState {
    Canceled = "Canceled",
    Failed = "Failed",
    Succeeded = "Succeeded"
}

// @public
export enum KnownScriptParameterTypes {
    Bool = "Bool",
    Credential = "Credential",
    Float = "Float",
    Int = "Int",
    SecureString = "SecureString",
    String = "String"
}

// @public
export enum KnownSegmentStatusEnum {
    Failure = "FAILURE",
    Success = "SUCCESS"
}

// @public
export enum KnownSslEnum {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownTrialStatus {
    TrialAvailable = "TrialAvailable",
    TrialDisabled = "TrialDisabled",
    TrialUsed = "TrialUsed"
}

// @public
export enum KnownVcfLicenseKind {
    Vcf5 = "vcf5"
}

// @public
export enum KnownVersions {
    V20230901 = "2023-09-01",
    V20240901 = "2024-09-01",
    V20250901 = "2025-09-01"
}

// @public
export enum KnownVirtualMachineProvisioningState {
    Canceled = "Canceled",
    Failed = "Failed",
    Succeeded = "Succeeded"
}

// @public
export enum KnownVirtualMachineRestrictMovementState {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownVisibilityParameterEnum {
    Hidden = "Hidden",
    Visible = "Visible"
}

// @public
export enum KnownVMGroupStatusEnum {
    Failure = "FAILURE",
    Success = "SUCCESS"
}

// @public
export enum KnownVMTypeEnum {
    Edge = "EDGE",
    Regular = "REGULAR",
    Service = "SERVICE"
}

// @public
export enum KnownWorkloadNetworkDhcpProvisioningState {
    Building = "Building",
    Canceled = "Canceled",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownWorkloadNetworkDnsServiceProvisioningState {
    Building = "Building",
    Canceled = "Canceled",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownWorkloadNetworkDnsZoneProvisioningState {
    Building = "Building",
    Canceled = "Canceled",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownWorkloadNetworkPortMirroringProvisioningState {
    Building = "Building",
    Canceled = "Canceled",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownWorkloadNetworkProvisioningState {
    Building = "Building",
    Canceled = "Canceled",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownWorkloadNetworkPublicIPProvisioningState {
    Building = "Building",
    Canceled = "Canceled",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownWorkloadNetworkSegmentProvisioningState {
    Building = "Building",
    Canceled = "Canceled",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownWorkloadNetworkVMGroupProvisioningState {
    Building = "Building",
    Canceled = "Canceled",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export interface Label {
    key: string;
    value: string;
}

// @public
export interface License extends ProxyResource {
    properties?: LicensePropertiesUnion;
}

// @public
export type LicenseKind = string;

// @public
export type LicenseName = string;

// @public
export interface LicenseProperties {
    kind: LicenseKind;
    readonly provisioningState?: LicenseProvisioningState;
}

// @public
export type LicensePropertiesUnion = VmwareFirewallLicenseProperties | LicenseProperties;

// @public
export type LicenseProvisioningState = string;

// @public
export interface Maintenance extends ProxyResource {
    properties?: MaintenanceProperties;
}

// @public
export type MaintenanceCheckType = string;

// @public
export interface MaintenanceFailedCheck {
    readonly impactedResources?: ImpactedMaintenanceResource[];
    readonly name?: string;
}

// @public
export interface MaintenanceManagementOperation {
    readonly kind: MaintenanceManagementOperationKind;
}

// @public
export type MaintenanceManagementOperationKind = string;

// @public
export type MaintenanceManagementOperationUnion = ScheduleOperation | RescheduleOperation | MaintenanceReadinessRefreshOperation | MaintenanceManagementOperation;

// @public
export interface MaintenanceProperties {
    readonly clusterId?: number;
    readonly component?: MaintenanceType;
    readonly displayName?: string;
    readonly estimatedDurationInMinutes?: number;
    readonly impact?: string;
    readonly infoLink?: string;
    readonly maintenanceReadiness?: MaintenanceReadiness;
    readonly operations?: MaintenanceManagementOperationUnion[];
    readonly provisioningState?: MaintenanceProvisioningState;
    readonly scheduledByMicrosoft?: boolean;
    readonly scheduledStartTime?: Date;
    readonly state?: MaintenanceState;
}

// @public
export type MaintenanceProvisioningState = string;

// @public
export interface MaintenanceReadiness {
    readonly failedChecks?: MaintenanceFailedCheck[];
    readonly lastUpdated?: Date;
    readonly message?: string;
    readonly status: MaintenanceReadinessStatus;
    readonly type: MaintenanceCheckType;
}

// @public
export interface MaintenanceReadinessRefreshOperation extends MaintenanceManagementOperation {
    readonly disabledReason?: string;
    readonly isDisabled?: boolean;
    kind: "MaintenanceReadinessRefresh";
    readonly message?: string;
    readonly refreshedByMicrosoft?: boolean;
    readonly status?: MaintenanceReadinessRefreshOperationStatus;
}

// @public
export type MaintenanceReadinessRefreshOperationStatus = string;

// @public
export type MaintenanceReadinessStatus = string;

// @public
export interface MaintenanceReschedule {
    message?: string;
    rescheduleTime?: Date;
}

// @public
export interface MaintenanceSchedule {
    message?: string;
    scheduleTime?: Date;
}

// @public
export interface MaintenanceState {
    endedAt?: Date;
    message?: string;
    name?: MaintenanceStateName;
    startedAt?: Date;
}

// @public
export type MaintenanceStateName = string;

// @public
export type MaintenanceStatusFilter = string;

// @public
export type MaintenanceType = string;

// @public
export interface ManagementCluster {
    readonly clusterId?: number;
    clusterSize?: number;
    hosts?: string[];
    readonly provisioningState?: ClusterProvisioningState;
    vsanDatastoreName?: string;
}

// @public
export type MountOptionEnum = string;

// @public
export interface NetAppVolume {
    id: string;
}

// @public
export type NsxPublicIpQuotaRaisedEnum = string;

// @public
export interface Operation {
    readonly actionType?: ActionType;
    display?: OperationDisplay;
    readonly isDataAction?: boolean;
    readonly name?: string;
    readonly origin?: Origin;
}

// @public
export interface OperationDisplay {
    readonly description?: string;
    readonly operation?: string;
    readonly provider?: string;
    readonly resource?: string;
}

// @public
export type OptionalParamEnum = string;

// @public
export type Origin = string;

// @public
export interface PlacementPolicy extends ProxyResource {
    properties?: PlacementPolicyPropertiesUnion;
}

// @public
export interface PlacementPolicyProperties {
    displayName?: string;
    readonly provisioningState?: PlacementPolicyProvisioningState;
    state?: PlacementPolicyState;
    type: PlacementPolicyType;
}

// @public
export type PlacementPolicyPropertiesUnion = VmPlacementPolicyProperties | VmHostPlacementPolicyProperties | PlacementPolicyProperties;

// @public
export type PlacementPolicyProvisioningState = string;

// @public
export type PlacementPolicyState = string;

// @public
export type PlacementPolicyType = string;

// @public
export interface PlacementPolicyUpdate {
    properties?: PlacementPolicyUpdateProperties;
}

// @public
export interface PlacementPolicyUpdateProperties {
    affinityStrength?: AffinityStrength;
    azureHybridBenefitType?: AzureHybridBenefitType;
    hostMembers?: string[];
    state?: PlacementPolicyState;
    vmMembers?: string[];
}

// @public
export type PortMirroringDirectionEnum = string;

// @public
export type PortMirroringStatusEnum = string;

// @public
export interface PrivateCloud extends TrackedResource {
    identity?: PrivateCloudIdentity;
    properties?: PrivateCloudProperties;
    sku: Sku;
    zones?: string[];
}

// @public
export interface PrivateCloudIdentity {
    readonly principalId?: string;
    readonly tenantId?: string;
    type: ResourceIdentityType;
}

// @public
export interface PrivateCloudProperties {
    availability?: AvailabilityProperties;
    circuit?: Circuit;
    dnsZoneType?: DnsZoneType;
    encryption?: Encryption;
    readonly endpoints?: Endpoints;
    extendedNetworkBlocks?: string[];
    readonly externalCloudLinks?: string[];
    identitySources?: IdentitySource[];
    internet?: InternetEnum;
    managementCluster: ManagementCluster;
    readonly managementNetwork?: string;
    networkBlock: string;
    readonly nsxPublicIpQuotaRaised?: NsxPublicIpQuotaRaisedEnum;
    readonly nsxtCertificateThumbprint?: string;
    nsxtPassword?: string;
    readonly provisioningNetwork?: string;
    readonly provisioningState?: PrivateCloudProvisioningState;
    secondaryCircuit?: Circuit;
    readonly vcenterCertificateThumbprint?: string;
    vcenterPassword?: string;
    vcfLicense?: VcfLicenseUnion;
    virtualNetworkId?: string;
    readonly vmotionNetwork?: string;
}

// @public
export type PrivateCloudProvisioningState = string;

// @public
export interface PrivateCloudUpdate {
    identity?: PrivateCloudIdentity;
    properties?: PrivateCloudUpdateProperties;
    sku?: Sku;
    tags?: Record<string, string>;
}

// @public
export interface PrivateCloudUpdateProperties {
    availability?: AvailabilityProperties;
    dnsZoneType?: DnsZoneType;
    encryption?: Encryption;
    extendedNetworkBlocks?: string[];
    identitySources?: IdentitySource[];
    internet?: InternetEnum;
    managementCluster?: ManagementCluster;
}

// @public
export interface ProvisionedNetwork extends ProxyResource {
    properties?: ProvisionedNetworkProperties;
}

// @public
export interface ProvisionedNetworkProperties {
    readonly addressPrefix?: string;
    readonly networkType?: ProvisionedNetworkTypes;
    readonly provisioningState?: ProvisionedNetworkProvisioningState;
}

// @public
export type ProvisionedNetworkProvisioningState = string;

// @public
export type ProvisionedNetworkTypes = string;

// @public
export interface ProxyResource extends Resource {
}

// @public
export interface PSCredentialExecutionParameter extends ScriptExecutionParameter {
    password?: string;
    type: "Credential";
    username?: string;
}

// @public
export interface PureStoragePolicy extends ProxyResource {
    properties?: PureStoragePolicyProperties;
}

// @public
export interface PureStoragePolicyProperties {
    readonly provisioningState?: PureStoragePolicyProvisioningState;
    storagePolicyDefinition: string;
    storagePoolId: string;
}

// @public
export type PureStoragePolicyProvisioningState = string;

// @public
export interface PureStorageVolume {
    sizeGb: number;
    storagePoolId: string;
}

// @public
export interface Quota {
    readonly hostsRemaining?: Record<string, number>;
    readonly quotaEnabled?: QuotaEnabled;
}

// @public
export type QuotaEnabled = string;

// @public
export interface RescheduleOperation extends MaintenanceManagementOperation {
    readonly constraints?: RescheduleOperationConstraintUnion[];
    readonly disabledReason?: string;
    readonly isDisabled?: boolean;
    kind: "Reschedule";
}

// @public
export interface RescheduleOperationConstraint {
    readonly kind: RescheduleOperationConstraintKind;
}

// @public
export type RescheduleOperationConstraintKind = string;

// @public
export type RescheduleOperationConstraintUnion = AvailableWindowForMaintenanceWhileRescheduleOperation | BlockedWhileRescheduleOperation | RescheduleOperationConstraint;

// @public
export interface Resource {
    readonly id?: string;
    readonly name?: string;
    readonly systemData?: SystemData;
    readonly type?: string;
}

// @public
export type ResourceIdentityType = string;

// @public
export interface ResourceSku {
    capabilities?: ResourceSkuCapabilities[];
    family?: string;
    locationInfo: ResourceSkuLocationInfo[];
    locations: string[];
    name: string;
    resourceType: ResourceSkuResourceType;
    restrictions: ResourceSkuRestrictions[];
    size?: string;
    tier?: string;
}

// @public
export interface ResourceSkuCapabilities {
    name: string;
    value: string;
}

// @public
export interface ResourceSkuLocationInfo {
    location: string;
    zoneDetails: ResourceSkuZoneDetails[];
    zones: string[];
}

// @public
export type ResourceSkuResourceType = string;

// @public
export interface ResourceSkuRestrictionInfo {
    locations?: string[];
    zones?: string[];
}

// @public
export interface ResourceSkuRestrictions {
    reasonCode?: ResourceSkuRestrictionsReasonCode;
    restrictionInfo: ResourceSkuRestrictionInfo;
    type?: ResourceSkuRestrictionsType;
    values: string[];
}

// @public
export type ResourceSkuRestrictionsReasonCode = string;

// @public
export type ResourceSkuRestrictionsType = string;

// @public
export interface ResourceSkuZoneDetails {
    capabilities: ResourceSkuCapabilities[];
    name: string[];
}

// @public
export interface ScheduleOperation extends MaintenanceManagementOperation {
    readonly constraints?: ScheduleOperationConstraintUnion[];
    readonly disabledReason?: string;
    readonly isDisabled?: boolean;
    kind: "Schedule";
}

// @public
export interface ScheduleOperationConstraint {
    readonly kind: ScheduleOperationConstraintKind;
}

// @public
export type ScheduleOperationConstraintKind = string;

// @public
export type ScheduleOperationConstraintUnion = SchedulingWindow | AvailableWindowForMaintenanceWhileScheduleOperation | BlockedWhileScheduleOperation | ScheduleOperationConstraint;

// @public
export interface SchedulingWindow extends ScheduleOperationConstraint {
    readonly endsAt: Date;
    kind: "SchedulingWindow";
    readonly startsAt: Date;
}

// @public
export interface ScriptCmdlet extends ProxyResource {
    properties?: ScriptCmdletProperties;
}

// @public
export type ScriptCmdletAudience = string;

// @public
export interface ScriptCmdletProperties {
    readonly audience?: ScriptCmdletAudience;
    readonly description?: string;
    readonly parameters?: ScriptParameter[];
    readonly provisioningState?: ScriptCmdletProvisioningState;
    readonly timeout?: string;
}

// @public
export type ScriptCmdletProvisioningState = string;

// @public
export interface ScriptExecution extends ProxyResource {
    properties?: ScriptExecutionProperties;
}

// @public
export interface ScriptExecutionParameter {
    name: string;
    type: ScriptExecutionParameterType;
}

// @public
export type ScriptExecutionParameterType = string;

// @public
export type ScriptExecutionParameterUnion = ScriptSecureStringExecutionParameter | ScriptStringExecutionParameter | PSCredentialExecutionParameter | ScriptExecutionParameter;

// @public
export interface ScriptExecutionProperties {
    readonly errors?: string[];
    failureReason?: string;
    readonly finishedAt?: Date;
    hiddenParameters?: ScriptExecutionParameterUnion[];
    readonly information?: string[];
    namedOutputs?: Record<string, Record<string, any>>;
    output?: string[];
    parameters?: ScriptExecutionParameterUnion[];
    readonly provisioningState?: ScriptExecutionProvisioningState;
    retention?: string;
    scriptCmdletId?: string;
    readonly startedAt?: Date;
    readonly submittedAt?: Date;
    timeout: string;
    readonly warnings?: string[];
}

// @public
export type ScriptExecutionProvisioningState = string;

// @public
export type ScriptOutputStreamType = string;

// @public
export interface ScriptPackage extends ProxyResource {
    properties?: ScriptPackageProperties;
}

// @public
export interface ScriptPackageProperties {
    readonly company?: string;
    readonly description?: string;
    readonly provisioningState?: ScriptPackageProvisioningState;
    readonly uri?: string;
    readonly version?: string;
}

// @public
export type ScriptPackageProvisioningState = string;

// @public
export interface ScriptParameter {
    readonly description?: string;
    name?: string;
    readonly optional?: OptionalParamEnum;
    readonly type?: ScriptParameterTypes;
    readonly visibility?: VisibilityParameterEnum;
}

// @public
export type ScriptParameterTypes = string;

// @public
export interface ScriptSecureStringExecutionParameter extends ScriptExecutionParameter {
    secureValue?: string;
    type: "SecureValue";
}

// @public
export interface ScriptStringExecutionParameter extends ScriptExecutionParameter {
    type: "Value";
    value?: string;
}

// @public
export type SegmentStatusEnum = string;

// @public
export interface Sku {
    capacity?: number;
    family?: string;
    name: string;
    size?: string;
    tier?: SkuTier;
}

// @public
export type SkuTier = "Free" | "Basic" | "Standard" | "Premium";

// @public
export interface SpecializedHostProperties extends HostProperties {
    kind: "Specialized";
}

// @public
export type SslEnum = string;

// @public
export interface SystemData {
    createdAt?: Date;
    createdBy?: string;
    createdByType?: CreatedByType;
    lastModifiedAt?: Date;
    lastModifiedBy?: string;
    lastModifiedByType?: CreatedByType;
}

// @public
export interface TrackedResource extends Resource {
    location: string;
    tags?: Record<string, string>;
}

// @public
export interface Trial {
    readonly availableHosts?: number;
    readonly status?: TrialStatus;
}

// @public
export type TrialStatus = string;

// @public
export interface Vcf5License extends VcfLicense {
    broadcomContractNumber?: string;
    broadcomSiteId?: string;
    cores: number;
    endDate: Date;
    kind: "vcf5";
    labels?: Label[];
    licenseKey?: string;
}

// @public
export interface VcfLicense {
    kind: VcfLicenseKind;
    readonly provisioningState?: LicenseProvisioningState;
}

// @public
export type VcfLicenseKind = string;

// @public
export type VcfLicenseUnion = Vcf5License | VcfLicense;

// @public
export interface VirtualMachine extends ProxyResource {
    properties?: VirtualMachineProperties;
}

// @public
export interface VirtualMachineProperties {
    readonly displayName?: string;
    readonly folderPath?: string;
    readonly moRefId?: string;
    readonly provisioningState?: VirtualMachineProvisioningState;
    readonly restrictMovement?: VirtualMachineRestrictMovementState;
}

// @public
export type VirtualMachineProvisioningState = string;

// @public
export interface VirtualMachineRestrictMovement {
    restrictMovement?: VirtualMachineRestrictMovementState;
}

// @public
export type VirtualMachineRestrictMovementState = string;

// @public
export type VisibilityParameterEnum = string;

// @public
export type VMGroupStatusEnum = string;

// @public
export interface VmHostPlacementPolicyProperties extends PlacementPolicyProperties {
    affinityStrength?: AffinityStrength;
    affinityType: AffinityType;
    azureHybridBenefitType?: AzureHybridBenefitType;
    hostMembers: string[];
    type: "VmHost";
    vmMembers: string[];
}

// @public
export interface VmPlacementPolicyProperties extends PlacementPolicyProperties {
    affinityType: AffinityType;
    type: "VmVm";
    vmMembers: string[];
}

// @public
export type VMTypeEnum = string;

// @public
export interface VmwareFirewallLicenseProperties extends LicenseProperties {
    broadcomContractNumber?: string;
    broadcomSiteId?: string;
    cores: number;
    endDate: Date;
    kind: "VmwareFirewall";
    labels?: Label[];
    licenseKey?: string;
}

// @public
export interface WorkloadNetwork extends ProxyResource {
    properties?: WorkloadNetworkProperties;
}

// @public
export interface WorkloadNetworkDhcp extends ProxyResource {
    properties?: WorkloadNetworkDhcpEntityUnion;
}

// @public
export interface WorkloadNetworkDhcpEntity {
    dhcpType: DhcpTypeEnum;
    displayName?: string;
    readonly provisioningState?: WorkloadNetworkDhcpProvisioningState;
    revision?: number;
    readonly segments?: string[];
}

// @public
export type WorkloadNetworkDhcpEntityUnion = WorkloadNetworkDhcpServer | WorkloadNetworkDhcpRelay | WorkloadNetworkDhcpEntity;

// @public
export type WorkloadNetworkDhcpProvisioningState = string;

// @public
export interface WorkloadNetworkDhcpRelay extends WorkloadNetworkDhcpEntity {
    dhcpType: "RELAY";
    serverAddresses?: string[];
}

// @public
export interface WorkloadNetworkDhcpServer extends WorkloadNetworkDhcpEntity {
    dhcpType: "SERVER";
    leaseTime?: number;
    serverAddress?: string;
}

// @public
export interface WorkloadNetworkDnsService extends ProxyResource {
    properties?: WorkloadNetworkDnsServiceProperties;
}

// @public
export interface WorkloadNetworkDnsServiceProperties {
    defaultDnsZone?: string;
    displayName?: string;
    dnsServiceIp?: string;
    fqdnZones?: string[];
    logLevel?: DnsServiceLogLevelEnum;
    readonly provisioningState?: WorkloadNetworkDnsServiceProvisioningState;
    revision?: number;
    readonly status?: DnsServiceStatusEnum;
}

// @public
export type WorkloadNetworkDnsServiceProvisioningState = string;

// @public
export interface WorkloadNetworkDnsZone extends ProxyResource {
    properties?: WorkloadNetworkDnsZoneProperties;
}

// @public
export interface WorkloadNetworkDnsZoneProperties {
    displayName?: string;
    dnsServerIps?: string[];
    dnsServices?: number;
    domain?: string[];
    readonly provisioningState?: WorkloadNetworkDnsZoneProvisioningState;
    revision?: number;
    sourceIp?: string;
}

// @public
export type WorkloadNetworkDnsZoneProvisioningState = string;

// @public
export interface WorkloadNetworkGateway extends ProxyResource {
    properties?: WorkloadNetworkGatewayProperties;
}

// @public
export interface WorkloadNetworkGatewayProperties {
    displayName?: string;
    readonly path?: string;
    readonly provisioningState?: WorkloadNetworkProvisioningState;
}

// @public
export interface WorkloadNetworkPortMirroring extends ProxyResource {
    properties?: WorkloadNetworkPortMirroringProperties;
}

// @public
export interface WorkloadNetworkPortMirroringProperties {
    destination?: string;
    direction?: PortMirroringDirectionEnum;
    displayName?: string;
    readonly provisioningState?: WorkloadNetworkPortMirroringProvisioningState;
    revision?: number;
    source?: string;
    readonly status?: PortMirroringStatusEnum;
}

// @public
export type WorkloadNetworkPortMirroringProvisioningState = string;

// @public
export interface WorkloadNetworkProperties {
    readonly provisioningState?: WorkloadNetworkProvisioningState;
}

// @public
export type WorkloadNetworkProvisioningState = string;

// @public
export interface WorkloadNetworkPublicIP extends ProxyResource {
    properties?: WorkloadNetworkPublicIPProperties;
}

// @public
export interface WorkloadNetworkPublicIPProperties {
    displayName?: string;
    numberOfPublicIPs?: number;
    readonly provisioningState?: WorkloadNetworkPublicIPProvisioningState;
    readonly publicIPBlock?: string;
}

// @public
export type WorkloadNetworkPublicIPProvisioningState = string;

// @public
export interface WorkloadNetworkSegment extends ProxyResource {
    properties?: WorkloadNetworkSegmentProperties;
}

// @public
export interface WorkloadNetworkSegmentPortVif {
    portName?: string;
}

// @public
export interface WorkloadNetworkSegmentProperties {
    connectedGateway?: string;
    displayName?: string;
    readonly portVif?: WorkloadNetworkSegmentPortVif[];
    readonly provisioningState?: WorkloadNetworkSegmentProvisioningState;
    revision?: number;
    readonly status?: SegmentStatusEnum;
    subnet?: WorkloadNetworkSegmentSubnet;
}

// @public
export type WorkloadNetworkSegmentProvisioningState = string;

// @public
export interface WorkloadNetworkSegmentSubnet {
    dhcpRanges?: string[];
    gatewayAddress?: string;
}

// @public
export interface WorkloadNetworkVirtualMachine extends ProxyResource {
    properties?: WorkloadNetworkVirtualMachineProperties;
}

// @public
export interface WorkloadNetworkVirtualMachineProperties {
    displayName?: string;
    readonly provisioningState?: WorkloadNetworkProvisioningState;
    readonly vmType?: VMTypeEnum;
}

// @public
export interface WorkloadNetworkVMGroup extends ProxyResource {
    properties?: WorkloadNetworkVMGroupProperties;
}

// @public
export interface WorkloadNetworkVMGroupProperties {
    displayName?: string;
    members?: string[];
    readonly provisioningState?: WorkloadNetworkVMGroupProvisioningState;
    revision?: number;
    readonly status?: VMGroupStatusEnum;
}

// @public
export type WorkloadNetworkVMGroupProvisioningState = string;

// (No @packageDocumentation comment for this package)

```