@azure/arm-azurestackhci 4.0.0-beta.1 → 4.0.0-beta.2

package/review/arm-azurestackhci.api.md

@@ -10,9 +10,153 @@ import { OperationState } from '@azure/core-lro';
 import { PagedAsyncIterableIterator } from '@azure/core-paging';
 import { SimplePollerLike } from '@azure/core-lro';
 
+// @public
+export type AccessLevel = string;
+
 // @public
 export type ActionType = string;
 
+// @public
+export interface ArcConnectivityProperties {
+    enabled?: boolean;
+    serviceConfigurations?: ServiceConfiguration[];
+}
+
+// @public
+export type ArcExtensionState = string;
+
+// @public
+export interface ArcIdentityResponse {
+    // (undocumented)
+    arcApplicationClientId?: string;
+    // (undocumented)
+    arcApplicationObjectId?: string;
+    // (undocumented)
+    arcApplicationTenantId?: string;
+    // (undocumented)
+    arcServicePrincipalObjectId?: string;
+}
+
+// @public
+export interface ArcSetting extends ProxyResource {
+    readonly aggregateState?: ArcSettingAggregateState;
+    arcApplicationClientId?: string;
+    arcApplicationObjectId?: string;
+    arcApplicationTenantId?: string;
+    arcInstanceResourceGroup?: string;
+    arcServicePrincipalObjectId?: string;
+    connectivityProperties?: Record<string, unknown>;
+    readonly defaultExtensions?: DefaultExtensionDetails[];
+    readonly perNodeDetails?: PerNodeState[];
+    readonly provisioningState?: ProvisioningState;
+}
+
+// @public
+export type ArcSettingAggregateState = string;
+
+// @public
+export interface ArcSettingList {
+    readonly nextLink?: string;
+    readonly value?: ArcSetting[];
+}
+
+// @public
+export interface ArcSettings {
+    beginCreateIdentity(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ArcSettingsCreateIdentityOptionalParams): Promise<SimplePollerLike<OperationState<ArcSettingsCreateIdentityResponse>, ArcSettingsCreateIdentityResponse>>;
+    beginCreateIdentityAndWait(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ArcSettingsCreateIdentityOptionalParams): Promise<ArcSettingsCreateIdentityResponse>;
+    beginDelete(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ArcSettingsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
+    beginDeleteAndWait(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ArcSettingsDeleteOptionalParams): Promise<void>;
+    beginInitializeDisableProcess(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ArcSettingsInitializeDisableProcessOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
+    beginInitializeDisableProcessAndWait(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ArcSettingsInitializeDisableProcessOptionalParams): Promise<void>;
+    consentAndInstallDefaultExtensions(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ArcSettingsConsentAndInstallDefaultExtensionsOptionalParams): Promise<ArcSettingsConsentAndInstallDefaultExtensionsResponse>;
+    create(resourceGroupName: string, clusterName: string, arcSettingName: string, arcSetting: ArcSetting, options?: ArcSettingsCreateOptionalParams): Promise<ArcSettingsCreateResponse>;
+    generatePassword(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ArcSettingsGeneratePasswordOptionalParams): Promise<ArcSettingsGeneratePasswordResponse>;
+    get(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ArcSettingsGetOptionalParams): Promise<ArcSettingsGetResponse>;
+    listByCluster(resourceGroupName: string, clusterName: string, options?: ArcSettingsListByClusterOptionalParams): PagedAsyncIterableIterator<ArcSetting>;
+    update(resourceGroupName: string, clusterName: string, arcSettingName: string, arcSetting: ArcSettingsPatch, options?: ArcSettingsUpdateOptionalParams): Promise<ArcSettingsUpdateResponse>;
+}
+
+// @public
+export interface ArcSettingsConsentAndInstallDefaultExtensionsOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type ArcSettingsConsentAndInstallDefaultExtensionsResponse = ArcSetting;
+
+// @public
+export interface ArcSettingsCreateIdentityOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type ArcSettingsCreateIdentityResponse = ArcIdentityResponse;
+
+// @public
+export interface ArcSettingsCreateOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type ArcSettingsCreateResponse = ArcSetting;
+
+// @public
+export interface ArcSettingsDeleteOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export interface ArcSettingsGeneratePasswordOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type ArcSettingsGeneratePasswordResponse = PasswordCredential;
+
+// @public
+export interface ArcSettingsGetOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type ArcSettingsGetResponse = ArcSetting;
+
+// @public
+export interface ArcSettingsInitializeDisableProcessOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export interface ArcSettingsListByClusterNextOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type ArcSettingsListByClusterNextResponse = ArcSettingList;
+
+// @public
+export interface ArcSettingsListByClusterOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type ArcSettingsListByClusterResponse = ArcSettingList;
+
+// @public
+export interface ArcSettingsPatch {
+    connectivityProperties?: Record<string, unknown>;
+    tags?: {
+        [propertyName: string]: string;
+    };
+}
+
+// @public
+export interface ArcSettingsUpdateOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type ArcSettingsUpdateResponse = ArcSetting;
+
+// @public
+export type AvailabilityType = string;
+
 // @public (undocumented)
 export class AzureStackHCIClient extends coreClient.ServiceClient {
     // (undocumented)
@@ -22,29 +166,33 @@ export class AzureStackHCIClient extends coreClient.ServiceClient {
     // (undocumented)
     apiVersion: string;
     // (undocumented)
-    galleryImagesOperations: GalleryImagesOperations;
+    arcSettings: ArcSettings;
     // (undocumented)
-    guestAgentOperations: GuestAgentOperations;
+    clusters: Clusters;
     // (undocumented)
-    guestAgents: GuestAgents;
+    deploymentSettings: DeploymentSettings;
     // (undocumented)
-    hybridIdentityMetadataOperations: HybridIdentityMetadataOperations;
+    edgeDevices: EdgeDevices;
     // (undocumented)
-    logicalNetworksOperations: LogicalNetworksOperations;
+    extensions: Extensions;
     // (undocumented)
-    marketplaceGalleryImagesOperations: MarketplaceGalleryImagesOperations;
-    // (undocumented)
-    networkInterfacesOperations: NetworkInterfacesOperations;
+    offers: Offers;
     // (undocumented)
     operations: Operations;
     // (undocumented)
-    storageContainersOperations: StorageContainersOperations;
+    publishers: Publishers;
+    // (undocumented)
+    securitySettings: SecuritySettings;
+    // (undocumented)
+    skus: Skus;
     // (undocumented)
     subscriptionId?: string;
     // (undocumented)
-    virtualHardDisksOperations: VirtualHardDisksOperations;
+    updateRuns: UpdateRuns;
+    // (undocumented)
+    updates: Updates;
     // (undocumented)
-    virtualMachineInstances: VirtualMachineInstances;
+    updateSummariesOperations: UpdateSummariesOperations;
 }
 
 // @public
@@ -55,367 +203,633 @@ export interface AzureStackHCIClientOptionalParams extends coreClient.ServiceCli
 }
 
 // @public
-export type CloudInitDataSource = string;
+export interface Cluster extends TrackedResource {
+    aadApplicationObjectId?: string;
+    aadClientId?: string;
+    aadServicePrincipalObjectId?: string;
+    aadTenantId?: string;
+    readonly billingModel?: string;
+    readonly cloudId?: string;
+    cloudManagementEndpoint?: string;
+    readonly connectivityStatus?: ConnectivityStatus;
+    desiredProperties?: ClusterDesiredProperties;
+    readonly isolatedVmAttestationConfiguration?: IsolatedVmAttestationConfiguration;
+    readonly lastBillingTimestamp?: Date;
+    readonly lastSyncTimestamp?: Date;
+    logCollectionProperties?: LogCollectionProperties;
+    readonly principalId?: string;
+    readonly provisioningState?: ProvisioningState;
+    readonly registrationTimestamp?: Date;
+    remoteSupportProperties?: RemoteSupportProperties;
+    readonly reportedProperties?: ClusterReportedProperties;
+    readonly resourceProviderObjectId?: string;
+    readonly serviceEndpoint?: string;
+    softwareAssuranceProperties?: SoftwareAssuranceProperties;
+    readonly status?: Status;
+    readonly tenantId?: string;
+    readonly trialDaysRemaining?: number;
+    typeIdentityType?: ManagedServiceIdentityType;
+    userAssignedIdentities?: {
+        [propertyName: string]: UserAssignedIdentity;
+    };
+}
 
 // @public
-export type CreatedByType = string;
+export interface ClusterDesiredProperties {
+    diagnosticLevel?: DiagnosticLevel;
+    windowsServerSubscription?: WindowsServerSubscription;
+}
 
 // @public
-export type DiskFileFormat = string;
+export interface ClusterIdentityResponse {
+    // (undocumented)
+    aadApplicationObjectId?: string;
+    // (undocumented)
+    aadClientId?: string;
+    // (undocumented)
+    aadServicePrincipalObjectId?: string;
+    // (undocumented)
+    aadTenantId?: string;
+}
 
 // @public
-export interface ErrorAdditionalInfo {
-    readonly info?: Record<string, unknown>;
-    readonly type?: string;
+export interface ClusterList {
+    readonly nextLink?: string;
+    value?: Cluster[];
 }
 
 // @public
-export interface ErrorDetail {
-    readonly additionalInfo?: ErrorAdditionalInfo[];
-    readonly code?: string;
-    readonly details?: ErrorDetail[];
-    readonly message?: string;
-    readonly target?: string;
+export interface ClusterNode {
+    readonly coreCount?: number;
+    readonly ehcResourceId?: string;
+    readonly id?: number;
+    readonly lastLicensingTimestamp?: Date;
+    readonly manufacturer?: string;
+    readonly memoryInGiB?: number;
+    readonly model?: string;
+    readonly name?: string;
+    readonly nodeType?: ClusterNodeType;
+    readonly oemActivation?: OemActivation;
+    readonly osDisplayVersion?: string;
+    readonly osName?: string;
+    readonly osVersion?: string;
+    readonly serialNumber?: string;
+    readonly windowsServerSubscription?: WindowsServerSubscription;
 }
 
 // @public
-export interface ErrorResponse {
-    error?: ErrorDetail;
-}
+export type ClusterNodeType = string;
 
 // @public
-export interface ExtendedLocation {
-    name?: string;
-    type?: ExtendedLocationTypes;
+export interface ClusterPatch {
+    aadClientId?: string;
+    aadTenantId?: string;
+    cloudManagementEndpoint?: string;
+    desiredProperties?: ClusterDesiredProperties;
+    readonly principalId?: string;
+    tags?: {
+        [propertyName: string]: string;
+    };
+    readonly tenantId?: string;
+    type?: ManagedServiceIdentityType;
+    userAssignedIdentities?: {
+        [propertyName: string]: UserAssignedIdentity;
+    };
 }
 
 // @public
-export type ExtendedLocationTypes = string;
+export interface ClusterReportedProperties {
+    readonly clusterId?: string;
+    readonly clusterName?: string;
+    readonly clusterType?: ClusterNodeType;
+    readonly clusterVersion?: string;
+    diagnosticLevel?: DiagnosticLevel;
+    readonly imdsAttestation?: ImdsAttestation;
+    readonly lastUpdated?: Date;
+    readonly manufacturer?: string;
+    readonly nodes?: ClusterNode[];
+    readonly oemActivation?: OemActivation;
+    readonly supportedCapabilities?: string[];
+}
 
 // @public
-export interface GalleryDiskImage {
-    readonly sizeInMB?: number;
+export interface Clusters {
+    beginConfigureRemoteSupport(resourceGroupName: string, clusterName: string, remoteSupportRequest: RemoteSupportRequest, options?: ClustersConfigureRemoteSupportOptionalParams): Promise<SimplePollerLike<OperationState<ClustersConfigureRemoteSupportResponse>, ClustersConfigureRemoteSupportResponse>>;
+    beginConfigureRemoteSupportAndWait(resourceGroupName: string, clusterName: string, remoteSupportRequest: RemoteSupportRequest, options?: ClustersConfigureRemoteSupportOptionalParams): Promise<ClustersConfigureRemoteSupportResponse>;
+    beginCreateIdentity(resourceGroupName: string, clusterName: string, options?: ClustersCreateIdentityOptionalParams): Promise<SimplePollerLike<OperationState<ClustersCreateIdentityResponse>, ClustersCreateIdentityResponse>>;
+    beginCreateIdentityAndWait(resourceGroupName: string, clusterName: string, options?: ClustersCreateIdentityOptionalParams): Promise<ClustersCreateIdentityResponse>;
+    beginDelete(resourceGroupName: string, clusterName: string, options?: ClustersDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
+    beginDeleteAndWait(resourceGroupName: string, clusterName: string, options?: ClustersDeleteOptionalParams): Promise<void>;
+    beginExtendSoftwareAssuranceBenefit(resourceGroupName: string, clusterName: string, softwareAssuranceChangeRequest: SoftwareAssuranceChangeRequest, options?: ClustersExtendSoftwareAssuranceBenefitOptionalParams): Promise<SimplePollerLike<OperationState<ClustersExtendSoftwareAssuranceBenefitResponse>, ClustersExtendSoftwareAssuranceBenefitResponse>>;
+    beginExtendSoftwareAssuranceBenefitAndWait(resourceGroupName: string, clusterName: string, softwareAssuranceChangeRequest: SoftwareAssuranceChangeRequest, options?: ClustersExtendSoftwareAssuranceBenefitOptionalParams): Promise<ClustersExtendSoftwareAssuranceBenefitResponse>;
+    beginTriggerLogCollection(resourceGroupName: string, clusterName: string, logCollectionRequest: LogCollectionRequest, options?: ClustersTriggerLogCollectionOptionalParams): Promise<SimplePollerLike<OperationState<ClustersTriggerLogCollectionResponse>, ClustersTriggerLogCollectionResponse>>;
+    beginTriggerLogCollectionAndWait(resourceGroupName: string, clusterName: string, logCollectionRequest: LogCollectionRequest, options?: ClustersTriggerLogCollectionOptionalParams): Promise<ClustersTriggerLogCollectionResponse>;
+    beginUploadCertificate(resourceGroupName: string, clusterName: string, uploadCertificateRequest: UploadCertificateRequest, options?: ClustersUploadCertificateOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
+    beginUploadCertificateAndWait(resourceGroupName: string, clusterName: string, uploadCertificateRequest: UploadCertificateRequest, options?: ClustersUploadCertificateOptionalParams): Promise<void>;
+    create(resourceGroupName: string, clusterName: string, cluster: Cluster, options?: ClustersCreateOptionalParams): Promise<ClustersCreateResponse>;
+    get(resourceGroupName: string, clusterName: string, options?: ClustersGetOptionalParams): Promise<ClustersGetResponse>;
+    listByResourceGroup(resourceGroupName: string, options?: ClustersListByResourceGroupOptionalParams): PagedAsyncIterableIterator<Cluster>;
+    listBySubscription(options?: ClustersListBySubscriptionOptionalParams): PagedAsyncIterableIterator<Cluster>;
+    update(resourceGroupName: string, clusterName: string, cluster: ClusterPatch, options?: ClustersUpdateOptionalParams): Promise<ClustersUpdateResponse>;
 }
 
 // @public
-export interface GalleryImageIdentifier {
-    offer: string;
-    publisher: string;
-    sku: string;
+export interface ClustersConfigureRemoteSupportHeaders {
+    // (undocumented)
+    location?: string;
 }
 
 // @public
-export interface GalleryImages extends TrackedResource {
-    cloudInitDataSource?: CloudInitDataSource;
-    containerId?: string;
-    extendedLocation?: ExtendedLocation;
-    hyperVGeneration?: HyperVGeneration;
-    identifier?: GalleryImageIdentifier;
-    imagePath?: string;
-    osType?: OperatingSystemTypes;
-    readonly provisioningState?: ProvisioningStateEnum;
-    readonly status?: GalleryImageStatus;
-    version?: GalleryImageVersion;
+export interface ClustersConfigureRemoteSupportOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
 }
 
 // @public
-export interface GalleryImagesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
+export type ClustersConfigureRemoteSupportResponse = Cluster;
+
+// @public
+export interface ClustersCreateIdentityOptionalParams extends coreClient.OperationOptions {
     resumeFrom?: string;
     updateIntervalInMs?: number;
 }
 
 // @public
-export type GalleryImagesCreateOrUpdateResponse = GalleryImages;
+export type ClustersCreateIdentityResponse = ClusterIdentityResponse;
 
 // @public
-export interface GalleryImagesDeleteHeaders {
-    // (undocumented)
-    location?: string;
+export interface ClustersCreateOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface GalleryImagesDeleteOptionalParams extends coreClient.OperationOptions {
+export type ClustersCreateResponse = Cluster;
+
+// @public
+export interface ClustersDeleteOptionalParams extends coreClient.OperationOptions {
     resumeFrom?: string;
     updateIntervalInMs?: number;
 }
 
 // @public
-export type GalleryImagesDeleteResponse = GalleryImagesDeleteHeaders;
+export interface ClustersExtendSoftwareAssuranceBenefitOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
 
 // @public
-export interface GalleryImagesGetOptionalParams extends coreClient.OperationOptions {
+export type ClustersExtendSoftwareAssuranceBenefitResponse = Cluster;
+
+// @public
+export interface ClustersGetOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type GalleryImagesGetResponse = GalleryImages;
+export type ClustersGetResponse = Cluster;
 
 // @public
-export interface GalleryImagesListAllNextOptionalParams extends coreClient.OperationOptions {
+export interface ClustersListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type GalleryImagesListAllNextResponse = GalleryImagesListResult;
+export type ClustersListByResourceGroupNextResponse = ClusterList;
 
 // @public
-export interface GalleryImagesListAllOptionalParams extends coreClient.OperationOptions {
+export interface ClustersListByResourceGroupOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type GalleryImagesListAllResponse = GalleryImagesListResult;
+export type ClustersListByResourceGroupResponse = ClusterList;
 
 // @public
-export interface GalleryImagesListNextOptionalParams extends coreClient.OperationOptions {
+export interface ClustersListBySubscriptionNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type GalleryImagesListNextResponse = GalleryImagesListResult;
+export type ClustersListBySubscriptionNextResponse = ClusterList;
 
 // @public
-export interface GalleryImagesListOptionalParams extends coreClient.OperationOptions {
+export interface ClustersListBySubscriptionOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type GalleryImagesListResponse = GalleryImagesListResult;
+export type ClustersListBySubscriptionResponse = ClusterList;
 
 // @public
-export interface GalleryImagesListResult {
-    readonly nextLink?: string;
+export interface ClustersTriggerLogCollectionHeaders {
     // (undocumented)
-    value?: GalleryImages[];
+    location?: string;
 }
 
 // @public
-export interface GalleryImagesOperations {
-    beginCreateOrUpdate(resourceGroupName: string, galleryImageName: string, galleryImages: GalleryImages, options?: GalleryImagesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<GalleryImagesCreateOrUpdateResponse>, GalleryImagesCreateOrUpdateResponse>>;
-    beginCreateOrUpdateAndWait(resourceGroupName: string, galleryImageName: string, galleryImages: GalleryImages, options?: GalleryImagesCreateOrUpdateOptionalParams): Promise<GalleryImagesCreateOrUpdateResponse>;
-    beginDelete(resourceGroupName: string, galleryImageName: string, options?: GalleryImagesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<GalleryImagesDeleteResponse>, GalleryImagesDeleteResponse>>;
-    beginDeleteAndWait(resourceGroupName: string, galleryImageName: string, options?: GalleryImagesDeleteOptionalParams): Promise<GalleryImagesDeleteResponse>;
-    beginUpdate(resourceGroupName: string, galleryImageName: string, galleryImages: GalleryImagesUpdateRequest, options?: GalleryImagesUpdateOptionalParams): Promise<SimplePollerLike<OperationState<GalleryImagesUpdateResponse>, GalleryImagesUpdateResponse>>;
-    beginUpdateAndWait(resourceGroupName: string, galleryImageName: string, galleryImages: GalleryImagesUpdateRequest, options?: GalleryImagesUpdateOptionalParams): Promise<GalleryImagesUpdateResponse>;
-    get(resourceGroupName: string, galleryImageName: string, options?: GalleryImagesGetOptionalParams): Promise<GalleryImagesGetResponse>;
-    list(resourceGroupName: string, options?: GalleryImagesListOptionalParams): PagedAsyncIterableIterator<GalleryImages>;
-    listAll(options?: GalleryImagesListAllOptionalParams): PagedAsyncIterableIterator<GalleryImages>;
+export interface ClustersTriggerLogCollectionOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
 }
 
 // @public
-export interface GalleryImageStatus {
-    downloadStatus?: GalleryImageStatusDownloadStatus;
-    errorCode?: string;
-    errorMessage?: string;
-    progressPercentage?: number;
-    // (undocumented)
-    provisioningStatus?: GalleryImageStatusProvisioningStatus;
+export type ClustersTriggerLogCollectionResponse = Cluster;
+
+// @public
+export interface ClustersUpdateOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface GalleryImageStatusDownloadStatus {
-    downloadSizeInMB?: number;
+export type ClustersUpdateResponse = Cluster;
+
+// @public
+export interface ClustersUploadCertificateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
 }
 
-// @public (undocumented)
-export interface GalleryImageStatusProvisioningStatus {
-    operationId?: string;
-    status?: Status;
+// @public
+export type ComplianceAssignmentType = string;
+
+// @public
+export type ComplianceStatus = string;
+
+// @public
+export type ConnectivityStatus = string;
+
+// @public
+export type CreatedByType = string;
+
+// @public
+export interface DefaultExtensionDetails {
+    readonly category?: string;
+    readonly consentTime?: Date;
 }
 
 // @public
-export interface GalleryImagesUpdateHeaders {
-    // (undocumented)
-    location?: string;
+export interface DeploymentCluster {
+    azureServiceEndpoint?: string;
+    cloudAccountName?: string;
+    name?: string;
+    witnessPath?: string;
+    witnessType?: string;
 }
 
 // @public
-export interface GalleryImagesUpdateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export interface DeploymentConfiguration {
+    scaleUnits: ScaleUnits[];
+    version?: string;
 }
 
 // @public
-export interface GalleryImagesUpdateRequest {
-    tags?: {
-        [propertyName: string]: string;
-    };
+export interface DeploymentData {
+    adouPath?: string;
+    cluster?: DeploymentCluster;
+    domainFqdn?: string;
+    hostNetwork?: DeploymentSettingHostNetwork;
+    infrastructureNetwork?: InfrastructureNetwork[];
+    namingPrefix?: string;
+    observability?: Observability;
+    optionalServices?: OptionalServices;
+    physicalNodes?: PhysicalNodes[];
+    sdnIntegration?: SdnIntegration;
+    secrets?: EceDeploymentSecrets[];
+    secretsLocation?: string;
+    securitySettings?: DeploymentSecuritySettings;
+    storage?: Storage_2;
 }
 
 // @public
-export type GalleryImagesUpdateResponse = GalleryImages;
+export type DeploymentMode = string;
 
 // @public
-export interface GalleryImageVersion {
-    name?: string;
-    storageProfile?: GalleryImageVersionStorageProfile;
+export interface DeploymentSecuritySettings {
+    bitlockerBootVolume?: boolean;
+    bitlockerDataVolumes?: boolean;
+    credentialGuardEnforced?: boolean;
+    driftControlEnforced?: boolean;
+    drtmProtection?: boolean;
+    hvciProtection?: boolean;
+    sideChannelMitigationEnforced?: boolean;
+    smbClusterEncryption?: boolean;
+    smbSigningEnforced?: boolean;
+    wdacEnforced?: boolean;
 }
 
 // @public
-export interface GalleryImageVersionStorageProfile {
-    osDiskImage?: GalleryOSDiskImage;
+export interface DeploymentSetting extends ProxyResource {
+    arcNodeResourceIds?: string[];
+    deploymentConfiguration?: DeploymentConfiguration;
+    deploymentMode?: DeploymentMode;
+    operationType?: OperationType;
+    readonly provisioningState?: ProvisioningState;
+    readonly reportedProperties?: EceReportedProperties;
 }
 
 // @public
-export interface GalleryOSDiskImage extends GalleryDiskImage {
+export interface DeploymentSettingAdapterPropertyOverrides {
+    jumboPacket?: string;
+    networkDirect?: string;
+    networkDirectTechnology?: string;
 }
 
 // @public
-export function getContinuationToken(page: unknown): string | undefined;
+export interface DeploymentSettingHostNetwork {
+    enableStorageAutoIp?: boolean;
+    intents?: DeploymentSettingIntents[];
+    storageConnectivitySwitchless?: boolean;
+    storageNetworks?: DeploymentSettingStorageNetworks[];
+}
 
 // @public
-export interface GuestAgent extends ProxyResource {
-    credentials?: GuestCredential;
-    provisioningAction?: ProvisioningAction;
-    readonly provisioningState?: string;
-    readonly status?: string;
+export interface DeploymentSettingIntents {
+    adapter?: string[];
+    adapterPropertyOverrides?: DeploymentSettingAdapterPropertyOverrides;
+    name?: string;
+    overrideAdapterProperty?: boolean;
+    overrideQosPolicy?: boolean;
+    overrideVirtualSwitchConfiguration?: boolean;
+    qosPolicyOverrides?: QosPolicyOverrides;
+    trafficType?: string[];
+    virtualSwitchConfigurationOverrides?: DeploymentSettingVirtualSwitchConfigurationOverrides;
 }
 
 // @public
-export interface GuestAgentCreateOptionalParams extends coreClient.OperationOptions {
-    body?: GuestAgent;
+export interface DeploymentSettingListResult {
+    nextLink?: string;
+    value: DeploymentSetting[];
+}
+
+// @public
+export interface DeploymentSettings {
+    beginCreateOrUpdate(resourceGroupName: string, clusterName: string, deploymentSettingsName: string, resource: DeploymentSetting, options?: DeploymentSettingsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<DeploymentSettingsCreateOrUpdateResponse>, DeploymentSettingsCreateOrUpdateResponse>>;
+    beginCreateOrUpdateAndWait(resourceGroupName: string, clusterName: string, deploymentSettingsName: string, resource: DeploymentSetting, options?: DeploymentSettingsCreateOrUpdateOptionalParams): Promise<DeploymentSettingsCreateOrUpdateResponse>;
+    beginDelete(resourceGroupName: string, clusterName: string, deploymentSettingsName: string, options?: DeploymentSettingsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<DeploymentSettingsDeleteResponse>, DeploymentSettingsDeleteResponse>>;
+    beginDeleteAndWait(resourceGroupName: string, clusterName: string, deploymentSettingsName: string, options?: DeploymentSettingsDeleteOptionalParams): Promise<DeploymentSettingsDeleteResponse>;
+    get(resourceGroupName: string, clusterName: string, deploymentSettingsName: string, options?: DeploymentSettingsGetOptionalParams): Promise<DeploymentSettingsGetResponse>;
+    listByClusters(resourceGroupName: string, clusterName: string, options?: DeploymentSettingsListByClustersOptionalParams): PagedAsyncIterableIterator<DeploymentSetting>;
+}
+
+// @public
+export interface DeploymentSettingsCreateOrUpdateHeaders {
+    retryAfter?: number;
+}
+
+// @public
+export interface DeploymentSettingsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
     resumeFrom?: string;
     updateIntervalInMs?: number;
 }
 
 // @public
-export type GuestAgentCreateResponse = GuestAgent;
+export type DeploymentSettingsCreateOrUpdateResponse = DeploymentSetting;
 
 // @public
-export interface GuestAgentDeleteHeaders {
-    // (undocumented)
+export interface DeploymentSettingsDeleteHeaders {
     location?: string;
+    retryAfter?: number;
 }
 
 // @public
-export interface GuestAgentDeleteOptionalParams extends coreClient.OperationOptions {
+export interface DeploymentSettingsDeleteOptionalParams extends coreClient.OperationOptions {
     resumeFrom?: string;
     updateIntervalInMs?: number;
 }
 
 // @public
-export type GuestAgentDeleteResponse = GuestAgentDeleteHeaders;
+export type DeploymentSettingsDeleteResponse = DeploymentSettingsDeleteHeaders;
 
 // @public
-export interface GuestAgentGetOptionalParams extends coreClient.OperationOptions {
+export interface DeploymentSettingsGetOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type GuestAgentGetResponse = GuestAgent;
+export type DeploymentSettingsGetResponse = DeploymentSetting;
 
 // @public
-export interface GuestAgentInstallStatus {
-    readonly agentVersion?: string;
-    readonly errorDetails?: ErrorDetail[];
-    readonly lastStatusChange?: Date;
-    readonly status?: StatusTypes;
-    readonly vmUuid?: string;
+export interface DeploymentSettingsListByClustersNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface GuestAgentList {
-    nextLink?: string;
-    value: GuestAgent[];
+export type DeploymentSettingsListByClustersNextResponse = DeploymentSettingListResult;
+
+// @public
+export interface DeploymentSettingsListByClustersOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface GuestAgentOperations {
-    beginCreate(resourceUri: string, options?: GuestAgentCreateOptionalParams): Promise<SimplePollerLike<OperationState<GuestAgentCreateResponse>, GuestAgentCreateResponse>>;
-    beginCreateAndWait(resourceUri: string, options?: GuestAgentCreateOptionalParams): Promise<GuestAgentCreateResponse>;
-    beginDelete(resourceUri: string, options?: GuestAgentDeleteOptionalParams): Promise<SimplePollerLike<OperationState<GuestAgentDeleteResponse>, GuestAgentDeleteResponse>>;
-    beginDeleteAndWait(resourceUri: string, options?: GuestAgentDeleteOptionalParams): Promise<GuestAgentDeleteResponse>;
-    get(resourceUri: string, options?: GuestAgentGetOptionalParams): Promise<GuestAgentGetResponse>;
+export type DeploymentSettingsListByClustersResponse = DeploymentSettingListResult;
+
+// @public
+export interface DeploymentSettingStorageAdapterIPInfo {
+    ipv4Address?: string;
+    physicalNode?: string;
+    subnetMask?: string;
 }
 
 // @public
-export interface GuestAgents {
-    list(resourceUri: string, options?: GuestAgentsListOptionalParams): PagedAsyncIterableIterator<GuestAgent>;
+export interface DeploymentSettingStorageNetworks {
+    name?: string;
+    networkAdapterName?: string;
+    storageAdapterIPInfo?: DeploymentSettingStorageAdapterIPInfo[];
+    vlanId?: string;
 }
 
 // @public
-export interface GuestAgentsListNextOptionalParams extends coreClient.OperationOptions {
+export interface DeploymentSettingVirtualSwitchConfigurationOverrides {
+    enableIov?: string;
+    loadBalancingAlgorithm?: string;
 }
 
 // @public
-export type GuestAgentsListNextResponse = GuestAgentList;
+export interface DeploymentStep {
+    readonly description?: string;
+    readonly endTimeUtc?: string;
+    readonly exception?: string[];
+    readonly fullStepIndex?: string;
+    readonly name?: string;
+    readonly startTimeUtc?: string;
+    readonly status?: string;
+    readonly steps?: DeploymentStep[];
+}
 
 // @public
-export interface GuestAgentsListOptionalParams extends coreClient.OperationOptions {
+export interface DeviceConfiguration {
+    deviceMetadata?: string;
+    nicDetails?: NicDetail[];
 }
 
 // @public
-export type GuestAgentsListResponse = GuestAgentList;
+export type DeviceKind = string;
+
+// @public
+export type DeviceState = string;
+
+// @public
+export type DiagnosticLevel = string;
 
 // @public
-export interface GuestCredential {
-    password?: string;
-    username?: string;
+export interface EceActionStatus {
+    readonly status?: string;
+    readonly steps?: DeploymentStep[];
 }
 
 // @public
-export interface HardwareProfileUpdate {
-    memoryMB?: number;
-    processors?: number;
-    // (undocumented)
-    vmSize?: VmSizeEnum;
+export interface EceDeploymentSecrets {
+    eceSecretName?: EceSecrets;
+    secretLocation?: string;
+    secretName?: string;
 }
 
 // @public
-export interface HttpProxyConfiguration {
-    httpProxy?: string;
-    httpsProxy?: string;
-    noProxy?: string[];
-    trustedCa?: string;
+export interface EceReportedProperties {
+    readonly deploymentStatus?: EceActionStatus;
+    readonly validationStatus?: EceActionStatus;
 }
 
 // @public
-export interface HybridIdentityMetadata extends ProxyResource {
-    readonly identity?: Identity;
-    readonly provisioningState?: string;
-    publicKey?: string;
-    resourceUid?: string;
+export type EceSecrets = string;
+
+// @public
+export interface EdgeDevice extends ProxyResource {
+    kind: DeviceKind;
 }
 
 // @public
-export interface HybridIdentityMetadataGetOptionalParams extends coreClient.OperationOptions {
+export interface EdgeDeviceListResult {
+    nextLink?: string;
+    value: EdgeDeviceUnion[];
 }
 
 // @public
-export type HybridIdentityMetadataGetResponse = HybridIdentityMetadata;
+export interface EdgeDeviceProperties {
+    deviceConfiguration?: DeviceConfiguration;
+    readonly provisioningState?: ProvisioningState;
+}
 
 // @public
-export interface HybridIdentityMetadataList {
-    nextLink?: string;
-    value: HybridIdentityMetadata[];
+export interface EdgeDevices {
+    beginCreateOrUpdate(resourceUri: string, edgeDeviceName: string, resource: EdgeDeviceUnion, options?: EdgeDevicesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<EdgeDevicesCreateOrUpdateResponse>, EdgeDevicesCreateOrUpdateResponse>>;
+    beginCreateOrUpdateAndWait(resourceUri: string, edgeDeviceName: string, resource: EdgeDeviceUnion, options?: EdgeDevicesCreateOrUpdateOptionalParams): Promise<EdgeDevicesCreateOrUpdateResponse>;
+    beginDelete(resourceUri: string, edgeDeviceName: string, options?: EdgeDevicesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<EdgeDevicesDeleteResponse>, EdgeDevicesDeleteResponse>>;
+    beginDeleteAndWait(resourceUri: string, edgeDeviceName: string, options?: EdgeDevicesDeleteOptionalParams): Promise<EdgeDevicesDeleteResponse>;
+    beginValidate(resourceUri: string, edgeDeviceName: string, validateRequest: ValidateRequest, options?: EdgeDevicesValidateOptionalParams): Promise<SimplePollerLike<OperationState<EdgeDevicesValidateResponse>, EdgeDevicesValidateResponse>>;
+    beginValidateAndWait(resourceUri: string, edgeDeviceName: string, validateRequest: ValidateRequest, options?: EdgeDevicesValidateOptionalParams): Promise<EdgeDevicesValidateResponse>;
+    get(resourceUri: string, edgeDeviceName: string, options?: EdgeDevicesGetOptionalParams): Promise<EdgeDevicesGetResponse>;
+    list(resourceUri: string, options?: EdgeDevicesListOptionalParams): PagedAsyncIterableIterator<EdgeDeviceUnion>;
+}
+
+// @public
+export interface EdgeDevicesCreateOrUpdateHeaders {
+    retryAfter?: number;
 }
 
 // @public
-export interface HybridIdentityMetadataListNextOptionalParams extends coreClient.OperationOptions {
+export interface EdgeDevicesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
 }
 
 // @public
-export type HybridIdentityMetadataListNextResponse = HybridIdentityMetadataList;
+export type EdgeDevicesCreateOrUpdateResponse = EdgeDeviceUnion;
 
 // @public
-export interface HybridIdentityMetadataListOptionalParams extends coreClient.OperationOptions {
+export interface EdgeDevicesDeleteHeaders {
+    location?: string;
+    retryAfter?: number;
 }
 
 // @public
-export type HybridIdentityMetadataListResponse = HybridIdentityMetadataList;
+export interface EdgeDevicesDeleteOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
 
 // @public
-export interface HybridIdentityMetadataOperations {
-    get(resourceUri: string, options?: HybridIdentityMetadataGetOptionalParams): Promise<HybridIdentityMetadataGetResponse>;
-    list(resourceUri: string, options?: HybridIdentityMetadataListOptionalParams): PagedAsyncIterableIterator<HybridIdentityMetadata>;
+export type EdgeDevicesDeleteResponse = EdgeDevicesDeleteHeaders;
+
+// @public
+export interface EdgeDevicesGetOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type HyperVGeneration = string;
+export type EdgeDevicesGetResponse = EdgeDeviceUnion;
 
 // @public
-export interface Identity {
-    readonly principalId?: string;
-    readonly tenantId?: string;
-    type?: "SystemAssigned";
+export interface EdgeDevicesListNextOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type EdgeDevicesListNextResponse = EdgeDeviceListResult;
+
+// @public
+export interface EdgeDevicesListOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type EdgeDevicesListResponse = EdgeDeviceListResult;
+
+// @public
+export interface EdgeDevicesValidateHeaders {
+    location?: string;
+    retryAfter?: number;
+}
+
+// @public
+export interface EdgeDevicesValidateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type EdgeDevicesValidateResponse = ValidateResponse;
+
+// @public (undocumented)
+export type EdgeDeviceUnion = EdgeDevice | HciEdgeDevice;
+
+// @public
+export interface ErrorAdditionalInfo {
+    readonly info?: Record<string, unknown>;
+    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 InstanceViewStatus {
+export interface ErrorResponse {
+    error?: ErrorDetail;
+}
+
+// @public
+export interface Extension extends ProxyResource {
+    readonly aggregateState?: ExtensionAggregateState;
+    autoUpgradeMinorVersion?: boolean;
+    enableAutomaticUpgrade?: boolean;
+    forceUpdateTag?: string;
+    readonly managedBy?: ExtensionManagedBy;
+    readonly perNodeExtensionDetails?: PerNodeExtensionState[];
+    protectedSettings?: Record<string, unknown>;
+    readonly provisioningState?: ProvisioningState;
+    publisher?: string;
+    settings?: Record<string, unknown>;
+    typeHandlerVersion?: string;
+    typePropertiesExtensionParametersType?: string;
+}
+
+// @public
+export type ExtensionAggregateState = string;
+
+// @public
+export interface ExtensionInstanceView {
+    name?: string;
+    status?: ExtensionInstanceViewStatus;
+    type?: string;
+    typeHandlerVersion?: string;
+}
+
+// @public
+export interface ExtensionInstanceViewStatus {
     code?: string;
     displayStatus?: string;
     level?: StatusLevelTypes;
@@ -423,589 +837,790 @@ export interface InstanceViewStatus {
     time?: Date;
 }
 
-// @public (undocumented)
-export interface InterfaceDNSSettings {
-    dnsServers?: string[];
+// @public
+export interface ExtensionList {
+    readonly nextLink?: string;
+    readonly value?: Extension[];
 }
 
 // @public
-export type IpAllocationMethodEnum = string;
+export type ExtensionManagedBy = string;
 
 // @public
-export interface IPConfiguration {
-    name?: string;
-    properties?: IPConfigurationProperties;
+export interface ExtensionPatch {
+    extensionParameters?: ExtensionPatchParameters;
 }
 
 // @public
-export interface IPConfigurationProperties {
-    readonly gateway?: string;
-    readonly prefixLength?: string;
-    privateIPAddress?: string;
-    subnet?: IPConfigurationPropertiesSubnet;
+export interface ExtensionPatchParameters {
+    enableAutomaticUpgrade?: boolean;
+    protectedSettings?: Record<string, unknown>;
+    settings?: Record<string, unknown>;
+    typeHandlerVersion?: string;
 }
 
 // @public
-export interface IPConfigurationPropertiesSubnet {
-    id?: string;
+export interface ExtensionProfile {
+    readonly extensions?: HciEdgeDeviceArcExtension[];
 }
 
-// @public (undocumented)
-export interface IPPool {
-    end?: string;
-    // (undocumented)
-    info?: IPPoolInfo;
-    ipPoolType?: IPPoolTypeEnum;
-    name?: string;
-    start?: string;
+// @public
+export interface Extensions {
+    beginCreate(resourceGroupName: string, clusterName: string, arcSettingName: string, extensionName: string, extension: Extension, options?: ExtensionsCreateOptionalParams): Promise<SimplePollerLike<OperationState<ExtensionsCreateResponse>, ExtensionsCreateResponse>>;
+    beginCreateAndWait(resourceGroupName: string, clusterName: string, arcSettingName: string, extensionName: string, extension: Extension, options?: ExtensionsCreateOptionalParams): Promise<ExtensionsCreateResponse>;
+    beginDelete(resourceGroupName: string, clusterName: string, arcSettingName: string, extensionName: string, options?: ExtensionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
+    beginDeleteAndWait(resourceGroupName: string, clusterName: string, arcSettingName: string, extensionName: string, options?: ExtensionsDeleteOptionalParams): Promise<void>;
+    beginUpdate(resourceGroupName: string, clusterName: string, arcSettingName: string, extensionName: string, extension: ExtensionPatch, options?: ExtensionsUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ExtensionsUpdateResponse>, ExtensionsUpdateResponse>>;
+    beginUpdateAndWait(resourceGroupName: string, clusterName: string, arcSettingName: string, extensionName: string, extension: ExtensionPatch, options?: ExtensionsUpdateOptionalParams): Promise<ExtensionsUpdateResponse>;
+    beginUpgrade(resourceGroupName: string, clusterName: string, arcSettingName: string, extensionName: string, extensionUpgradeParameters: ExtensionUpgradeParameters, options?: ExtensionsUpgradeOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
+    beginUpgradeAndWait(resourceGroupName: string, clusterName: string, arcSettingName: string, extensionName: string, extensionUpgradeParameters: ExtensionUpgradeParameters, options?: ExtensionsUpgradeOptionalParams): Promise<void>;
+    get(resourceGroupName: string, clusterName: string, arcSettingName: string, extensionName: string, options?: ExtensionsGetOptionalParams): Promise<ExtensionsGetResponse>;
+    listByArcSetting(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ExtensionsListByArcSettingOptionalParams): PagedAsyncIterableIterator<Extension>;
 }
 
-// @public (undocumented)
-export interface IPPoolInfo {
-    readonly available?: string;
-    readonly used?: string;
+// @public
+export interface ExtensionsCreateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
 }
 
 // @public
-export type IPPoolTypeEnum = "vm" | "vippool";
+export type ExtensionsCreateResponse = Extension;
 
 // @public
-export enum KnownActionType {
-    Internal = "Internal"
+export interface ExtensionsDeleteOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
 }
 
 // @public
-export enum KnownCloudInitDataSource {
-    Azure = "Azure",
-    NoCloud = "NoCloud"
+export interface ExtensionsGetOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export enum KnownCreatedByType {
-    Application = "Application",
-    Key = "Key",
-    ManagedIdentity = "ManagedIdentity",
-    User = "User"
+export type ExtensionsGetResponse = Extension;
+
+// @public
+export interface ExtensionsListByArcSettingNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export enum KnownDiskFileFormat {
-    Vhd = "vhd",
-    Vhdx = "vhdx"
+export type ExtensionsListByArcSettingNextResponse = ExtensionList;
+
+// @public
+export interface ExtensionsListByArcSettingOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export enum KnownExtendedLocationTypes {
-    CustomLocation = "CustomLocation"
+export type ExtensionsListByArcSettingResponse = ExtensionList;
+
+// @public
+export interface ExtensionsUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
 }
 
 // @public
-export enum KnownHyperVGeneration {
-    V1 = "V1",
-    V2 = "V2"
+export type ExtensionsUpdateResponse = Extension;
+
+// @public
+export interface ExtensionsUpgradeOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
 }
 
 // @public
-export enum KnownIpAllocationMethodEnum {
-    Dynamic = "Dynamic",
-    Static = "Static"
+export interface ExtensionUpgradeParameters {
+    targetVersion?: string;
 }
 
 // @public
-export enum KnownOrigin {
-    System = "system",
-    User = "user",
-    UserSystem = "user,system"
+export function getContinuationToken(page: unknown): string | undefined;
+
+// @public
+export interface HciEdgeDevice extends EdgeDevice {
+    kind: "HCI";
+    properties?: HciEdgeDeviceProperties;
 }
 
 // @public
-export enum KnownPowerStateEnum {
-    Deallocated = "Deallocated",
-    Deallocating = "Deallocating",
-    Running = "Running",
-    Starting = "Starting",
-    Stopped = "Stopped",
-    Stopping = "Stopping",
-    Unknown = "Unknown"
+export interface HciEdgeDeviceAdapterPropertyOverrides {
+    readonly jumboPacket?: string;
+    readonly networkDirect?: string;
+    readonly networkDirectTechnology?: string;
 }
 
 // @public
-export enum KnownProvisioningAction {
-    Install = "install",
-    Repair = "repair",
-    Uninstall = "uninstall"
+export interface HciEdgeDeviceArcExtension {
+    readonly errorDetails?: HciValidationFailureDetail[];
+    readonly extensionName?: string;
+    readonly extensionResourceId?: string;
+    readonly managedBy?: ExtensionManagedBy;
+    readonly state?: ArcExtensionState;
+    readonly typeHandlerVersion?: string;
 }
 
 // @public
-export enum KnownProvisioningStateEnum {
-    Accepted = "Accepted",
-    Canceled = "Canceled",
-    Deleting = "Deleting",
-    Failed = "Failed",
-    InProgress = "InProgress",
-    Succeeded = "Succeeded"
+export interface HciEdgeDeviceHostNetwork {
+    readonly enableStorageAutoIp?: boolean;
+    readonly intents?: HciEdgeDeviceIntents[];
+    readonly storageConnectivitySwitchless?: boolean;
+    readonly storageNetworks?: HciEdgeDeviceStorageNetworks[];
 }
 
 // @public
-export enum KnownSecurityTypes {
-    ConfidentialVM = "ConfidentialVM",
-    TrustedLaunch = "TrustedLaunch"
+export interface HciEdgeDeviceIntents {
+    readonly adapterPropertyOverrides?: HciEdgeDeviceAdapterPropertyOverrides;
+    readonly intentAdapters?: string[];
+    readonly intentName?: string;
+    readonly intentType?: number;
+    readonly isComputeIntentSet?: boolean;
+    readonly isManagementIntentSet?: boolean;
+    readonly isNetworkIntentType?: boolean;
+    readonly isOnlyStorage?: boolean;
+    readonly isOnlyStretch?: boolean;
+    readonly isStorageIntentSet?: boolean;
+    readonly isStretchIntentSet?: boolean;
+    readonly overrideAdapterProperty?: boolean;
+    readonly overrideQosPolicy?: boolean;
+    readonly overrideVirtualSwitchConfiguration?: boolean;
+    readonly qosPolicyOverrides?: QosPolicyOverrides;
+    readonly scope?: number;
+    readonly virtualSwitchConfigurationOverrides?: HciEdgeDeviceVirtualSwitchConfigurationOverrides;
 }
 
 // @public
-export enum KnownStatus {
-    Failed = "Failed",
-    InProgress = "InProgress",
-    Succeeded = "Succeeded"
+export interface HciEdgeDeviceProperties extends EdgeDeviceProperties {
+    readonly reportedProperties?: HciReportedProperties;
 }
 
 // @public
-export enum KnownStatusLevelTypes {
-    Error = "Error",
-    Info = "Info",
-    Warning = "Warning"
+export interface HciEdgeDeviceStorageAdapterIPInfo {
+    readonly ipv4Address?: string;
+    readonly physicalNode?: string;
+    readonly subnetMask?: string;
 }
 
 // @public
-export enum KnownStatusTypes {
-    Failed = "Failed",
-    InProgress = "InProgress",
-    Succeeded = "Succeeded"
+export interface HciEdgeDeviceStorageNetworks {
+    readonly name?: string;
+    readonly networkAdapterName?: string;
+    readonly storageAdapterIPInfo?: HciEdgeDeviceStorageAdapterIPInfo[];
+    readonly storageVlanId?: string;
 }
 
 // @public
-export enum KnownVmSizeEnum {
-    Custom = "Custom",
-    Default = "Default",
-    StandardA2V2 = "Standard_A2_v2",
-    StandardA4V2 = "Standard_A4_v2",
-    StandardD16SV3 = "Standard_D16s_v3",
-    StandardD2SV3 = "Standard_D2s_v3",
-    StandardD32SV3 = "Standard_D32s_v3",
-    StandardD4SV3 = "Standard_D4s_v3",
-    StandardD8SV3 = "Standard_D8s_v3",
-    StandardDS13V2 = "Standard_DS13_v2",
-    StandardDS2V2 = "Standard_DS2_v2",
-    StandardDS3V2 = "Standard_DS3_v2",
-    StandardDS4V2 = "Standard_DS4_v2",
-    StandardDS5V2 = "Standard_DS5_v2",
-    StandardK8S2V1 = "Standard_K8S2_v1",
-    StandardK8S3V1 = "Standard_K8S3_v1",
-    StandardK8S4V1 = "Standard_K8S4_v1",
-    StandardK8S5V1 = "Standard_K8S5_v1",
-    StandardK8SV1 = "Standard_K8S_v1",
-    StandardNK12 = "Standard_NK12",
-    StandardNK6 = "Standard_NK6",
-    StandardNV12 = "Standard_NV12",
-    StandardNV6 = "Standard_NV6"
-}
-
-// @public
-export interface LogicalNetworkPropertiesDhcpOptions {
-    dnsServers?: string[];
+export interface HciEdgeDeviceVirtualSwitchConfigurationOverrides {
+    readonly enableIov?: string;
+    readonly loadBalancingAlgorithm?: string;
 }
 
 // @public
-export interface LogicalNetworks extends TrackedResource {
-    dhcpOptions?: LogicalNetworkPropertiesDhcpOptions;
-    extendedLocation?: ExtendedLocation;
-    readonly provisioningState?: ProvisioningStateEnum;
-    readonly status?: LogicalNetworkStatus;
-    subnets?: Subnet[];
-    vmSwitchName?: string;
+export interface HciNetworkProfile {
+    readonly hostNetwork?: HciEdgeDeviceHostNetwork;
+    readonly nicDetails?: HciNicDetail[];
+    readonly switchDetails?: SwitchDetail[];
 }
 
 // @public
-export interface LogicalNetworksCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export interface HciNicDetail {
+    readonly adapterName?: string;
+    readonly componentId?: string;
+    readonly defaultGateway?: string;
+    readonly defaultIsolationId?: string;
+    readonly dnsServers?: string[];
+    readonly driverVersion?: string;
+    readonly interfaceDescription?: string;
+    readonly ip4Address?: string;
+    readonly macAddress?: string;
+    readonly nicStatus?: string;
+    readonly nicType?: string;
+    readonly slot?: string;
+    readonly subnetMask?: string;
+    readonly switchName?: string;
+    readonly vlanId?: string;
 }
 
 // @public
-export type LogicalNetworksCreateOrUpdateResponse = LogicalNetworks;
+export interface HciOsProfile {
+    readonly assemblyVersion?: string;
+    readonly bootType?: string;
+}
 
 // @public
-export interface LogicalNetworksDeleteHeaders {
-    // (undocumented)
-    location?: string;
+export interface HciReportedProperties extends ReportedProperties {
+    readonly networkProfile?: HciNetworkProfile;
+    readonly osProfile?: HciOsProfile;
+    readonly sbeDeploymentPackageInfo?: SbeDeploymentPackageInfo;
 }
 
 // @public
-export interface LogicalNetworksDeleteOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export interface HciValidationFailureDetail {
+    readonly exception?: string;
 }
 
 // @public
-export type LogicalNetworksDeleteResponse = LogicalNetworksDeleteHeaders;
+export type HealthState = string;
 
 // @public
-export interface LogicalNetworksGetOptionalParams extends coreClient.OperationOptions {
-}
+export type ImdsAttestation = string;
 
 // @public
-export type LogicalNetworksGetResponse = LogicalNetworks;
+export interface InfrastructureNetwork {
+    dnsServers?: string[];
+    gateway?: string;
+    ipPools?: IpPools[];
+    subnetMask?: string;
+    useDhcp?: boolean;
+}
 
 // @public
-export interface LogicalNetworksListAllNextOptionalParams extends coreClient.OperationOptions {
+export interface IpPools {
+    endingAddress?: string;
+    startingAddress?: string;
 }
 
 // @public
-export type LogicalNetworksListAllNextResponse = LogicalNetworksListResult;
+export interface IsolatedVmAttestationConfiguration {
+    readonly attestationResourceId?: string;
+    readonly attestationServiceEndpoint?: string;
+    readonly relyingPartyServiceEndpoint?: string;
+}
 
 // @public
-export interface LogicalNetworksListAllOptionalParams extends coreClient.OperationOptions {
+export enum KnownAccessLevel {
+    Diagnostics = "Diagnostics",
+    DiagnosticsAndRepair = "DiagnosticsAndRepair"
 }
 
 // @public
-export type LogicalNetworksListAllResponse = LogicalNetworksListResult;
+export enum KnownActionType {
+    Internal = "Internal"
+}
 
 // @public
-export interface LogicalNetworksListNextOptionalParams extends coreClient.OperationOptions {
+export enum KnownArcExtensionState {
+    Accepted = "Accepted",
+    Canceled = "Canceled",
+    Creating = "Creating",
+    Deleted = "Deleted",
+    Deleting = "Deleting",
+    Failed = "Failed",
+    Moving = "Moving",
+    NotSpecified = "NotSpecified",
+    Succeeded = "Succeeded",
+    Updating = "Updating"
 }
 
 // @public
-export type LogicalNetworksListNextResponse = LogicalNetworksListResult;
+export enum KnownArcSettingAggregateState {
+    Accepted = "Accepted",
+    Canceled = "Canceled",
+    Connected = "Connected",
+    Creating = "Creating",
+    Deleted = "Deleted",
+    Deleting = "Deleting",
+    DisableInProgress = "DisableInProgress",
+    Disconnected = "Disconnected",
+    Error = "Error",
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Moving = "Moving",
+    NotSpecified = "NotSpecified",
+    PartiallyConnected = "PartiallyConnected",
+    PartiallySucceeded = "PartiallySucceeded",
+    Provisioning = "Provisioning",
+    Succeeded = "Succeeded",
+    Updating = "Updating"
+}
 
 // @public
-export interface LogicalNetworksListOptionalParams extends coreClient.OperationOptions {
+export enum KnownAvailabilityType {
+    Local = "Local",
+    Notify = "Notify",
+    Online = "Online"
 }
 
 // @public
-export type LogicalNetworksListResponse = LogicalNetworksListResult;
+export enum KnownClusterNodeType {
+    FirstParty = "FirstParty",
+    ThirdParty = "ThirdParty"
+}
 
-// @public (undocumented)
-export interface LogicalNetworksListResult {
-    // (undocumented)
-    nextLink?: string;
-    // (undocumented)
-    value?: LogicalNetworks[];
+// @public
+export enum KnownComplianceAssignmentType {
+    ApplyAndAutoCorrect = "ApplyAndAutoCorrect",
+    Audit = "Audit"
 }
 
 // @public
-export interface LogicalNetworksOperations {
-    beginCreateOrUpdate(resourceGroupName: string, logicalNetworkName: string, logicalNetworks: LogicalNetworks, options?: LogicalNetworksCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<LogicalNetworksCreateOrUpdateResponse>, LogicalNetworksCreateOrUpdateResponse>>;
-    beginCreateOrUpdateAndWait(resourceGroupName: string, logicalNetworkName: string, logicalNetworks: LogicalNetworks, options?: LogicalNetworksCreateOrUpdateOptionalParams): Promise<LogicalNetworksCreateOrUpdateResponse>;
-    beginDelete(resourceGroupName: string, logicalNetworkName: string, options?: LogicalNetworksDeleteOptionalParams): Promise<SimplePollerLike<OperationState<LogicalNetworksDeleteResponse>, LogicalNetworksDeleteResponse>>;
-    beginDeleteAndWait(resourceGroupName: string, logicalNetworkName: string, options?: LogicalNetworksDeleteOptionalParams): Promise<LogicalNetworksDeleteResponse>;
-    beginUpdate(resourceGroupName: string, logicalNetworkName: string, logicalNetworks: LogicalNetworksUpdateRequest, options?: LogicalNetworksUpdateOptionalParams): Promise<SimplePollerLike<OperationState<LogicalNetworksUpdateResponse>, LogicalNetworksUpdateResponse>>;
-    beginUpdateAndWait(resourceGroupName: string, logicalNetworkName: string, logicalNetworks: LogicalNetworksUpdateRequest, options?: LogicalNetworksUpdateOptionalParams): Promise<LogicalNetworksUpdateResponse>;
-    // (undocumented)
-    get(resourceGroupName: string, logicalNetworkName: string, options?: LogicalNetworksGetOptionalParams): Promise<LogicalNetworksGetResponse>;
-    list(resourceGroupName: string, options?: LogicalNetworksListOptionalParams): PagedAsyncIterableIterator<LogicalNetworks>;
-    listAll(options?: LogicalNetworksListAllOptionalParams): PagedAsyncIterableIterator<LogicalNetworks>;
+export enum KnownComplianceStatus {
+    Compliant = "Compliant",
+    NonCompliant = "NonCompliant",
+    Pending = "Pending"
 }
 
 // @public
-export interface LogicalNetworkStatus {
-    errorCode?: string;
-    errorMessage?: string;
-    // (undocumented)
-    provisioningStatus?: LogicalNetworkStatusProvisioningStatus;
+export enum KnownConnectivityStatus {
+    Connected = "Connected",
+    Disconnected = "Disconnected",
+    NotConnectedRecently = "NotConnectedRecently",
+    NotSpecified = "NotSpecified",
+    NotYetRegistered = "NotYetRegistered",
+    PartiallyConnected = "PartiallyConnected"
 }
 
-// @public (undocumented)
-export interface LogicalNetworkStatusProvisioningStatus {
-    operationId?: string;
-    status?: Status;
+// @public
+export enum KnownCreatedByType {
+    Application = "Application",
+    Key = "Key",
+    ManagedIdentity = "ManagedIdentity",
+    User = "User"
 }
 
 // @public
-export interface LogicalNetworksUpdateHeaders {
-    // (undocumented)
-    location?: string;
+export enum KnownDeploymentMode {
+    Deploy = "Deploy",
+    Validate = "Validate"
 }
 
 // @public
-export interface LogicalNetworksUpdateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export enum KnownDeviceKind {
+    HCI = "HCI"
 }
 
 // @public
-export interface LogicalNetworksUpdateRequest {
-    tags?: {
-        [propertyName: string]: string;
-    };
+export enum KnownDeviceState {
+    Connected = "Connected",
+    Disconnected = "Disconnected",
+    Draining = "Draining",
+    InMaintenance = "InMaintenance",
+    NotSpecified = "NotSpecified",
+    Processing = "Processing",
+    Repairing = "Repairing",
+    Resuming = "Resuming"
 }
 
 // @public
-export type LogicalNetworksUpdateResponse = LogicalNetworks;
+export enum KnownDiagnosticLevel {
+    Basic = "Basic",
+    Enhanced = "Enhanced",
+    Off = "Off"
+}
 
 // @public
-export interface MarketplaceGalleryImages extends TrackedResource {
-    cloudInitDataSource?: CloudInitDataSource;
-    containerId?: string;
-    extendedLocation?: ExtendedLocation;
-    hyperVGeneration?: HyperVGeneration;
-    identifier?: GalleryImageIdentifier;
-    osType?: OperatingSystemTypes;
-    readonly provisioningState?: ProvisioningStateEnum;
-    readonly status?: MarketplaceGalleryImageStatus;
-    version?: GalleryImageVersion;
+export enum KnownEceSecrets {
+    AzureStackLCMUserCredential = "AzureStackLCMUserCredential",
+    DefaultARBApplication = "DefaultARBApplication",
+    LocalAdminCredential = "LocalAdminCredential",
+    WitnessStorageKey = "WitnessStorageKey"
 }
 
 // @public
-export interface MarketplaceGalleryImagesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export enum KnownExtensionAggregateState {
+    Accepted = "Accepted",
+    Canceled = "Canceled",
+    Connected = "Connected",
+    Creating = "Creating",
+    Deleted = "Deleted",
+    Deleting = "Deleting",
+    Disconnected = "Disconnected",
+    Error = "Error",
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Moving = "Moving",
+    NotSpecified = "NotSpecified",
+    PartiallyConnected = "PartiallyConnected",
+    PartiallySucceeded = "PartiallySucceeded",
+    Provisioning = "Provisioning",
+    Succeeded = "Succeeded",
+    Updating = "Updating",
+    UpgradeFailedRollbackSucceeded = "UpgradeFailedRollbackSucceeded"
 }
 
 // @public
-export type MarketplaceGalleryImagesCreateOrUpdateResponse = MarketplaceGalleryImages;
+export enum KnownExtensionManagedBy {
+    Azure = "Azure",
+    User = "User"
+}
 
 // @public
-export interface MarketplaceGalleryImagesDeleteHeaders {
-    // (undocumented)
-    location?: string;
+export enum KnownHealthState {
+    Error = "Error",
+    Failure = "Failure",
+    InProgress = "InProgress",
+    Success = "Success",
+    Unknown = "Unknown",
+    Warning = "Warning"
 }
 
 // @public
-export interface MarketplaceGalleryImagesDeleteOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export enum KnownImdsAttestation {
+    Disabled = "Disabled",
+    Enabled = "Enabled"
 }
 
 // @public
-export type MarketplaceGalleryImagesDeleteResponse = MarketplaceGalleryImagesDeleteHeaders;
+export enum KnownLogCollectionJobType {
+    OnDemand = "OnDemand",
+    Scheduled = "Scheduled"
+}
 
 // @public
-export interface MarketplaceGalleryImagesGetOptionalParams extends coreClient.OperationOptions {
+export enum KnownLogCollectionStatus {
+    Failed = "Failed",
+    InProgress = "InProgress",
+    None = "None",
+    Succeeded = "Succeeded"
 }
 
 // @public
-export type MarketplaceGalleryImagesGetResponse = MarketplaceGalleryImages;
+export enum KnownManagedServiceIdentityType {
+    None = "None",
+    SystemAssigned = "SystemAssigned",
+    SystemAssignedUserAssigned = "SystemAssigned, UserAssigned",
+    UserAssigned = "UserAssigned"
+}
 
 // @public
-export interface MarketplaceGalleryImagesListAllNextOptionalParams extends coreClient.OperationOptions {
+export enum KnownNodeArcState {
+    Accepted = "Accepted",
+    Canceled = "Canceled",
+    Connected = "Connected",
+    Creating = "Creating",
+    Deleted = "Deleted",
+    Deleting = "Deleting",
+    DisableInProgress = "DisableInProgress",
+    Disconnected = "Disconnected",
+    Error = "Error",
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Moving = "Moving",
+    NotSpecified = "NotSpecified",
+    PartiallyConnected = "PartiallyConnected",
+    PartiallySucceeded = "PartiallySucceeded",
+    Provisioning = "Provisioning",
+    Succeeded = "Succeeded",
+    Updating = "Updating"
 }
 
 // @public
-export type MarketplaceGalleryImagesListAllNextResponse = MarketplaceGalleryImagesListResult;
+export enum KnownNodeExtensionState {
+    Accepted = "Accepted",
+    Canceled = "Canceled",
+    Connected = "Connected",
+    Creating = "Creating",
+    Deleted = "Deleted",
+    Deleting = "Deleting",
+    Disconnected = "Disconnected",
+    Error = "Error",
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Moving = "Moving",
+    NotSpecified = "NotSpecified",
+    PartiallyConnected = "PartiallyConnected",
+    PartiallySucceeded = "PartiallySucceeded",
+    Provisioning = "Provisioning",
+    Succeeded = "Succeeded",
+    Updating = "Updating"
+}
 
 // @public
-export interface MarketplaceGalleryImagesListAllOptionalParams extends coreClient.OperationOptions {
+export enum KnownOemActivation {
+    Disabled = "Disabled",
+    Enabled = "Enabled"
 }
 
 // @public
-export type MarketplaceGalleryImagesListAllResponse = MarketplaceGalleryImagesListResult;
+export enum KnownOperationType {
+    ClusterProvisioning = "ClusterProvisioning",
+    ClusterUpgrade = "ClusterUpgrade"
+}
 
 // @public
-export interface MarketplaceGalleryImagesListNextOptionalParams extends coreClient.OperationOptions {
+export enum KnownOrigin {
+    System = "system",
+    User = "user",
+    UserSystem = "user,system"
 }
 
 // @public
-export type MarketplaceGalleryImagesListNextResponse = MarketplaceGalleryImagesListResult;
+export enum KnownProvisioningState {
+    Accepted = "Accepted",
+    Canceled = "Canceled",
+    Connected = "Connected",
+    Creating = "Creating",
+    Deleted = "Deleted",
+    Deleting = "Deleting",
+    DisableInProgress = "DisableInProgress",
+    Disconnected = "Disconnected",
+    Error = "Error",
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Moving = "Moving",
+    NotSpecified = "NotSpecified",
+    PartiallyConnected = "PartiallyConnected",
+    PartiallySucceeded = "PartiallySucceeded",
+    Provisioning = "Provisioning",
+    Succeeded = "Succeeded",
+    Updating = "Updating"
+}
 
 // @public
-export interface MarketplaceGalleryImagesListOptionalParams extends coreClient.OperationOptions {
+export enum KnownRebootRequirement {
+    False = "False",
+    True = "True",
+    Unknown = "Unknown"
 }
 
 // @public
-export type MarketplaceGalleryImagesListResponse = MarketplaceGalleryImagesListResult;
+export enum KnownRemoteSupportType {
+    Enable = "Enable",
+    Revoke = "Revoke"
+}
 
-// @public (undocumented)
-export interface MarketplaceGalleryImagesListResult {
-    // (undocumented)
-    nextLink?: string;
-    // (undocumented)
-    value?: MarketplaceGalleryImages[];
+// @public
+export enum KnownServiceName {
+    WAC = "WAC"
 }
 
 // @public
-export interface MarketplaceGalleryImagesOperations {
-    beginCreateOrUpdate(resourceGroupName: string, marketplaceGalleryImageName: string, marketplaceGalleryImages: MarketplaceGalleryImages, options?: MarketplaceGalleryImagesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<MarketplaceGalleryImagesCreateOrUpdateResponse>, MarketplaceGalleryImagesCreateOrUpdateResponse>>;
-    beginCreateOrUpdateAndWait(resourceGroupName: string, marketplaceGalleryImageName: string, marketplaceGalleryImages: MarketplaceGalleryImages, options?: MarketplaceGalleryImagesCreateOrUpdateOptionalParams): Promise<MarketplaceGalleryImagesCreateOrUpdateResponse>;
-    beginDelete(resourceGroupName: string, marketplaceGalleryImageName: string, options?: MarketplaceGalleryImagesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<MarketplaceGalleryImagesDeleteResponse>, MarketplaceGalleryImagesDeleteResponse>>;
-    beginDeleteAndWait(resourceGroupName: string, marketplaceGalleryImageName: string, options?: MarketplaceGalleryImagesDeleteOptionalParams): Promise<MarketplaceGalleryImagesDeleteResponse>;
-    beginUpdate(resourceGroupName: string, marketplaceGalleryImageName: string, marketplaceGalleryImages: MarketplaceGalleryImagesUpdateRequest, options?: MarketplaceGalleryImagesUpdateOptionalParams): Promise<SimplePollerLike<OperationState<MarketplaceGalleryImagesUpdateResponse>, MarketplaceGalleryImagesUpdateResponse>>;
-    beginUpdateAndWait(resourceGroupName: string, marketplaceGalleryImageName: string, marketplaceGalleryImages: MarketplaceGalleryImagesUpdateRequest, options?: MarketplaceGalleryImagesUpdateOptionalParams): Promise<MarketplaceGalleryImagesUpdateResponse>;
-    get(resourceGroupName: string, marketplaceGalleryImageName: string, options?: MarketplaceGalleryImagesGetOptionalParams): Promise<MarketplaceGalleryImagesGetResponse>;
-    list(resourceGroupName: string, options?: MarketplaceGalleryImagesListOptionalParams): PagedAsyncIterableIterator<MarketplaceGalleryImages>;
-    listAll(options?: MarketplaceGalleryImagesListAllOptionalParams): PagedAsyncIterableIterator<MarketplaceGalleryImages>;
+export enum KnownSeverity {
+    Critical = "Critical",
+    Hidden = "Hidden",
+    Informational = "Informational",
+    Warning = "Warning"
 }
 
 // @public
-export interface MarketplaceGalleryImageStatus {
-    downloadStatus?: MarketplaceGalleryImageStatusDownloadStatus;
-    errorCode?: string;
-    errorMessage?: string;
-    progressPercentage?: number;
-    // (undocumented)
-    provisioningStatus?: MarketplaceGalleryImageStatusProvisioningStatus;
+export enum KnownSoftwareAssuranceIntent {
+    Disable = "Disable",
+    Enable = "Enable"
 }
 
 // @public
-export interface MarketplaceGalleryImageStatusDownloadStatus {
-    downloadSizeInMB?: number;
+export enum KnownSoftwareAssuranceStatus {
+    Disabled = "Disabled",
+    Enabled = "Enabled"
 }
 
-// @public (undocumented)
-export interface MarketplaceGalleryImageStatusProvisioningStatus {
-    operationId?: string;
-    status?: Status;
+// @public
+export enum KnownState {
+    AdditionalContentRequired = "AdditionalContentRequired",
+    DownloadFailed = "DownloadFailed",
+    Downloading = "Downloading",
+    HasPrerequisite = "HasPrerequisite",
+    HealthCheckFailed = "HealthCheckFailed",
+    HealthChecking = "HealthChecking",
+    InstallationFailed = "InstallationFailed",
+    Installed = "Installed",
+    Installing = "Installing",
+    Invalid = "Invalid",
+    NotApplicableBecauseAnotherUpdateIsInProgress = "NotApplicableBecauseAnotherUpdateIsInProgress",
+    Obsolete = "Obsolete",
+    PreparationFailed = "PreparationFailed",
+    Preparing = "Preparing",
+    Ready = "Ready",
+    ReadyToInstall = "ReadyToInstall",
+    Recalled = "Recalled",
+    ScanFailed = "ScanFailed",
+    ScanInProgress = "ScanInProgress"
 }
 
 // @public
-export interface MarketplaceGalleryImagesUpdateHeaders {
-    // (undocumented)
-    location?: string;
+export enum KnownStatus {
+    ConnectedRecently = "ConnectedRecently",
+    DeploymentFailed = "DeploymentFailed",
+    DeploymentInProgress = "DeploymentInProgress",
+    DeploymentSuccess = "DeploymentSuccess",
+    Disconnected = "Disconnected",
+    Error = "Error",
+    Failed = "Failed",
+    InProgress = "InProgress",
+    NotConnectedRecently = "NotConnectedRecently",
+    NotSpecified = "NotSpecified",
+    NotYetRegistered = "NotYetRegistered",
+    Succeeded = "Succeeded",
+    ValidationFailed = "ValidationFailed",
+    ValidationInProgress = "ValidationInProgress",
+    ValidationSuccess = "ValidationSuccess"
 }
 
 // @public
-export interface MarketplaceGalleryImagesUpdateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export enum KnownStatusLevelTypes {
+    Error = "Error",
+    Info = "Info",
+    Warning = "Warning"
 }
 
 // @public
-export interface MarketplaceGalleryImagesUpdateRequest {
-    tags?: {
-        [propertyName: string]: string;
-    };
+export enum KnownUpdateRunPropertiesState {
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Succeeded = "Succeeded",
+    Unknown = "Unknown"
 }
 
 // @public
-export type MarketplaceGalleryImagesUpdateResponse = MarketplaceGalleryImages;
+export enum KnownUpdateSummariesPropertiesState {
+    AppliedSuccessfully = "AppliedSuccessfully",
+    NeedsAttention = "NeedsAttention",
+    PreparationFailed = "PreparationFailed",
+    PreparationInProgress = "PreparationInProgress",
+    Unknown = "Unknown",
+    UpdateAvailable = "UpdateAvailable",
+    UpdateFailed = "UpdateFailed",
+    UpdateInProgress = "UpdateInProgress"
+}
 
 // @public
-export interface NetworkInterfaces extends TrackedResource {
-    dnsSettings?: InterfaceDNSSettings;
-    extendedLocation?: ExtendedLocation;
-    ipConfigurations?: IPConfiguration[];
-    macAddress?: string;
-    readonly provisioningState?: ProvisioningStateEnum;
-    readonly status?: NetworkInterfaceStatus;
+export enum KnownWindowsServerSubscription {
+    Disabled = "Disabled",
+    Enabled = "Enabled"
 }
 
 // @public
-export interface NetworkInterfacesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export interface LogCollectionError {
+    readonly errorCode?: string;
+    readonly errorMessage?: string;
 }
 
 // @public
-export type NetworkInterfacesCreateOrUpdateResponse = NetworkInterfaces;
+export type LogCollectionJobType = string;
 
 // @public
-export interface NetworkInterfacesDeleteHeaders {
-    // (undocumented)
-    location?: string;
+export interface LogCollectionProperties {
+    readonly fromDate?: Date;
+    readonly lastLogGenerated?: Date;
+    readonly logCollectionSessionDetails?: LogCollectionSession[];
+    readonly toDate?: Date;
 }
 
 // @public
-export interface NetworkInterfacesDeleteOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export interface LogCollectionRequest {
+    properties?: LogCollectionRequestProperties;
 }
 
 // @public
-export type NetworkInterfacesDeleteResponse = NetworkInterfacesDeleteHeaders;
+export interface LogCollectionRequestProperties {
+    fromDate: Date;
+    toDate: Date;
+}
 
 // @public
-export interface NetworkInterfacesGetOptionalParams extends coreClient.OperationOptions {
+export interface LogCollectionSession {
+    readonly correlationId?: string;
+    readonly endTimeCollected?: Date;
+    readonly logCollectionError?: LogCollectionError;
+    readonly logCollectionJobType?: LogCollectionJobType;
+    readonly logCollectionStatus?: LogCollectionStatus;
+    readonly logEndTime?: Date;
+    readonly logSize?: number;
+    readonly logStartTime?: Date;
+    readonly timeCollected?: Date;
 }
 
 // @public
-export type NetworkInterfacesGetResponse = NetworkInterfaces;
+export type LogCollectionStatus = string;
 
 // @public
-export interface NetworkInterfacesListAllNextOptionalParams extends coreClient.OperationOptions {
-}
+export type ManagedServiceIdentityType = string;
 
 // @public
-export type NetworkInterfacesListAllNextResponse = NetworkInterfacesListResult;
+export interface NetworkController {
+    macAddressPoolStart?: string;
+    macAddressPoolStop?: string;
+    networkVirtualizationEnabled?: boolean;
+}
 
 // @public
-export interface NetworkInterfacesListAllOptionalParams extends coreClient.OperationOptions {
+export interface NicDetail {
+    adapterName?: string;
+    componentId?: string;
+    defaultGateway?: string;
+    defaultIsolationId?: string;
+    dnsServers?: string[];
+    driverVersion?: string;
+    interfaceDescription?: string;
+    ip4Address?: string;
+    subnetMask?: string;
 }
 
 // @public
-export type NetworkInterfacesListAllResponse = NetworkInterfacesListResult;
+export type NodeArcState = string;
+
+// @public
+export type NodeExtensionState = string;
 
 // @public
-export interface NetworkInterfacesListNextOptionalParams extends coreClient.OperationOptions {
+export interface Observability {
+    episodicDataUpload?: boolean;
+    euLocation?: boolean;
+    streamingDataClient?: boolean;
 }
 
 // @public
-export type NetworkInterfacesListNextResponse = NetworkInterfacesListResult;
+export type OemActivation = string;
 
 // @public
-export interface NetworkInterfacesListOptionalParams extends coreClient.OperationOptions {
+export interface Offer extends ProxyResource {
+    content?: string;
+    contentVersion?: string;
+    readonly provisioningState?: string;
+    publisherId?: string;
+    skuMappings?: SkuMappings[];
 }
 
 // @public
-export type NetworkInterfacesListResponse = NetworkInterfacesListResult;
-
-// @public (undocumented)
-export interface NetworkInterfacesListResult {
-    // (undocumented)
-    nextLink?: string;
-    // (undocumented)
-    value?: NetworkInterfaces[];
+export interface OfferList {
+    readonly nextLink?: string;
+    readonly value?: Offer[];
 }
 
 // @public
-export interface NetworkInterfacesOperations {
-    beginCreateOrUpdate(resourceGroupName: string, networkInterfaceName: string, networkInterfaces: NetworkInterfaces, options?: NetworkInterfacesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NetworkInterfacesCreateOrUpdateResponse>, NetworkInterfacesCreateOrUpdateResponse>>;
-    beginCreateOrUpdateAndWait(resourceGroupName: string, networkInterfaceName: string, networkInterfaces: NetworkInterfaces, options?: NetworkInterfacesCreateOrUpdateOptionalParams): Promise<NetworkInterfacesCreateOrUpdateResponse>;
-    beginDelete(resourceGroupName: string, networkInterfaceName: string, options?: NetworkInterfacesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<NetworkInterfacesDeleteResponse>, NetworkInterfacesDeleteResponse>>;
-    beginDeleteAndWait(resourceGroupName: string, networkInterfaceName: string, options?: NetworkInterfacesDeleteOptionalParams): Promise<NetworkInterfacesDeleteResponse>;
-    beginUpdate(resourceGroupName: string, networkInterfaceName: string, networkInterfaces: NetworkInterfacesUpdateRequest, options?: NetworkInterfacesUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NetworkInterfacesUpdateResponse>, NetworkInterfacesUpdateResponse>>;
-    beginUpdateAndWait(resourceGroupName: string, networkInterfaceName: string, networkInterfaces: NetworkInterfacesUpdateRequest, options?: NetworkInterfacesUpdateOptionalParams): Promise<NetworkInterfacesUpdateResponse>;
-    get(resourceGroupName: string, networkInterfaceName: string, options?: NetworkInterfacesGetOptionalParams): Promise<NetworkInterfacesGetResponse>;
-    list(resourceGroupName: string, options?: NetworkInterfacesListOptionalParams): PagedAsyncIterableIterator<NetworkInterfaces>;
-    listAll(options?: NetworkInterfacesListAllOptionalParams): PagedAsyncIterableIterator<NetworkInterfaces>;
+export interface Offers {
+    get(resourceGroupName: string, clusterName: string, publisherName: string, offerName: string, options?: OffersGetOptionalParams): Promise<OffersGetResponse>;
+    listByCluster(resourceGroupName: string, clusterName: string, options?: OffersListByClusterOptionalParams): PagedAsyncIterableIterator<Offer>;
+    listByPublisher(resourceGroupName: string, clusterName: string, publisherName: string, options?: OffersListByPublisherOptionalParams): PagedAsyncIterableIterator<Offer>;
 }
 
 // @public
-export interface NetworkInterfaceStatus {
-    errorCode?: string;
-    errorMessage?: string;
-    // (undocumented)
-    provisioningStatus?: NetworkInterfaceStatusProvisioningStatus;
+export interface OffersGetOptionalParams extends coreClient.OperationOptions {
+    expand?: string;
 }
 
-// @public (undocumented)
-export interface NetworkInterfaceStatusProvisioningStatus {
-    operationId?: string;
-    status?: Status;
-}
+// @public
+export type OffersGetResponse = Offer;
 
 // @public
-export interface NetworkInterfacesUpdateHeaders {
-    // (undocumented)
-    location?: string;
+export interface OffersListByClusterNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface NetworkInterfacesUpdateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
-}
+export type OffersListByClusterNextResponse = OfferList;
 
 // @public
-export interface NetworkInterfacesUpdateRequest {
-    tags?: {
-        [propertyName: string]: string;
-    };
+export interface OffersListByClusterOptionalParams extends coreClient.OperationOptions {
+    expand?: string;
 }
 
 // @public
-export type NetworkInterfacesUpdateResponse = NetworkInterfaces;
+export type OffersListByClusterResponse = OfferList;
 
 // @public
-export interface NetworkProfileUpdate {
-    networkInterfaces?: NetworkProfileUpdateNetworkInterfacesItem[];
+export interface OffersListByPublisherNextOptionalParams extends coreClient.OperationOptions {
 }
 
-// @public (undocumented)
-export interface NetworkProfileUpdateNetworkInterfacesItem {
-    id?: string;
+// @public
+export type OffersListByPublisherNextResponse = OfferList;
+
+// @public
+export interface OffersListByPublisherOptionalParams extends coreClient.OperationOptions {
+    expand?: string;
 }
 
 // @public
-export type OperatingSystemTypes = "Windows" | "Linux";
+export type OffersListByPublisherResponse = OfferList;
 
 // @public
 export interface Operation {
@@ -1032,697 +1647,770 @@ export interface OperationListResult {
 
 // @public
 export interface Operations {
-    list(options?: OperationsListOptionalParams): PagedAsyncIterableIterator<Operation>;
+    list(options?: OperationsListOptionalParams): Promise<OperationsListResponse>;
 }
 
 // @public
-export interface OperationsListNextOptionalParams extends coreClient.OperationOptions {
+export interface OperationsListOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type OperationsListNextResponse = OperationListResult;
+export type OperationsListResponse = OperationListResult;
 
 // @public
-export interface OperationsListOptionalParams extends coreClient.OperationOptions {
-}
+export type OperationType = string;
 
 // @public
-export type OperationsListResponse = OperationListResult;
+export interface OptionalServices {
+    customLocation?: string;
+}
 
 // @public
 export type Origin = string;
 
 // @public
-export interface OsProfileUpdate {
-    computerName?: string;
-    // (undocumented)
-    linuxConfiguration?: OsProfileUpdateLinuxConfiguration;
-    // (undocumented)
-    windowsConfiguration?: OsProfileUpdateWindowsConfiguration;
-}
-
-// @public (undocumented)
-export interface OsProfileUpdateLinuxConfiguration {
-    provisionVMAgent?: boolean;
-    provisionVMConfigAgent?: boolean;
+export interface PackageVersionInfo {
+    lastUpdated?: Date;
+    packageType?: string;
+    version?: string;
 }
 
 // @public (undocumented)
-export interface OsProfileUpdateWindowsConfiguration {
-    provisionVMAgent?: boolean;
-    provisionVMConfigAgent?: boolean;
+export interface PasswordCredential {
+    // (undocumented)
+    endDateTime?: Date;
+    // (undocumented)
+    keyId?: string;
+    // (undocumented)
+    secretText?: string;
+    // (undocumented)
+    startDateTime?: Date;
 }
 
 // @public
-export type PowerStateEnum = string;
-
-// @public
-export type ProvisioningAction = string;
-
-// @public
-export type ProvisioningStateEnum = string;
+export interface PerNodeExtensionState {
+    readonly extension?: string;
+    readonly instanceView?: ExtensionInstanceView;
+    readonly name?: string;
+    readonly state?: NodeExtensionState;
+    readonly typeHandlerVersion?: string;
+}
 
 // @public
-export interface ProxyResource extends Resource {
+export interface PerNodeRemoteSupportSession {
+    readonly accessLevel?: AccessLevel;
+    readonly duration?: number;
+    readonly nodeName?: string;
+    readonly sessionEndTime?: Date;
+    readonly sessionStartTime?: Date;
 }
 
 // @public
-export interface Resource {
-    readonly id?: string;
+export interface PerNodeState {
+    readonly arcInstance?: string;
+    readonly arcNodeServicePrincipalObjectId?: string;
     readonly name?: string;
-    readonly systemData?: SystemData;
-    readonly type?: string;
+    readonly state?: NodeArcState;
 }
 
 // @public
-export interface Route {
-    addressPrefix?: string;
+export interface PhysicalNodes {
+    ipv4Address?: string;
+    name?: string;
+}
+
+// @public (undocumented)
+export interface PrecheckResult {
+    additionalData?: string;
+    description?: string;
+    displayName?: string;
+    healthCheckSource?: string;
+    healthCheckTags?: Record<string, unknown>;
     name?: string;
-    nextHopIpAddress?: string;
+    remediation?: string;
+    severity?: Severity;
+    status?: Status;
+    tags?: PrecheckResultTags;
+    targetResourceID?: string;
+    targetResourceName?: string;
+    targetResourceType?: string;
+    timestamp?: Date;
+    title?: string;
 }
 
 // @public
-export interface RouteTable {
-    readonly etag?: string;
-    readonly name?: string;
-    routes?: Route[];
-    readonly type?: string;
+export interface PrecheckResultTags {
+    key?: string;
+    value?: string;
 }
 
 // @public
-export type SecurityTypes = string;
+export type ProvisioningState = string;
 
 // @public
-export interface SshConfiguration {
-    publicKeys?: SshPublicKey[];
+export interface ProxyResource extends Resource {
 }
 
 // @public
-export interface SshPublicKey {
-    keyData?: string;
-    path?: string;
+export interface Publisher extends ProxyResource {
+    readonly provisioningState?: string;
 }
 
 // @public
-export type Status = string;
+export interface PublisherList {
+    readonly nextLink?: string;
+    readonly value?: Publisher[];
+}
 
 // @public
-export type StatusLevelTypes = string;
+export interface Publishers {
+    get(resourceGroupName: string, clusterName: string, publisherName: string, options?: PublishersGetOptionalParams): Promise<PublishersGetResponse>;
+    listByCluster(resourceGroupName: string, clusterName: string, options?: PublishersListByClusterOptionalParams): PagedAsyncIterableIterator<Publisher>;
+}
 
 // @public
-export type StatusTypes = string;
+export interface PublishersGetOptionalParams extends coreClient.OperationOptions {
+}
 
 // @public
-export interface StorageContainers extends TrackedResource {
-    extendedLocation?: ExtendedLocation;
-    path?: string;
-    readonly provisioningState?: ProvisioningStateEnum;
-    readonly status?: StorageContainerStatus;
-}
+export type PublishersGetResponse = Publisher;
 
 // @public
-export interface StorageContainersCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export interface PublishersListByClusterNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type StorageContainersCreateOrUpdateResponse = StorageContainers;
+export type PublishersListByClusterNextResponse = PublisherList;
 
 // @public
-export interface StorageContainersDeleteHeaders {
-    // (undocumented)
-    location?: string;
+export interface PublishersListByClusterOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface StorageContainersDeleteOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
-}
+export type PublishersListByClusterResponse = PublisherList;
 
 // @public
-export type StorageContainersDeleteResponse = StorageContainersDeleteHeaders;
+export interface QosPolicyOverrides {
+    bandwidthPercentageSMB?: string;
+    priorityValue8021ActionCluster?: string;
+    priorityValue8021ActionSMB?: string;
+}
 
-// @public
-export interface StorageContainersGetOptionalParams extends coreClient.OperationOptions {
+// @public (undocumented)
+export interface RawCertificateData {
+    // (undocumented)
+    certificates?: string[];
 }
 
 // @public
-export type StorageContainersGetResponse = StorageContainers;
+export type RebootRequirement = string;
 
 // @public
-export interface StorageContainersListAllNextOptionalParams extends coreClient.OperationOptions {
+export interface RemoteSupportNodeSettings {
+    readonly arcResourceId?: string;
+    readonly connectionErrorMessage?: string;
+    readonly connectionStatus?: string;
+    readonly createdAt?: Date;
+    readonly state?: string;
+    readonly transcriptLocation?: string;
+    readonly updatedAt?: Date;
 }
 
 // @public
-export type StorageContainersListAllNextResponse = StorageContainersListResult;
-
-// @public
-export interface StorageContainersListAllOptionalParams extends coreClient.OperationOptions {
+export interface RemoteSupportProperties {
+    readonly accessLevel?: AccessLevel;
+    readonly expirationTimeStamp?: Date;
+    readonly remoteSupportNodeSettings?: RemoteSupportNodeSettings[];
+    readonly remoteSupportSessionDetails?: PerNodeRemoteSupportSession[];
+    readonly remoteSupportType?: RemoteSupportType;
 }
 
 // @public
-export type StorageContainersListAllResponse = StorageContainersListResult;
+export interface RemoteSupportRequest {
+    properties?: RemoteSupportRequestProperties;
+}
 
 // @public
-export interface StorageContainersListNextOptionalParams extends coreClient.OperationOptions {
+export interface RemoteSupportRequestProperties {
+    readonly accessLevel?: AccessLevel;
+    expirationTimeStamp?: Date;
+    remoteSupportType?: RemoteSupportType;
 }
 
 // @public
-export type StorageContainersListNextResponse = StorageContainersListResult;
+export type RemoteSupportType = string;
 
 // @public
-export interface StorageContainersListOptionalParams extends coreClient.OperationOptions {
+export interface ReportedProperties {
+    readonly deviceState?: DeviceState;
+    readonly extensionProfile?: ExtensionProfile;
 }
 
 // @public
-export type StorageContainersListResponse = StorageContainersListResult;
-
-// @public (undocumented)
-export interface StorageContainersListResult {
-    // (undocumented)
-    nextLink?: string;
-    // (undocumented)
-    value?: StorageContainers[];
+export interface Resource {
+    readonly id?: string;
+    readonly name?: string;
+    readonly systemData?: SystemData;
+    readonly type?: string;
 }
 
 // @public
-export interface StorageContainersOperations {
-    beginCreateOrUpdate(resourceGroupName: string, storageContainerName: string, storageContainers: StorageContainers, options?: StorageContainersCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<StorageContainersCreateOrUpdateResponse>, StorageContainersCreateOrUpdateResponse>>;
-    beginCreateOrUpdateAndWait(resourceGroupName: string, storageContainerName: string, storageContainers: StorageContainers, options?: StorageContainersCreateOrUpdateOptionalParams): Promise<StorageContainersCreateOrUpdateResponse>;
-    beginDelete(resourceGroupName: string, storageContainerName: string, options?: StorageContainersDeleteOptionalParams): Promise<SimplePollerLike<OperationState<StorageContainersDeleteResponse>, StorageContainersDeleteResponse>>;
-    beginDeleteAndWait(resourceGroupName: string, storageContainerName: string, options?: StorageContainersDeleteOptionalParams): Promise<StorageContainersDeleteResponse>;
-    beginUpdate(resourceGroupName: string, storageContainerName: string, storageContainers: StorageContainersUpdateRequest, options?: StorageContainersUpdateOptionalParams): Promise<SimplePollerLike<OperationState<StorageContainersUpdateResponse>, StorageContainersUpdateResponse>>;
-    beginUpdateAndWait(resourceGroupName: string, storageContainerName: string, storageContainers: StorageContainersUpdateRequest, options?: StorageContainersUpdateOptionalParams): Promise<StorageContainersUpdateResponse>;
-    get(resourceGroupName: string, storageContainerName: string, options?: StorageContainersGetOptionalParams): Promise<StorageContainersGetResponse>;
-    list(resourceGroupName: string, options?: StorageContainersListOptionalParams): PagedAsyncIterableIterator<StorageContainers>;
-    listAll(options?: StorageContainersListAllOptionalParams): PagedAsyncIterableIterator<StorageContainers>;
+export interface SbeCredentials {
+    eceSecretName?: string;
+    secretLocation?: string;
+    secretName?: string;
 }
 
 // @public
-export interface StorageContainerStatus {
-    availableSizeMB?: number;
-    containerSizeMB?: number;
-    errorCode?: string;
-    errorMessage?: string;
-    // (undocumented)
-    provisioningStatus?: StorageContainerStatusProvisioningStatus;
-}
-
-// @public (undocumented)
-export interface StorageContainerStatusProvisioningStatus {
-    operationId?: string;
-    status?: Status;
+export interface SbeDeploymentInfo {
+    family?: string;
+    publisher?: string;
+    sbeManifestCreationDate?: Date;
+    sbeManifestSource?: string;
+    version?: string;
 }
 
 // @public
-export interface StorageContainersUpdateHeaders {
-    // (undocumented)
-    location?: string;
+export interface SbeDeploymentPackageInfo {
+    readonly code?: string;
+    readonly message?: string;
+    readonly sbeManifest?: string;
 }
 
 // @public
-export interface StorageContainersUpdateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export interface SbePartnerInfo {
+    credentialList?: SbeCredentials[];
+    partnerProperties?: SbePartnerProperties[];
+    sbeDeploymentInfo?: SbeDeploymentInfo;
 }
 
 // @public
-export interface StorageContainersUpdateRequest {
-    tags?: {
-        [propertyName: string]: string;
-    };
+export interface SbePartnerProperties {
+    name?: string;
+    value?: string;
 }
 
 // @public
-export type StorageContainersUpdateResponse = StorageContainers;
-
-// @public (undocumented)
-export interface StorageProfileUpdate {
-    dataDisks?: StorageProfileUpdateDataDisksItem[];
+export interface ScaleUnits {
+    deploymentData: DeploymentData;
+    sbePartnerInfo?: SbePartnerInfo;
 }
 
-// @public (undocumented)
-export interface StorageProfileUpdateDataDisksItem {
-    // (undocumented)
-    id?: string;
+// @public
+export interface SdnIntegration {
+    networkController?: NetworkController;
 }
 
-// @public (undocumented)
-export interface Subnet {
-    addressPrefix?: string;
-    addressPrefixes?: string[];
-    ipAllocationMethod?: IpAllocationMethodEnum;
-    ipConfigurationReferences?: SubnetPropertiesFormatIpConfigurationReferencesItem[];
-    ipPools?: IPPool[];
-    name?: string;
-    routeTable?: RouteTable;
-    vlan?: number;
+// @public
+export interface SecurityComplianceStatus {
+    readonly dataAtRestEncrypted?: ComplianceStatus;
+    readonly dataInTransitProtected?: ComplianceStatus;
+    readonly lastUpdated?: Date;
+    readonly securedCoreCompliance?: ComplianceStatus;
+    readonly wdacCompliance?: ComplianceStatus;
 }
 
 // @public
-export interface SubnetPropertiesFormatIpConfigurationReferencesItem {
-    id?: string;
+export interface SecuritySetting extends ProxyResource {
+    provisioningState?: ProvisioningState;
+    securedCoreComplianceAssignment?: ComplianceAssignmentType;
+    readonly securityComplianceStatus?: SecurityComplianceStatus;
+    smbEncryptionForIntraClusterTrafficComplianceAssignment?: ComplianceAssignmentType;
+    wdacComplianceAssignment?: ComplianceAssignmentType;
 }
 
 // @public
-export interface SystemData {
-    createdAt?: Date;
-    createdBy?: string;
-    createdByType?: CreatedByType;
-    lastModifiedAt?: Date;
-    lastModifiedBy?: string;
-    lastModifiedByType?: CreatedByType;
+export interface SecuritySettingListResult {
+    nextLink?: string;
+    value: SecuritySetting[];
 }
 
 // @public
-export interface TrackedResource extends Resource {
-    location: string;
-    tags?: {
-        [propertyName: string]: string;
-    };
+export interface SecuritySettings {
+    beginCreateOrUpdate(resourceGroupName: string, clusterName: string, securitySettingsName: string, resource: SecuritySetting, options?: SecuritySettingsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<SecuritySettingsCreateOrUpdateResponse>, SecuritySettingsCreateOrUpdateResponse>>;
+    beginCreateOrUpdateAndWait(resourceGroupName: string, clusterName: string, securitySettingsName: string, resource: SecuritySetting, options?: SecuritySettingsCreateOrUpdateOptionalParams): Promise<SecuritySettingsCreateOrUpdateResponse>;
+    beginDelete(resourceGroupName: string, clusterName: string, securitySettingsName: string, options?: SecuritySettingsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<SecuritySettingsDeleteResponse>, SecuritySettingsDeleteResponse>>;
+    beginDeleteAndWait(resourceGroupName: string, clusterName: string, securitySettingsName: string, options?: SecuritySettingsDeleteOptionalParams): Promise<SecuritySettingsDeleteResponse>;
+    get(resourceGroupName: string, clusterName: string, securitySettingsName: string, options?: SecuritySettingsGetOptionalParams): Promise<SecuritySettingsGetResponse>;
+    listByClusters(resourceGroupName: string, clusterName: string, options?: SecuritySettingsListByClustersOptionalParams): PagedAsyncIterableIterator<SecuritySetting>;
 }
 
 // @public
-export interface VirtualHardDisks extends TrackedResource {
-    // (undocumented)
-    blockSizeBytes?: number;
-    containerId?: string;
-    diskFileFormat?: DiskFileFormat;
-    diskSizeGB?: number;
-    dynamic?: boolean;
-    extendedLocation?: ExtendedLocation;
-    hyperVGeneration?: HyperVGeneration;
-    // (undocumented)
-    logicalSectorBytes?: number;
-    // (undocumented)
-    physicalSectorBytes?: number;
-    readonly provisioningState?: ProvisioningStateEnum;
-    readonly status?: VirtualHardDiskStatus;
+export interface SecuritySettingsCreateOrUpdateHeaders {
+    retryAfter?: number;
 }
 
 // @public
-export interface VirtualHardDisksCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
+export interface SecuritySettingsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
     resumeFrom?: string;
     updateIntervalInMs?: number;
 }
 
 // @public
-export type VirtualHardDisksCreateOrUpdateResponse = VirtualHardDisks;
+export type SecuritySettingsCreateOrUpdateResponse = SecuritySetting;
 
 // @public
-export interface VirtualHardDisksDeleteHeaders {
-    // (undocumented)
+export interface SecuritySettingsDeleteHeaders {
     location?: string;
+    retryAfter?: number;
 }
 
 // @public
-export interface VirtualHardDisksDeleteOptionalParams extends coreClient.OperationOptions {
+export interface SecuritySettingsDeleteOptionalParams extends coreClient.OperationOptions {
     resumeFrom?: string;
     updateIntervalInMs?: number;
 }
 
 // @public
-export type VirtualHardDisksDeleteResponse = VirtualHardDisksDeleteHeaders;
+export type SecuritySettingsDeleteResponse = SecuritySettingsDeleteHeaders;
 
 // @public
-export interface VirtualHardDisksGetOptionalParams extends coreClient.OperationOptions {
+export interface SecuritySettingsGetOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type VirtualHardDisksGetResponse = VirtualHardDisks;
+export type SecuritySettingsGetResponse = SecuritySetting;
 
 // @public
-export interface VirtualHardDisksListAllNextOptionalParams extends coreClient.OperationOptions {
+export interface SecuritySettingsListByClustersNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type VirtualHardDisksListAllNextResponse = VirtualHardDisksListResult;
+export type SecuritySettingsListByClustersNextResponse = SecuritySettingListResult;
 
 // @public
-export interface VirtualHardDisksListAllOptionalParams extends coreClient.OperationOptions {
+export interface SecuritySettingsListByClustersOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type VirtualHardDisksListAllResponse = VirtualHardDisksListResult;
+export type SecuritySettingsListByClustersResponse = SecuritySettingListResult;
 
 // @public
-export interface VirtualHardDisksListNextOptionalParams extends coreClient.OperationOptions {
+export interface ServiceConfiguration {
+    port: number;
+    serviceName: ServiceName;
 }
 
 // @public
-export type VirtualHardDisksListNextResponse = VirtualHardDisksListResult;
+export type ServiceName = string;
 
 // @public
-export interface VirtualHardDisksListOptionalParams extends coreClient.OperationOptions {
-}
+export type Severity = string;
 
 // @public
-export type VirtualHardDisksListResponse = VirtualHardDisksListResult;
-
-// @public (undocumented)
-export interface VirtualHardDisksListResult {
-    // (undocumented)
-    nextLink?: string;
-    // (undocumented)
-    value?: VirtualHardDisks[];
+export interface Sku extends ProxyResource {
+    content?: string;
+    contentVersion?: string;
+    offerId?: string;
+    readonly provisioningState?: string;
+    publisherId?: string;
+    skuMappings?: SkuMappings[];
 }
 
 // @public
-export interface VirtualHardDisksOperations {
-    beginCreateOrUpdate(resourceGroupName: string, virtualHardDiskName: string, virtualHardDisks: VirtualHardDisks, options?: VirtualHardDisksCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualHardDisksCreateOrUpdateResponse>, VirtualHardDisksCreateOrUpdateResponse>>;
-    beginCreateOrUpdateAndWait(resourceGroupName: string, virtualHardDiskName: string, virtualHardDisks: VirtualHardDisks, options?: VirtualHardDisksCreateOrUpdateOptionalParams): Promise<VirtualHardDisksCreateOrUpdateResponse>;
-    beginDelete(resourceGroupName: string, virtualHardDiskName: string, options?: VirtualHardDisksDeleteOptionalParams): Promise<SimplePollerLike<OperationState<VirtualHardDisksDeleteResponse>, VirtualHardDisksDeleteResponse>>;
-    beginDeleteAndWait(resourceGroupName: string, virtualHardDiskName: string, options?: VirtualHardDisksDeleteOptionalParams): Promise<VirtualHardDisksDeleteResponse>;
-    beginUpdate(resourceGroupName: string, virtualHardDiskName: string, virtualHardDisks: VirtualHardDisksUpdateRequest, options?: VirtualHardDisksUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualHardDisksUpdateResponse>, VirtualHardDisksUpdateResponse>>;
-    beginUpdateAndWait(resourceGroupName: string, virtualHardDiskName: string, virtualHardDisks: VirtualHardDisksUpdateRequest, options?: VirtualHardDisksUpdateOptionalParams): Promise<VirtualHardDisksUpdateResponse>;
-    get(resourceGroupName: string, virtualHardDiskName: string, options?: VirtualHardDisksGetOptionalParams): Promise<VirtualHardDisksGetResponse>;
-    list(resourceGroupName: string, options?: VirtualHardDisksListOptionalParams): PagedAsyncIterableIterator<VirtualHardDisks>;
-    listAll(options?: VirtualHardDisksListAllOptionalParams): PagedAsyncIterableIterator<VirtualHardDisks>;
+export interface SkuList {
+    readonly nextLink?: string;
+    readonly value?: Sku[];
 }
 
 // @public
-export interface VirtualHardDiskStatus {
-    errorCode?: string;
-    errorMessage?: string;
-    // (undocumented)
-    provisioningStatus?: VirtualHardDiskStatusProvisioningStatus;
+export interface SkuMappings {
+    catalogPlanId?: string;
+    marketplaceSkuId?: string;
+    marketplaceSkuVersions?: string[];
 }
 
-// @public (undocumented)
-export interface VirtualHardDiskStatusProvisioningStatus {
-    operationId?: string;
-    status?: Status;
+// @public
+export interface Skus {
+    get(resourceGroupName: string, clusterName: string, publisherName: string, offerName: string, skuName: string, options?: SkusGetOptionalParams): Promise<SkusGetResponse>;
+    listByOffer(resourceGroupName: string, clusterName: string, publisherName: string, offerName: string, options?: SkusListByOfferOptionalParams): PagedAsyncIterableIterator<Sku>;
 }
 
 // @public
-export interface VirtualHardDisksUpdateHeaders {
-    // (undocumented)
-    location?: string;
+export interface SkusGetOptionalParams extends coreClient.OperationOptions {
+    expand?: string;
 }
 
 // @public
-export interface VirtualHardDisksUpdateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
-}
+export type SkusGetResponse = Sku;
 
 // @public
-export interface VirtualHardDisksUpdateRequest {
-    tags?: {
-        [propertyName: string]: string;
-    };
+export interface SkusListByOfferNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type VirtualHardDisksUpdateResponse = VirtualHardDisks;
+export type SkusListByOfferNextResponse = SkuList;
 
 // @public
-export interface VirtualMachineConfigAgentInstanceView {
-    statuses?: InstanceViewStatus[];
-    vmConfigAgentVersion?: string;
+export interface SkusListByOfferOptionalParams extends coreClient.OperationOptions {
+    expand?: string;
 }
 
 // @public
-export interface VirtualMachineInstance extends ProxyResource {
-    extendedLocation?: ExtendedLocation;
-    guestAgentInstallStatus?: GuestAgentInstallStatus;
-    hardwareProfile?: VirtualMachineInstancePropertiesHardwareProfile;
-    httpProxyConfig?: HttpProxyConfiguration;
-    identity?: Identity;
-    readonly instanceView?: VirtualMachineInstanceView;
-    networkProfile?: VirtualMachineInstancePropertiesNetworkProfile;
-    osProfile?: VirtualMachineInstancePropertiesOsProfile;
-    readonly provisioningState?: ProvisioningStateEnum;
-    resourceUid?: string;
-    securityProfile?: VirtualMachineInstancePropertiesSecurityProfile;
-    readonly status?: VirtualMachineInstanceStatus;
-    storageProfile?: VirtualMachineInstancePropertiesStorageProfile;
-    readonly vmId?: string;
-}
+export type SkusListByOfferResponse = SkuList;
 
 // @public (undocumented)
-export interface VirtualMachineInstanceListResult {
-    // (undocumented)
-    nextLink?: string;
+export interface SoftwareAssuranceChangeRequest {
     // (undocumented)
-    value?: VirtualMachineInstance[];
+    properties?: SoftwareAssuranceChangeRequestProperties;
+}
+
+// @public (undocumented)
+export interface SoftwareAssuranceChangeRequestProperties {
+    softwareAssuranceIntent?: SoftwareAssuranceIntent;
 }
 
 // @public
-export interface VirtualMachineInstancePropertiesHardwareProfile {
-    // (undocumented)
-    dynamicMemoryConfig?: VirtualMachineInstancePropertiesHardwareProfileDynamicMemoryConfig;
-    memoryMB?: number;
-    processors?: number;
-    // (undocumented)
-    vmSize?: VmSizeEnum;
+export type SoftwareAssuranceIntent = string;
+
+// @public
+export interface SoftwareAssuranceProperties {
+    readonly lastUpdated?: Date;
+    softwareAssuranceIntent?: SoftwareAssuranceIntent;
+    readonly softwareAssuranceStatus?: SoftwareAssuranceStatus;
 }
 
-// @public (undocumented)
-export interface VirtualMachineInstancePropertiesHardwareProfileDynamicMemoryConfig {
-    // (undocumented)
-    maximumMemoryMB?: number;
-    // (undocumented)
-    minimumMemoryMB?: number;
-    targetMemoryBuffer?: number;
+// @public
+export type SoftwareAssuranceStatus = string;
+
+// @public
+export type State = string;
+
+// @public
+export type Status = string;
+
+// @public
+export type StatusLevelTypes = string;
+
+// @public
+export interface Step {
+    description?: string;
+    endTimeUtc?: Date;
+    errorMessage?: string;
+    expectedExecutionTime?: string;
+    lastUpdatedTimeUtc?: Date;
+    name?: string;
+    startTimeUtc?: Date;
+    status?: string;
+    steps?: Step[];
 }
 
 // @public
-export interface VirtualMachineInstancePropertiesNetworkProfile {
-    networkInterfaces?: VirtualMachineInstancePropertiesNetworkProfileNetworkInterfacesItem[];
+interface Storage_2 {
+    configurationMode?: string;
 }
+export { Storage_2 as Storage }
 
-// @public (undocumented)
-export interface VirtualMachineInstancePropertiesNetworkProfileNetworkInterfacesItem {
-    id?: string;
+// @public
+export interface SwitchDetail {
+    readonly extensions?: SwitchExtension[];
+    readonly switchName?: string;
+    readonly switchType?: string;
 }
 
 // @public
-export interface VirtualMachineInstancePropertiesOsProfile {
-    adminPassword?: string;
-    adminUsername?: string;
-    computerName?: string;
-    linuxConfiguration?: VirtualMachineInstancePropertiesOsProfileLinuxConfiguration;
-    windowsConfiguration?: VirtualMachineInstancePropertiesOsProfileWindowsConfiguration;
+export interface SwitchExtension {
+    readonly extensionEnabled?: boolean;
+    readonly extensionName?: string;
+    readonly switchId?: string;
 }
 
 // @public
-export interface VirtualMachineInstancePropertiesOsProfileLinuxConfiguration {
-    disablePasswordAuthentication?: boolean;
-    provisionVMAgent?: boolean;
-    provisionVMConfigAgent?: boolean;
-    ssh?: SshConfiguration;
+export interface SystemData {
+    createdAt?: Date;
+    createdBy?: string;
+    createdByType?: CreatedByType;
+    lastModifiedAt?: Date;
+    lastModifiedBy?: string;
+    lastModifiedByType?: CreatedByType;
 }
 
 // @public
-export interface VirtualMachineInstancePropertiesOsProfileWindowsConfiguration {
-    enableAutomaticUpdates?: boolean;
-    provisionVMAgent?: boolean;
-    provisionVMConfigAgent?: boolean;
-    ssh?: SshConfiguration;
-    timeZone?: string;
+export interface TrackedResource extends Resource {
+    location: string;
+    tags?: {
+        [propertyName: string]: string;
+    };
 }
 
 // @public
-export interface VirtualMachineInstancePropertiesSecurityProfile {
-    // (undocumented)
-    enableTPM?: boolean;
-    securityType?: SecurityTypes;
+export interface Update extends ProxyResource {
+    additionalProperties?: string;
+    availabilityType?: AvailabilityType;
+    componentVersions?: PackageVersionInfo[];
+    description?: string;
+    displayName?: string;
+    healthCheckDate?: Date;
+    healthCheckResult?: PrecheckResult[];
+    healthState?: HealthState;
+    installedDate?: Date;
+    location?: string;
+    minSbeVersionRequired?: string;
+    notifyMessage?: string;
+    packagePath?: string;
+    packageSizeInMb?: number;
+    packageType?: string;
+    prerequisites?: UpdatePrerequisite[];
+    progressPercentage?: number;
+    readonly provisioningState?: ProvisioningState;
+    publisher?: string;
     // (undocumented)
-    uefiSettings?: VirtualMachineInstancePropertiesSecurityProfileUefiSettings;
+    rebootRequired?: RebootRequirement;
+    releaseLink?: string;
+    state?: State;
+    version?: string;
 }
 
-// @public (undocumented)
-export interface VirtualMachineInstancePropertiesSecurityProfileUefiSettings {
-    secureBootEnabled?: boolean;
+// @public
+export interface UpdateList {
+    readonly nextLink?: string;
+    value?: Update[];
 }
 
 // @public
-export interface VirtualMachineInstancePropertiesStorageProfile {
-    dataDisks?: VirtualMachineInstancePropertiesStorageProfileDataDisksItem[];
-    imageReference?: VirtualMachineInstancePropertiesStorageProfileImageReference;
-    osDisk?: VirtualMachineInstancePropertiesStorageProfileOsDisk;
-    vmConfigStoragePathId?: string;
+export interface UpdatePrerequisite {
+    packageName?: string;
+    updateType?: string;
+    version?: string;
 }
 
-// @public (undocumented)
-export interface VirtualMachineInstancePropertiesStorageProfileDataDisksItem {
-    id?: string;
+// @public
+export interface UpdateRun extends ProxyResource {
+    description?: string;
+    duration?: string;
+    endTimeUtc?: Date;
+    errorMessage?: string;
+    expectedExecutionTime?: string;
+    lastUpdatedTime?: Date;
+    lastUpdatedTimeUtc?: Date;
+    location?: string;
+    namePropertiesProgressName?: string;
+    readonly provisioningState?: ProvisioningState;
+    startTimeUtc?: Date;
+    state?: UpdateRunPropertiesState;
+    status?: string;
+    steps?: Step[];
+    timeStarted?: Date;
 }
 
 // @public
-export interface VirtualMachineInstancePropertiesStorageProfileImageReference {
-    id?: string;
+export interface UpdateRunList {
+    readonly nextLink?: string;
+    value?: UpdateRun[];
 }
 
 // @public
-export interface VirtualMachineInstancePropertiesStorageProfileOsDisk {
-    id?: string;
-    osType?: OperatingSystemTypes;
+export type UpdateRunPropertiesState = string;
+
+// @public
+export interface UpdateRuns {
+    beginDelete(resourceGroupName: string, clusterName: string, updateName: string, updateRunName: string, options?: UpdateRunsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
+    beginDeleteAndWait(resourceGroupName: string, clusterName: string, updateName: string, updateRunName: string, options?: UpdateRunsDeleteOptionalParams): Promise<void>;
+    get(resourceGroupName: string, clusterName: string, updateName: string, updateRunName: string, options?: UpdateRunsGetOptionalParams): Promise<UpdateRunsGetResponse>;
+    list(resourceGroupName: string, clusterName: string, updateName: string, options?: UpdateRunsListOptionalParams): PagedAsyncIterableIterator<UpdateRun>;
+    put(resourceGroupName: string, clusterName: string, updateName: string, updateRunName: string, updateRunsProperties: UpdateRun, options?: UpdateRunsPutOptionalParams): Promise<UpdateRunsPutResponse>;
 }
 
 // @public
-export interface VirtualMachineInstances {
-    beginCreateOrUpdate(resourceUri: string, virtualMachineInstance: VirtualMachineInstance, options?: VirtualMachineInstancesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualMachineInstancesCreateOrUpdateResponse>, VirtualMachineInstancesCreateOrUpdateResponse>>;
-    beginCreateOrUpdateAndWait(resourceUri: string, virtualMachineInstance: VirtualMachineInstance, options?: VirtualMachineInstancesCreateOrUpdateOptionalParams): Promise<VirtualMachineInstancesCreateOrUpdateResponse>;
-    beginDelete(resourceUri: string, options?: VirtualMachineInstancesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<VirtualMachineInstancesDeleteResponse>, VirtualMachineInstancesDeleteResponse>>;
-    beginDeleteAndWait(resourceUri: string, options?: VirtualMachineInstancesDeleteOptionalParams): Promise<VirtualMachineInstancesDeleteResponse>;
-    beginRestart(resourceUri: string, options?: VirtualMachineInstancesRestartOptionalParams): Promise<SimplePollerLike<OperationState<VirtualMachineInstancesRestartResponse>, VirtualMachineInstancesRestartResponse>>;
-    beginRestartAndWait(resourceUri: string, options?: VirtualMachineInstancesRestartOptionalParams): Promise<VirtualMachineInstancesRestartResponse>;
-    beginStart(resourceUri: string, options?: VirtualMachineInstancesStartOptionalParams): Promise<SimplePollerLike<OperationState<VirtualMachineInstancesStartResponse>, VirtualMachineInstancesStartResponse>>;
-    beginStartAndWait(resourceUri: string, options?: VirtualMachineInstancesStartOptionalParams): Promise<VirtualMachineInstancesStartResponse>;
-    beginStop(resourceUri: string, options?: VirtualMachineInstancesStopOptionalParams): Promise<SimplePollerLike<OperationState<VirtualMachineInstancesStopResponse>, VirtualMachineInstancesStopResponse>>;
-    beginStopAndWait(resourceUri: string, options?: VirtualMachineInstancesStopOptionalParams): Promise<VirtualMachineInstancesStopResponse>;
-    beginUpdate(resourceUri: string, virtualMachineInstance: VirtualMachineInstanceUpdateRequest, options?: VirtualMachineInstancesUpdateOptionalParams): Promise<SimplePollerLike<OperationState<VirtualMachineInstancesUpdateResponse>, VirtualMachineInstancesUpdateResponse>>;
-    beginUpdateAndWait(resourceUri: string, virtualMachineInstance: VirtualMachineInstanceUpdateRequest, options?: VirtualMachineInstancesUpdateOptionalParams): Promise<VirtualMachineInstancesUpdateResponse>;
-    get(resourceUri: string, options?: VirtualMachineInstancesGetOptionalParams): Promise<VirtualMachineInstancesGetResponse>;
-    list(resourceUri: string, options?: VirtualMachineInstancesListOptionalParams): PagedAsyncIterableIterator<VirtualMachineInstance>;
+export interface UpdateRunsDeleteHeaders {
+    azureAsyncOperation?: string;
 }
 
 // @public
-export interface VirtualMachineInstancesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
+export interface UpdateRunsDeleteOptionalParams extends coreClient.OperationOptions {
     resumeFrom?: string;
     updateIntervalInMs?: number;
 }
 
 // @public
-export type VirtualMachineInstancesCreateOrUpdateResponse = VirtualMachineInstance;
+export interface UpdateRunsGetOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type UpdateRunsGetResponse = UpdateRun;
 
 // @public
-export interface VirtualMachineInstancesDeleteHeaders {
-    // (undocumented)
-    location?: string;
+export interface UpdateRunsListNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface VirtualMachineInstancesDeleteOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export type UpdateRunsListNextResponse = UpdateRunList;
+
+// @public
+export interface UpdateRunsListOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type VirtualMachineInstancesDeleteResponse = VirtualMachineInstancesDeleteHeaders;
+export type UpdateRunsListResponse = UpdateRunList;
 
 // @public
-export interface VirtualMachineInstancesGetOptionalParams extends coreClient.OperationOptions {
+export interface UpdateRunsPutOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type VirtualMachineInstancesGetResponse = VirtualMachineInstance;
+export type UpdateRunsPutResponse = UpdateRun;
 
 // @public
-export interface VirtualMachineInstancesListNextOptionalParams extends coreClient.OperationOptions {
+export interface Updates {
+    beginDelete(resourceGroupName: string, clusterName: string, updateName: string, options?: UpdatesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
+    beginDeleteAndWait(resourceGroupName: string, clusterName: string, updateName: string, options?: UpdatesDeleteOptionalParams): Promise<void>;
+    beginPost(resourceGroupName: string, clusterName: string, updateName: string, options?: UpdatesPostOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
+    beginPostAndWait(resourceGroupName: string, clusterName: string, updateName: string, options?: UpdatesPostOptionalParams): Promise<void>;
+    get(resourceGroupName: string, clusterName: string, updateName: string, options?: UpdatesGetOptionalParams): Promise<UpdatesGetResponse>;
+    list(resourceGroupName: string, clusterName: string, options?: UpdatesListOptionalParams): PagedAsyncIterableIterator<Update>;
+    put(resourceGroupName: string, clusterName: string, updateName: string, updateProperties: Update, options?: UpdatesPutOptionalParams): Promise<UpdatesPutResponse>;
 }
 
 // @public
-export type VirtualMachineInstancesListNextResponse = VirtualMachineInstanceListResult;
+export interface UpdatesDeleteHeaders {
+    azureAsyncOperation?: string;
+}
+
+// @public
+export interface UpdatesDeleteOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
 
 // @public
-export interface VirtualMachineInstancesListOptionalParams extends coreClient.OperationOptions {
+export interface UpdatesGetOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type VirtualMachineInstancesListResponse = VirtualMachineInstanceListResult;
+export type UpdatesGetResponse = Update;
 
 // @public
-export interface VirtualMachineInstancesRestartHeaders {
-    // (undocumented)
-    location?: string;
+export interface UpdatesListNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface VirtualMachineInstancesRestartOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export type UpdatesListNextResponse = UpdateList;
+
+// @public
+export interface UpdatesListOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type VirtualMachineInstancesRestartResponse = VirtualMachineInstance;
+export type UpdatesListResponse = UpdateList;
 
 // @public
-export interface VirtualMachineInstancesStartHeaders {
-    // (undocumented)
-    location?: string;
+export interface UpdatesPostHeaders {
+    azureAsyncOperation?: string;
 }
 
 // @public
-export interface VirtualMachineInstancesStartOptionalParams extends coreClient.OperationOptions {
+export interface UpdatesPostOptionalParams extends coreClient.OperationOptions {
     resumeFrom?: string;
     updateIntervalInMs?: number;
 }
 
 // @public
-export type VirtualMachineInstancesStartResponse = VirtualMachineInstance;
+export interface UpdatesPutOptionalParams extends coreClient.OperationOptions {
+}
 
 // @public
-export interface VirtualMachineInstancesStopHeaders {
-    // (undocumented)
+export type UpdatesPutResponse = Update;
+
+// @public
+export interface UpdateSummaries extends ProxyResource {
+    currentOemVersion?: string;
+    currentSbeVersion?: string;
+    currentVersion?: string;
+    hardwareModel?: string;
+    healthCheckDate?: Date;
+    healthCheckResult?: PrecheckResult[];
+    healthState?: HealthState;
+    lastChecked?: Date;
+    lastUpdated?: Date;
     location?: string;
+    oemFamily?: string;
+    packageVersions?: PackageVersionInfo[];
+    readonly provisioningState?: ProvisioningState;
+    state?: UpdateSummariesPropertiesState;
+}
+
+// @public
+export interface UpdateSummariesDeleteHeaders {
+    azureAsyncOperation?: string;
 }
 
 // @public
-export interface VirtualMachineInstancesStopOptionalParams extends coreClient.OperationOptions {
+export interface UpdateSummariesDeleteOptionalParams extends coreClient.OperationOptions {
     resumeFrom?: string;
     updateIntervalInMs?: number;
 }
 
 // @public
-export type VirtualMachineInstancesStopResponse = VirtualMachineInstance;
+export interface UpdateSummariesGetOptionalParams extends coreClient.OperationOptions {
+}
 
 // @public
-export interface VirtualMachineInstanceStatus {
-    errorCode?: string;
-    errorMessage?: string;
-    powerState?: PowerStateEnum;
-    // (undocumented)
-    provisioningStatus?: VirtualMachineInstanceStatusProvisioningStatus;
+export type UpdateSummariesGetResponse = UpdateSummaries;
+
+// @public
+export interface UpdateSummariesList {
+    readonly nextLink?: string;
+    value?: UpdateSummaries[];
 }
 
-// @public (undocumented)
-export interface VirtualMachineInstanceStatusProvisioningStatus {
-    operationId?: string;
-    status?: Status;
+// @public
+export interface UpdateSummariesListNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface VirtualMachineInstancesUpdateHeaders {
-    // (undocumented)
-    location?: string;
+export type UpdateSummariesListNextResponse = UpdateSummariesList;
+
+// @public
+export interface UpdateSummariesListOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface VirtualMachineInstancesUpdateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export type UpdateSummariesListResponse = UpdateSummariesList;
+
+// @public
+export interface UpdateSummariesOperations {
+    beginDelete(resourceGroupName: string, clusterName: string, options?: UpdateSummariesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
+    beginDeleteAndWait(resourceGroupName: string, clusterName: string, options?: UpdateSummariesDeleteOptionalParams): Promise<void>;
+    get(resourceGroupName: string, clusterName: string, options?: UpdateSummariesGetOptionalParams): Promise<UpdateSummariesGetResponse>;
+    list(resourceGroupName: string, clusterName: string, options?: UpdateSummariesListOptionalParams): PagedAsyncIterableIterator<UpdateSummaries>;
+    put(resourceGroupName: string, clusterName: string, updateLocationProperties: UpdateSummaries, options?: UpdateSummariesPutOptionalParams): Promise<UpdateSummariesPutResponse>;
 }
 
 // @public
-export type VirtualMachineInstancesUpdateResponse = VirtualMachineInstance;
+export type UpdateSummariesPropertiesState = string;
+
+// @public
+export interface UpdateSummariesPutOptionalParams extends coreClient.OperationOptions {
+}
 
 // @public
-export interface VirtualMachineInstanceUpdateProperties {
-    hardwareProfile?: HardwareProfileUpdate;
-    networkProfile?: NetworkProfileUpdate;
-    osProfile?: OsProfileUpdate;
+export type UpdateSummariesPutResponse = UpdateSummaries;
+
+// @public (undocumented)
+export interface UploadCertificateRequest {
     // (undocumented)
-    storageProfile?: StorageProfileUpdate;
+    properties?: RawCertificateData;
+}
+
+// @public
+export interface UserAssignedIdentity {
+    readonly clientId?: string;
+    readonly principalId?: string;
 }
 
 // @public
-export interface VirtualMachineInstanceUpdateRequest {
-    identity?: Identity;
-    properties?: VirtualMachineInstanceUpdateProperties;
+export interface ValidateRequest {
+    additionalInfo?: string;
+    edgeDeviceIds: string[];
 }
 
 // @public
-export interface VirtualMachineInstanceView {
-    vmAgent?: VirtualMachineConfigAgentInstanceView;
+export interface ValidateResponse {
+    readonly status?: string;
 }
 
 // @public
-export type VmSizeEnum = string;
+export type WindowsServerSubscription = string;
 
 // (No @packageDocumentation comment for this package)