@azure/arm-azurestackhci 3.1.1-alpha.20231017.1 → 4.0.0-beta.1

package/review/arm-azurestackhci.api.md

@@ -6,450 +6,468 @@
 
 import * as coreAuth from '@azure/core-auth';
 import * as coreClient from '@azure/core-client';
+import { OperationState } from '@azure/core-lro';
 import { PagedAsyncIterableIterator } from '@azure/core-paging';
-import { PollerLike } from '@azure/core-lro';
-import { PollOperationState } from '@azure/core-lro';
+import { SimplePollerLike } from '@azure/core-lro';
 
 // @public
 export type ActionType = string;
 
-// @public
-export interface ArcConnectivityProperties {
-    enabled?: boolean;
-}
-
-// @public
-export interface ArcIdentityResponse {
+// @public (undocumented)
+export class AzureStackHCIClient extends coreClient.ServiceClient {
+    // (undocumented)
+    $host: string;
+    constructor(credentials: coreAuth.TokenCredential, subscriptionId: string, options?: AzureStackHCIClientOptionalParams);
+    constructor(credentials: coreAuth.TokenCredential, options?: AzureStackHCIClientOptionalParams);
+    // (undocumented)
+    apiVersion: string;
+    // (undocumented)
+    galleryImagesOperations: GalleryImagesOperations;
+    // (undocumented)
+    guestAgentOperations: GuestAgentOperations;
+    // (undocumented)
+    guestAgents: GuestAgents;
+    // (undocumented)
+    hybridIdentityMetadataOperations: HybridIdentityMetadataOperations;
+    // (undocumented)
+    logicalNetworksOperations: LogicalNetworksOperations;
     // (undocumented)
-    arcApplicationClientId?: string;
+    marketplaceGalleryImagesOperations: MarketplaceGalleryImagesOperations;
     // (undocumented)
-    arcApplicationObjectId?: string;
+    networkInterfacesOperations: NetworkInterfacesOperations;
     // (undocumented)
-    arcApplicationTenantId?: string;
+    operations: Operations;
+    // (undocumented)
+    storageContainersOperations: StorageContainersOperations;
+    // (undocumented)
+    subscriptionId?: string;
+    // (undocumented)
+    virtualHardDisksOperations: VirtualHardDisksOperations;
     // (undocumented)
-    arcServicePrincipalObjectId?: string;
+    virtualMachineInstances: VirtualMachineInstances;
 }
 
 // @public
-export interface ArcSetting extends ProxyResource {
-    readonly aggregateState?: ArcSettingAggregateState;
-    arcApplicationClientId?: string;
-    arcApplicationObjectId?: string;
-    arcApplicationTenantId?: string;
-    arcInstanceResourceGroup?: string;
-    arcServicePrincipalObjectId?: string;
-    connectivityProperties?: Record<string, unknown>;
-    createdAt?: Date;
-    createdBy?: string;
-    createdByType?: CreatedByType;
-    lastModifiedAt?: Date;
-    lastModifiedBy?: string;
-    lastModifiedByType?: CreatedByType;
-    readonly perNodeDetails?: PerNodeState[];
-    readonly provisioningState?: ProvisioningState;
+export interface AzureStackHCIClientOptionalParams extends coreClient.ServiceClientOptions {
+    $host?: string;
+    apiVersion?: string;
+    endpoint?: string;
 }
 
 // @public
-export type ArcSettingAggregateState = string;
+export type CloudInitDataSource = string;
 
 // @public
-export interface ArcSettingList {
-    readonly nextLink?: string;
-    readonly value?: ArcSetting[];
+export type CreatedByType = string;
+
+// @public
+export type DiskFileFormat = string;
+
+// @public
+export interface ErrorAdditionalInfo {
+    readonly info?: Record<string, unknown>;
+    readonly type?: string;
 }
 
 // @public
-export interface ArcSettings {
-    beginCreateIdentity(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ArcSettingsCreateIdentityOptionalParams): Promise<PollerLike<PollOperationState<ArcSettingsCreateIdentityResponse>, ArcSettingsCreateIdentityResponse>>;
-    beginCreateIdentityAndWait(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ArcSettingsCreateIdentityOptionalParams): Promise<ArcSettingsCreateIdentityResponse>;
-    beginDelete(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ArcSettingsDeleteOptionalParams): Promise<PollerLike<PollOperationState<void>, void>>;
-    beginDeleteAndWait(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ArcSettingsDeleteOptionalParams): Promise<void>;
-    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>;
+export interface ErrorDetail {
+    readonly additionalInfo?: ErrorAdditionalInfo[];
+    readonly code?: string;
+    readonly details?: ErrorDetail[];
+    readonly message?: string;
+    readonly target?: string;
 }
 
 // @public
-export interface ArcSettingsCreateIdentityOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export interface ErrorResponse {
+    error?: ErrorDetail;
+}
+
+// @public
+export interface ExtendedLocation {
+    name?: string;
+    type?: ExtendedLocationTypes;
 }
 
 // @public
-export type ArcSettingsCreateIdentityResponse = ArcIdentityResponse;
+export type ExtendedLocationTypes = string;
 
 // @public
-export interface ArcSettingsCreateOptionalParams extends coreClient.OperationOptions {
+export interface GalleryDiskImage {
+    readonly sizeInMB?: number;
 }
 
 // @public
-export type ArcSettingsCreateResponse = ArcSetting;
+export interface GalleryImageIdentifier {
+    offer: string;
+    publisher: string;
+    sku: 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;
+}
 
 // @public
-export interface ArcSettingsDeleteOptionalParams extends coreClient.OperationOptions {
+export interface GalleryImagesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
     resumeFrom?: string;
     updateIntervalInMs?: number;
 }
 
 // @public
-export interface ArcSettingsGeneratePasswordOptionalParams extends coreClient.OperationOptions {
+export type GalleryImagesCreateOrUpdateResponse = GalleryImages;
+
+// @public
+export interface GalleryImagesDeleteHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface GalleryImagesDeleteOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
 }
 
 // @public
-export type ArcSettingsGeneratePasswordResponse = PasswordCredential;
+export type GalleryImagesDeleteResponse = GalleryImagesDeleteHeaders;
 
 // @public
-export interface ArcSettingsGetOptionalParams extends coreClient.OperationOptions {
+export interface GalleryImagesGetOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type ArcSettingsGetResponse = ArcSetting;
+export type GalleryImagesGetResponse = GalleryImages;
 
 // @public
-export interface ArcSettingsListByClusterNextOptionalParams extends coreClient.OperationOptions {
+export interface GalleryImagesListAllNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type ArcSettingsListByClusterNextResponse = ArcSettingList;
+export type GalleryImagesListAllNextResponse = GalleryImagesListResult;
 
 // @public
-export interface ArcSettingsListByClusterOptionalParams extends coreClient.OperationOptions {
+export interface GalleryImagesListAllOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type ArcSettingsListByClusterResponse = ArcSettingList;
+export type GalleryImagesListAllResponse = GalleryImagesListResult;
 
 // @public
-export interface ArcSettingsPatch {
-    connectivityProperties?: Record<string, unknown>;
-    tags?: {
-        [propertyName: string]: string;
-    };
+export interface GalleryImagesListNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface ArcSettingsUpdateOptionalParams extends coreClient.OperationOptions {
+export type GalleryImagesListNextResponse = GalleryImagesListResult;
+
+// @public
+export interface GalleryImagesListOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type ArcSettingsUpdateResponse = ArcSetting;
+export type GalleryImagesListResponse = GalleryImagesListResult;
 
-// @public (undocumented)
-export class AzureStackHCIClient extends coreClient.ServiceClient {
-    // (undocumented)
-    $host: string;
-    constructor(credentials: coreAuth.TokenCredential, subscriptionId: string, options?: AzureStackHCIClientOptionalParams);
-    // (undocumented)
-    apiVersion: string;
-    // (undocumented)
-    arcSettings: ArcSettings;
-    // (undocumented)
-    clusters: Clusters;
-    // (undocumented)
-    extensions: Extensions;
-    // (undocumented)
-    operations: Operations;
+// @public
+export interface GalleryImagesListResult {
+    readonly nextLink?: string;
     // (undocumented)
-    subscriptionId: string;
+    value?: GalleryImages[];
 }
 
 // @public
-export interface AzureStackHCIClientOptionalParams extends coreClient.ServiceClientOptions {
-    $host?: string;
-    apiVersion?: string;
-    endpoint?: string;
+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>;
 }
 
 // @public
-export interface Cluster extends TrackedResource {
-    aadApplicationObjectId?: string;
-    aadClientId?: string;
-    aadServicePrincipalObjectId?: string;
-    aadTenantId?: string;
-    readonly billingModel?: string;
-    readonly cloudId?: string;
-    cloudManagementEndpoint?: string;
-    createdAt?: Date;
-    createdBy?: string;
-    createdByType?: CreatedByType;
-    desiredProperties?: ClusterDesiredProperties;
-    readonly lastBillingTimestamp?: Date;
-    lastModifiedAt?: Date;
-    lastModifiedBy?: string;
-    lastModifiedByType?: CreatedByType;
-    readonly lastSyncTimestamp?: Date;
-    readonly provisioningState?: ProvisioningState;
-    readonly registrationTimestamp?: Date;
-    readonly reportedProperties?: ClusterReportedProperties;
-    readonly serviceEndpoint?: string;
-    readonly status?: Status;
-    readonly trialDaysRemaining?: number;
+export interface GalleryImageStatus {
+    downloadStatus?: GalleryImageStatusDownloadStatus;
+    errorCode?: string;
+    errorMessage?: string;
+    progressPercentage?: number;
+    // (undocumented)
+    provisioningStatus?: GalleryImageStatusProvisioningStatus;
 }
 
 // @public
-export interface ClusterDesiredProperties {
-    diagnosticLevel?: DiagnosticLevel;
-    windowsServerSubscription?: WindowsServerSubscription;
+export interface GalleryImageStatusDownloadStatus {
+    downloadSizeInMB?: number;
 }
 
-// @public
-export interface ClusterIdentityResponse {
-    // (undocumented)
-    aadApplicationObjectId?: string;
-    // (undocumented)
-    aadClientId?: string;
-    // (undocumented)
-    aadServicePrincipalObjectId?: string;
-    // (undocumented)
-    aadTenantId?: string;
+// @public (undocumented)
+export interface GalleryImageStatusProvisioningStatus {
+    operationId?: string;
+    status?: Status;
 }
 
 // @public
-export interface ClusterList {
-    readonly nextLink?: string;
-    value?: Cluster[];
+export interface GalleryImagesUpdateHeaders {
+    // (undocumented)
+    location?: string;
 }
 
 // @public
-export interface ClusterNode {
-    readonly coreCount?: number;
-    readonly id?: number;
-    readonly manufacturer?: string;
-    readonly memoryInGiB?: number;
-    readonly model?: string;
-    readonly name?: string;
-    readonly osName?: string;
-    readonly osVersion?: string;
-    readonly serialNumber?: string;
-    readonly windowsServerSubscription?: WindowsServerSubscription;
+export interface GalleryImagesUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
 }
 
 // @public
-export interface ClusterPatch {
-    aadClientId?: string;
-    aadTenantId?: string;
-    cloudManagementEndpoint?: string;
-    desiredProperties?: ClusterDesiredProperties;
+export interface GalleryImagesUpdateRequest {
     tags?: {
         [propertyName: string]: string;
     };
 }
 
 // @public
-export interface ClusterReportedProperties {
-    readonly clusterId?: string;
-    readonly clusterName?: string;
-    readonly clusterVersion?: string;
-    diagnosticLevel?: DiagnosticLevel;
-    readonly imdsAttestation?: ImdsAttestation;
-    readonly lastUpdated?: Date;
-    readonly nodes?: ClusterNode[];
-}
+export type GalleryImagesUpdateResponse = GalleryImages;
 
 // @public
-export interface Clusters {
-    beginCreateIdentity(resourceGroupName: string, clusterName: string, options?: ClustersCreateIdentityOptionalParams): Promise<PollerLike<PollOperationState<ClustersCreateIdentityResponse>, ClustersCreateIdentityResponse>>;
-    beginCreateIdentityAndWait(resourceGroupName: string, clusterName: string, options?: ClustersCreateIdentityOptionalParams): Promise<ClustersCreateIdentityResponse>;
-    beginDelete(resourceGroupName: string, clusterName: string, options?: ClustersDeleteOptionalParams): Promise<PollerLike<PollOperationState<void>, void>>;
-    beginDeleteAndWait(resourceGroupName: string, clusterName: string, options?: ClustersDeleteOptionalParams): Promise<void>;
-    beginUploadCertificate(resourceGroupName: string, clusterName: string, uploadCertificateRequest: UploadCertificateRequest, options?: ClustersUploadCertificateOptionalParams): Promise<PollerLike<PollOperationState<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>;
+export interface GalleryImageVersion {
+    name?: string;
+    storageProfile?: GalleryImageVersionStorageProfile;
 }
 
 // @public
-export interface ClustersCreateIdentityOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export interface GalleryImageVersionStorageProfile {
+    osDiskImage?: GalleryOSDiskImage;
 }
 
 // @public
-export type ClustersCreateIdentityResponse = ClusterIdentityResponse;
+export interface GalleryOSDiskImage extends GalleryDiskImage {
+}
 
 // @public
-export interface ClustersCreateOptionalParams extends coreClient.OperationOptions {
-}
+export function getContinuationToken(page: unknown): string | undefined;
 
 // @public
-export type ClustersCreateResponse = Cluster;
+export interface GuestAgent extends ProxyResource {
+    credentials?: GuestCredential;
+    provisioningAction?: ProvisioningAction;
+    readonly provisioningState?: string;
+    readonly status?: string;
+}
 
 // @public
-export interface ClustersDeleteOptionalParams extends coreClient.OperationOptions {
+export interface GuestAgentCreateOptionalParams extends coreClient.OperationOptions {
+    body?: GuestAgent;
     resumeFrom?: string;
     updateIntervalInMs?: number;
 }
 
 // @public
-export interface ClustersGetOptionalParams extends coreClient.OperationOptions {
-}
+export type GuestAgentCreateResponse = GuestAgent;
 
 // @public
-export type ClustersGetResponse = Cluster;
+export interface GuestAgentDeleteHeaders {
+    // (undocumented)
+    location?: string;
+}
 
 // @public
-export interface ClustersListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
+export interface GuestAgentDeleteOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
 }
 
 // @public
-export type ClustersListByResourceGroupNextResponse = ClusterList;
+export type GuestAgentDeleteResponse = GuestAgentDeleteHeaders;
 
 // @public
-export interface ClustersListByResourceGroupOptionalParams extends coreClient.OperationOptions {
+export interface GuestAgentGetOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type ClustersListByResourceGroupResponse = ClusterList;
+export type GuestAgentGetResponse = GuestAgent;
 
 // @public
-export interface ClustersListBySubscriptionNextOptionalParams extends coreClient.OperationOptions {
+export interface GuestAgentInstallStatus {
+    readonly agentVersion?: string;
+    readonly errorDetails?: ErrorDetail[];
+    readonly lastStatusChange?: Date;
+    readonly status?: StatusTypes;
+    readonly vmUuid?: string;
 }
 
 // @public
-export type ClustersListBySubscriptionNextResponse = ClusterList;
+export interface GuestAgentList {
+    nextLink?: string;
+    value: GuestAgent[];
+}
 
 // @public
-export interface ClustersListBySubscriptionOptionalParams extends coreClient.OperationOptions {
+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>;
 }
 
 // @public
-export type ClustersListBySubscriptionResponse = ClusterList;
+export interface GuestAgents {
+    list(resourceUri: string, options?: GuestAgentsListOptionalParams): PagedAsyncIterableIterator<GuestAgent>;
+}
 
 // @public
-export interface ClustersUpdateOptionalParams extends coreClient.OperationOptions {
+export interface GuestAgentsListNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type ClustersUpdateResponse = Cluster;
+export type GuestAgentsListNextResponse = GuestAgentList;
 
 // @public
-export interface ClustersUploadCertificateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export interface GuestAgentsListOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type CreatedByType = string;
+export type GuestAgentsListResponse = GuestAgentList;
 
 // @public
-export type DiagnosticLevel = string;
+export interface GuestCredential {
+    password?: string;
+    username?: string;
+}
 
 // @public
-export interface ErrorAdditionalInfo {
-    readonly info?: Record<string, unknown>;
-    readonly type?: string;
+export interface HardwareProfileUpdate {
+    memoryMB?: number;
+    processors?: number;
+    // (undocumented)
+    vmSize?: VmSizeEnum;
 }
 
 // @public
-export interface ErrorDetail {
-    readonly additionalInfo?: ErrorAdditionalInfo[];
-    readonly code?: string;
-    readonly details?: ErrorDetail[];
-    readonly message?: string;
-    readonly target?: string;
+export interface HttpProxyConfiguration {
+    httpProxy?: string;
+    httpsProxy?: string;
+    noProxy?: string[];
+    trustedCa?: string;
 }
 
 // @public
-export interface ErrorResponse {
-    error?: ErrorDetail;
+export interface HybridIdentityMetadata extends ProxyResource {
+    readonly identity?: Identity;
+    readonly provisioningState?: string;
+    publicKey?: string;
+    resourceUid?: string;
 }
 
 // @public
-export interface Extension extends ProxyResource {
-    readonly aggregateState?: ExtensionAggregateState;
-    autoUpgradeMinorVersion?: boolean;
-    createdAt?: Date;
-    createdBy?: string;
-    createdByType?: CreatedByType;
-    forceUpdateTag?: string;
-    lastModifiedAt?: Date;
-    lastModifiedBy?: string;
-    lastModifiedByType?: CreatedByType;
-    readonly perNodeExtensionDetails?: PerNodeExtensionState[];
-    protectedSettings?: Record<string, unknown>;
-    readonly provisioningState?: ProvisioningState;
-    publisher?: string;
-    settings?: Record<string, unknown>;
-    typeHandlerVersion?: string;
-    typePropertiesExtensionParametersType?: string;
+export interface HybridIdentityMetadataGetOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type ExtensionAggregateState = string;
+export type HybridIdentityMetadataGetResponse = HybridIdentityMetadata;
 
 // @public
-export interface ExtensionList {
-    readonly nextLink?: string;
-    readonly value?: Extension[];
+export interface HybridIdentityMetadataList {
+    nextLink?: string;
+    value: HybridIdentityMetadata[];
 }
 
 // @public
-export interface Extensions {
-    beginCreate(resourceGroupName: string, clusterName: string, arcSettingName: string, extensionName: string, extension: Extension, options?: ExtensionsCreateOptionalParams): Promise<PollerLike<PollOperationState<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<PollerLike<PollOperationState<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: Extension, options?: ExtensionsUpdateOptionalParams): Promise<PollerLike<PollOperationState<ExtensionsUpdateResponse>, ExtensionsUpdateResponse>>;
-    beginUpdateAndWait(resourceGroupName: string, clusterName: string, arcSettingName: string, extensionName: string, extension: Extension, options?: ExtensionsUpdateOptionalParams): Promise<ExtensionsUpdateResponse>;
-    get(resourceGroupName: string, clusterName: string, arcSettingName: string, extensionName: string, options?: ExtensionsGetOptionalParams): Promise<ExtensionsGetResponse>;
-    listByArcSetting(resourceGroupName: string, clusterName: string, arcSettingName: string, options?: ExtensionsListByArcSettingOptionalParams): PagedAsyncIterableIterator<Extension>;
+export interface HybridIdentityMetadataListNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface ExtensionsCreateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
-}
+export type HybridIdentityMetadataListNextResponse = HybridIdentityMetadataList;
 
 // @public
-export type ExtensionsCreateResponse = Extension;
+export interface HybridIdentityMetadataListOptionalParams extends coreClient.OperationOptions {
+}
 
 // @public
-export interface ExtensionsDeleteOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
-}
+export type HybridIdentityMetadataListResponse = HybridIdentityMetadataList;
 
 // @public
-export interface ExtensionsGetOptionalParams extends coreClient.OperationOptions {
+export interface HybridIdentityMetadataOperations {
+    get(resourceUri: string, options?: HybridIdentityMetadataGetOptionalParams): Promise<HybridIdentityMetadataGetResponse>;
+    list(resourceUri: string, options?: HybridIdentityMetadataListOptionalParams): PagedAsyncIterableIterator<HybridIdentityMetadata>;
 }
 
 // @public
-export type ExtensionsGetResponse = Extension;
+export type HyperVGeneration = string;
 
 // @public
-export interface ExtensionsListByArcSettingNextOptionalParams extends coreClient.OperationOptions {
+export interface Identity {
+    readonly principalId?: string;
+    readonly tenantId?: string;
+    type?: "SystemAssigned";
 }
 
 // @public
-export type ExtensionsListByArcSettingNextResponse = ExtensionList;
+export interface InstanceViewStatus {
+    code?: string;
+    displayStatus?: string;
+    level?: StatusLevelTypes;
+    message?: string;
+    time?: Date;
+}
 
-// @public
-export interface ExtensionsListByArcSettingOptionalParams extends coreClient.OperationOptions {
+// @public (undocumented)
+export interface InterfaceDNSSettings {
+    dnsServers?: string[];
 }
 
 // @public
-export type ExtensionsListByArcSettingResponse = ExtensionList;
+export type IpAllocationMethodEnum = string;
 
 // @public
-export interface ExtensionsUpdateOptionalParams extends coreClient.OperationOptions {
-    resumeFrom?: string;
-    updateIntervalInMs?: number;
+export interface IPConfiguration {
+    name?: string;
+    properties?: IPConfigurationProperties;
 }
 
 // @public
-export type ExtensionsUpdateResponse = Extension;
+export interface IPConfigurationProperties {
+    readonly gateway?: string;
+    readonly prefixLength?: string;
+    privateIPAddress?: string;
+    subnet?: IPConfigurationPropertiesSubnet;
+}
 
 // @public
-export function getContinuationToken(page: unknown): string | undefined;
+export interface IPConfigurationPropertiesSubnet {
+    id?: string;
+}
+
+// @public (undocumented)
+export interface IPPool {
+    end?: string;
+    // (undocumented)
+    info?: IPPoolInfo;
+    ipPoolType?: IPPoolTypeEnum;
+    name?: string;
+    start?: string;
+}
+
+// @public (undocumented)
+export interface IPPoolInfo {
+    readonly available?: string;
+    readonly used?: string;
+}
 
 // @public
-export type ImdsAttestation = string;
+export type IPPoolTypeEnum = "vm" | "vippool";
 
 // @public
 export enum KnownActionType {
@@ -457,22 +475,9 @@ export enum KnownActionType {
 }
 
 // @public
-export enum KnownArcSettingAggregateState {
-    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",
-    Succeeded = "Succeeded",
-    Updating = "Updating"
+export enum KnownCloudInitDataSource {
+    Azure = "Azure",
+    NoCloud = "NoCloud"
 }
 
 // @public
@@ -484,67 +489,26 @@ export enum KnownCreatedByType {
 }
 
 // @public
-export enum KnownDiagnosticLevel {
-    Basic = "Basic",
-    Enhanced = "Enhanced",
-    Off = "Off"
-}
-
-// @public
-export enum KnownExtensionAggregateState {
-    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",
-    Succeeded = "Succeeded",
-    Updating = "Updating"
+export enum KnownDiskFileFormat {
+    Vhd = "vhd",
+    Vhdx = "vhdx"
 }
 
 // @public
-export enum KnownImdsAttestation {
-    Disabled = "Disabled",
-    Enabled = "Enabled"
+export enum KnownExtendedLocationTypes {
+    CustomLocation = "CustomLocation"
 }
 
 // @public
-export enum KnownNodeArcState {
-    Canceled = "Canceled",
-    Connected = "Connected",
-    Creating = "Creating",
-    Deleted = "Deleted",
-    Deleting = "Deleting",
-    Disconnected = "Disconnected",
-    Error = "Error",
-    Failed = "Failed",
-    Moving = "Moving",
-    NotSpecified = "NotSpecified",
-    Succeeded = "Succeeded",
-    Updating = "Updating"
+export enum KnownHyperVGeneration {
+    V1 = "V1",
+    V2 = "V2"
 }
 
 // @public
-export enum KnownNodeExtensionState {
-    Canceled = "Canceled",
-    Connected = "Connected",
-    Creating = "Creating",
-    Deleted = "Deleted",
-    Deleting = "Deleting",
-    Disconnected = "Disconnected",
-    Error = "Error",
-    Failed = "Failed",
-    Moving = "Moving",
-    NotSpecified = "NotSpecified",
-    Succeeded = "Succeeded",
-    Updating = "Updating"
+export enum KnownIpAllocationMethodEnum {
+    Dynamic = "Dynamic",
+    Static = "Static"
 }
 
 // @public
@@ -555,121 +519,782 @@ export enum KnownOrigin {
 }
 
 // @public
-export enum KnownProvisioningState {
+export enum KnownPowerStateEnum {
+    Deallocated = "Deallocated",
+    Deallocating = "Deallocating",
+    Running = "Running",
+    Starting = "Starting",
+    Stopped = "Stopped",
+    Stopping = "Stopping",
+    Unknown = "Unknown"
+}
+
+// @public
+export enum KnownProvisioningAction {
+    Install = "install",
+    Repair = "repair",
+    Uninstall = "uninstall"
+}
+
+// @public
+export enum KnownProvisioningStateEnum {
     Accepted = "Accepted",
     Canceled = "Canceled",
+    Deleting = "Deleting",
     Failed = "Failed",
-    Provisioning = "Provisioning",
+    InProgress = "InProgress",
     Succeeded = "Succeeded"
 }
 
+// @public
+export enum KnownSecurityTypes {
+    ConfidentialVM = "ConfidentialVM",
+    TrustedLaunch = "TrustedLaunch"
+}
+
 // @public
 export enum KnownStatus {
-    ConnectedRecently = "ConnectedRecently",
-    Disconnected = "Disconnected",
-    Error = "Error",
-    NotConnectedRecently = "NotConnectedRecently",
-    NotYetRegistered = "NotYetRegistered"
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Succeeded = "Succeeded"
 }
 
 // @public
-export enum KnownWindowsServerSubscription {
-    Disabled = "Disabled",
-    Enabled = "Enabled"
+export enum KnownStatusLevelTypes {
+    Error = "Error",
+    Info = "Info",
+    Warning = "Warning"
 }
 
 // @public
-export type NodeArcState = string;
+export enum KnownStatusTypes {
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Succeeded = "Succeeded"
+}
 
 // @public
-export type NodeExtensionState = string;
+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 Operation {
-    readonly actionType?: ActionType;
-    display?: OperationDisplay;
-    readonly isDataAction?: boolean;
-    readonly name?: string;
-    readonly origin?: Origin;
+export interface LogicalNetworkPropertiesDhcpOptions {
+    dnsServers?: string[];
 }
 
 // @public
-export interface OperationDisplay {
-    readonly description?: string;
-    readonly operation?: string;
-    readonly provider?: string;
-    readonly resource?: string;
+export interface LogicalNetworks extends TrackedResource {
+    dhcpOptions?: LogicalNetworkPropertiesDhcpOptions;
+    extendedLocation?: ExtendedLocation;
+    readonly provisioningState?: ProvisioningStateEnum;
+    readonly status?: LogicalNetworkStatus;
+    subnets?: Subnet[];
+    vmSwitchName?: string;
 }
 
 // @public
-export interface OperationListResult {
-    readonly nextLink?: string;
-    readonly value?: Operation[];
+export interface LogicalNetworksCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
 }
 
 // @public
-export interface Operations {
-    list(options?: OperationsListOptionalParams): Promise<OperationsListResponse>;
+export type LogicalNetworksCreateOrUpdateResponse = LogicalNetworks;
+
+// @public
+export interface LogicalNetworksDeleteHeaders {
+    // (undocumented)
+    location?: string;
 }
 
 // @public
-export interface OperationsListOptionalParams extends coreClient.OperationOptions {
+export interface LogicalNetworksDeleteOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
 }
 
 // @public
-export type OperationsListResponse = OperationListResult;
+export type LogicalNetworksDeleteResponse = LogicalNetworksDeleteHeaders;
 
 // @public
-export type Origin = string;
+export interface LogicalNetworksGetOptionalParams extends coreClient.OperationOptions {
+}
 
-// @public (undocumented)
-export interface PasswordCredential {
-    // (undocumented)
-    endDateTime?: Date;
-    // (undocumented)
-    keyId?: string;
-    // (undocumented)
-    secretText?: string;
-    // (undocumented)
-    startDateTime?: Date;
+// @public
+export type LogicalNetworksGetResponse = LogicalNetworks;
+
+// @public
+export interface LogicalNetworksListAllNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface PerNodeExtensionState {
-    readonly extension?: string;
-    readonly name?: string;
-    readonly state?: NodeExtensionState;
+export type LogicalNetworksListAllNextResponse = LogicalNetworksListResult;
+
+// @public
+export interface LogicalNetworksListAllOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export interface PerNodeState {
-    readonly arcInstance?: string;
-    readonly name?: string;
-    readonly state?: NodeArcState;
+export type LogicalNetworksListAllResponse = LogicalNetworksListResult;
+
+// @public
+export interface LogicalNetworksListNextOptionalParams extends coreClient.OperationOptions {
 }
 
 // @public
-export type ProvisioningState = string;
+export type LogicalNetworksListNextResponse = LogicalNetworksListResult;
 
 // @public
-export interface ProxyResource extends Resource {
+export interface LogicalNetworksListOptionalParams extends coreClient.OperationOptions {
 }
 
+// @public
+export type LogicalNetworksListResponse = LogicalNetworksListResult;
+
 // @public (undocumented)
-export interface RawCertificateData {
+export interface LogicalNetworksListResult {
+    // (undocumented)
+    nextLink?: string;
     // (undocumented)
-    certificates?: string[];
+    value?: LogicalNetworks[];
 }
 
 // @public
-export interface Resource {
-    readonly id?: string;
-    readonly name?: string;
-    readonly type?: string;
+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>;
 }
 
 // @public
-export type Status = string;
+export interface LogicalNetworkStatus {
+    errorCode?: string;
+    errorMessage?: string;
+    // (undocumented)
+    provisioningStatus?: LogicalNetworkStatusProvisioningStatus;
+}
+
+// @public (undocumented)
+export interface LogicalNetworkStatusProvisioningStatus {
+    operationId?: string;
+    status?: Status;
+}
+
+// @public
+export interface LogicalNetworksUpdateHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface LogicalNetworksUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export interface LogicalNetworksUpdateRequest {
+    tags?: {
+        [propertyName: string]: string;
+    };
+}
+
+// @public
+export type LogicalNetworksUpdateResponse = LogicalNetworks;
+
+// @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;
+}
+
+// @public
+export interface MarketplaceGalleryImagesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type MarketplaceGalleryImagesCreateOrUpdateResponse = MarketplaceGalleryImages;
+
+// @public
+export interface MarketplaceGalleryImagesDeleteHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface MarketplaceGalleryImagesDeleteOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type MarketplaceGalleryImagesDeleteResponse = MarketplaceGalleryImagesDeleteHeaders;
+
+// @public
+export interface MarketplaceGalleryImagesGetOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type MarketplaceGalleryImagesGetResponse = MarketplaceGalleryImages;
+
+// @public
+export interface MarketplaceGalleryImagesListAllNextOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type MarketplaceGalleryImagesListAllNextResponse = MarketplaceGalleryImagesListResult;
+
+// @public
+export interface MarketplaceGalleryImagesListAllOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type MarketplaceGalleryImagesListAllResponse = MarketplaceGalleryImagesListResult;
+
+// @public
+export interface MarketplaceGalleryImagesListNextOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type MarketplaceGalleryImagesListNextResponse = MarketplaceGalleryImagesListResult;
+
+// @public
+export interface MarketplaceGalleryImagesListOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type MarketplaceGalleryImagesListResponse = MarketplaceGalleryImagesListResult;
+
+// @public (undocumented)
+export interface MarketplaceGalleryImagesListResult {
+    // (undocumented)
+    nextLink?: string;
+    // (undocumented)
+    value?: MarketplaceGalleryImages[];
+}
+
+// @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>;
+}
+
+// @public
+export interface MarketplaceGalleryImageStatus {
+    downloadStatus?: MarketplaceGalleryImageStatusDownloadStatus;
+    errorCode?: string;
+    errorMessage?: string;
+    progressPercentage?: number;
+    // (undocumented)
+    provisioningStatus?: MarketplaceGalleryImageStatusProvisioningStatus;
+}
+
+// @public
+export interface MarketplaceGalleryImageStatusDownloadStatus {
+    downloadSizeInMB?: number;
+}
+
+// @public (undocumented)
+export interface MarketplaceGalleryImageStatusProvisioningStatus {
+    operationId?: string;
+    status?: Status;
+}
+
+// @public
+export interface MarketplaceGalleryImagesUpdateHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface MarketplaceGalleryImagesUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export interface MarketplaceGalleryImagesUpdateRequest {
+    tags?: {
+        [propertyName: string]: string;
+    };
+}
+
+// @public
+export type MarketplaceGalleryImagesUpdateResponse = MarketplaceGalleryImages;
+
+// @public
+export interface NetworkInterfaces extends TrackedResource {
+    dnsSettings?: InterfaceDNSSettings;
+    extendedLocation?: ExtendedLocation;
+    ipConfigurations?: IPConfiguration[];
+    macAddress?: string;
+    readonly provisioningState?: ProvisioningStateEnum;
+    readonly status?: NetworkInterfaceStatus;
+}
+
+// @public
+export interface NetworkInterfacesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type NetworkInterfacesCreateOrUpdateResponse = NetworkInterfaces;
+
+// @public
+export interface NetworkInterfacesDeleteHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface NetworkInterfacesDeleteOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type NetworkInterfacesDeleteResponse = NetworkInterfacesDeleteHeaders;
+
+// @public
+export interface NetworkInterfacesGetOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type NetworkInterfacesGetResponse = NetworkInterfaces;
+
+// @public
+export interface NetworkInterfacesListAllNextOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type NetworkInterfacesListAllNextResponse = NetworkInterfacesListResult;
+
+// @public
+export interface NetworkInterfacesListAllOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type NetworkInterfacesListAllResponse = NetworkInterfacesListResult;
+
+// @public
+export interface NetworkInterfacesListNextOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type NetworkInterfacesListNextResponse = NetworkInterfacesListResult;
+
+// @public
+export interface NetworkInterfacesListOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type NetworkInterfacesListResponse = NetworkInterfacesListResult;
+
+// @public (undocumented)
+export interface NetworkInterfacesListResult {
+    // (undocumented)
+    nextLink?: string;
+    // (undocumented)
+    value?: NetworkInterfaces[];
+}
+
+// @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>;
+}
+
+// @public
+export interface NetworkInterfaceStatus {
+    errorCode?: string;
+    errorMessage?: string;
+    // (undocumented)
+    provisioningStatus?: NetworkInterfaceStatusProvisioningStatus;
+}
+
+// @public (undocumented)
+export interface NetworkInterfaceStatusProvisioningStatus {
+    operationId?: string;
+    status?: Status;
+}
+
+// @public
+export interface NetworkInterfacesUpdateHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface NetworkInterfacesUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export interface NetworkInterfacesUpdateRequest {
+    tags?: {
+        [propertyName: string]: string;
+    };
+}
+
+// @public
+export type NetworkInterfacesUpdateResponse = NetworkInterfaces;
+
+// @public
+export interface NetworkProfileUpdate {
+    networkInterfaces?: NetworkProfileUpdateNetworkInterfacesItem[];
+}
+
+// @public (undocumented)
+export interface NetworkProfileUpdateNetworkInterfacesItem {
+    id?: string;
+}
+
+// @public
+export type OperatingSystemTypes = "Windows" | "Linux";
+
+// @public
+export interface Operation {
+    readonly actionType?: ActionType;
+    display?: OperationDisplay;
+    readonly isDataAction?: boolean;
+    readonly name?: string;
+    readonly origin?: Origin;
+}
+
+// @public
+export interface OperationDisplay {
+    readonly description?: string;
+    readonly operation?: string;
+    readonly provider?: string;
+    readonly resource?: string;
+}
+
+// @public
+export interface OperationListResult {
+    readonly nextLink?: string;
+    readonly value?: Operation[];
+}
+
+// @public
+export interface Operations {
+    list(options?: OperationsListOptionalParams): PagedAsyncIterableIterator<Operation>;
+}
+
+// @public
+export interface OperationsListNextOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type OperationsListNextResponse = OperationListResult;
+
+// @public
+export interface OperationsListOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type OperationsListResponse = OperationListResult;
+
+// @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;
+}
+
+// @public (undocumented)
+export interface OsProfileUpdateWindowsConfiguration {
+    provisionVMAgent?: boolean;
+    provisionVMConfigAgent?: boolean;
+}
+
+// @public
+export type PowerStateEnum = string;
+
+// @public
+export type ProvisioningAction = string;
+
+// @public
+export type ProvisioningStateEnum = string;
+
+// @public
+export interface ProxyResource extends Resource {
+}
+
+// @public
+export interface Resource {
+    readonly id?: string;
+    readonly name?: string;
+    readonly systemData?: SystemData;
+    readonly type?: string;
+}
+
+// @public
+export interface Route {
+    addressPrefix?: string;
+    name?: string;
+    nextHopIpAddress?: string;
+}
+
+// @public
+export interface RouteTable {
+    readonly etag?: string;
+    readonly name?: string;
+    routes?: Route[];
+    readonly type?: string;
+}
+
+// @public
+export type SecurityTypes = string;
+
+// @public
+export interface SshConfiguration {
+    publicKeys?: SshPublicKey[];
+}
+
+// @public
+export interface SshPublicKey {
+    keyData?: string;
+    path?: string;
+}
+
+// @public
+export type Status = string;
+
+// @public
+export type StatusLevelTypes = string;
+
+// @public
+export type StatusTypes = string;
+
+// @public
+export interface StorageContainers extends TrackedResource {
+    extendedLocation?: ExtendedLocation;
+    path?: string;
+    readonly provisioningState?: ProvisioningStateEnum;
+    readonly status?: StorageContainerStatus;
+}
+
+// @public
+export interface StorageContainersCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type StorageContainersCreateOrUpdateResponse = StorageContainers;
+
+// @public
+export interface StorageContainersDeleteHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface StorageContainersDeleteOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type StorageContainersDeleteResponse = StorageContainersDeleteHeaders;
+
+// @public
+export interface StorageContainersGetOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type StorageContainersGetResponse = StorageContainers;
+
+// @public
+export interface StorageContainersListAllNextOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type StorageContainersListAllNextResponse = StorageContainersListResult;
+
+// @public
+export interface StorageContainersListAllOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type StorageContainersListAllResponse = StorageContainersListResult;
+
+// @public
+export interface StorageContainersListNextOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type StorageContainersListNextResponse = StorageContainersListResult;
+
+// @public
+export interface StorageContainersListOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type StorageContainersListResponse = StorageContainersListResult;
+
+// @public (undocumented)
+export interface StorageContainersListResult {
+    // (undocumented)
+    nextLink?: string;
+    // (undocumented)
+    value?: StorageContainers[];
+}
+
+// @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>;
+}
+
+// @public
+export interface StorageContainerStatus {
+    availableSizeMB?: number;
+    containerSizeMB?: number;
+    errorCode?: string;
+    errorMessage?: string;
+    // (undocumented)
+    provisioningStatus?: StorageContainerStatusProvisioningStatus;
+}
+
+// @public (undocumented)
+export interface StorageContainerStatusProvisioningStatus {
+    operationId?: string;
+    status?: Status;
+}
+
+// @public
+export interface StorageContainersUpdateHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface StorageContainersUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export interface StorageContainersUpdateRequest {
+    tags?: {
+        [propertyName: string]: string;
+    };
+}
+
+// @public
+export type StorageContainersUpdateResponse = StorageContainers;
+
+// @public (undocumented)
+export interface StorageProfileUpdate {
+    dataDisks?: StorageProfileUpdateDataDisksItem[];
+}
+
+// @public (undocumented)
+export interface StorageProfileUpdateDataDisksItem {
+    // (undocumented)
+    id?: string;
+}
+
+// @public (undocumented)
+export interface Subnet {
+    addressPrefix?: string;
+    addressPrefixes?: string[];
+    ipAllocationMethod?: IpAllocationMethodEnum;
+    ipConfigurationReferences?: SubnetPropertiesFormatIpConfigurationReferencesItem[];
+    ipPools?: IPPool[];
+    name?: string;
+    routeTable?: RouteTable;
+    vlan?: number;
+}
+
+// @public
+export interface SubnetPropertiesFormatIpConfigurationReferencesItem {
+    id?: string;
+}
+
+// @public
+export interface SystemData {
+    createdAt?: Date;
+    createdBy?: string;
+    createdByType?: CreatedByType;
+    lastModifiedAt?: Date;
+    lastModifiedBy?: string;
+    lastModifiedByType?: CreatedByType;
+}
 
 // @public
 export interface TrackedResource extends Resource {
@@ -679,14 +1304,425 @@ export interface TrackedResource extends Resource {
     };
 }
 
+// @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;
+}
+
+// @public
+export interface VirtualHardDisksCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type VirtualHardDisksCreateOrUpdateResponse = VirtualHardDisks;
+
+// @public
+export interface VirtualHardDisksDeleteHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface VirtualHardDisksDeleteOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type VirtualHardDisksDeleteResponse = VirtualHardDisksDeleteHeaders;
+
+// @public
+export interface VirtualHardDisksGetOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type VirtualHardDisksGetResponse = VirtualHardDisks;
+
+// @public
+export interface VirtualHardDisksListAllNextOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type VirtualHardDisksListAllNextResponse = VirtualHardDisksListResult;
+
+// @public
+export interface VirtualHardDisksListAllOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type VirtualHardDisksListAllResponse = VirtualHardDisksListResult;
+
+// @public
+export interface VirtualHardDisksListNextOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type VirtualHardDisksListNextResponse = VirtualHardDisksListResult;
+
+// @public
+export interface VirtualHardDisksListOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type VirtualHardDisksListResponse = VirtualHardDisksListResult;
+
+// @public (undocumented)
+export interface VirtualHardDisksListResult {
+    // (undocumented)
+    nextLink?: string;
+    // (undocumented)
+    value?: VirtualHardDisks[];
+}
+
+// @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>;
+}
+
+// @public
+export interface VirtualHardDiskStatus {
+    errorCode?: string;
+    errorMessage?: string;
+    // (undocumented)
+    provisioningStatus?: VirtualHardDiskStatusProvisioningStatus;
+}
+
+// @public (undocumented)
+export interface VirtualHardDiskStatusProvisioningStatus {
+    operationId?: string;
+    status?: Status;
+}
+
+// @public
+export interface VirtualHardDisksUpdateHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface VirtualHardDisksUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export interface VirtualHardDisksUpdateRequest {
+    tags?: {
+        [propertyName: string]: string;
+    };
+}
+
+// @public
+export type VirtualHardDisksUpdateResponse = VirtualHardDisks;
+
+// @public
+export interface VirtualMachineConfigAgentInstanceView {
+    statuses?: InstanceViewStatus[];
+    vmConfigAgentVersion?: 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;
+}
+
+// @public (undocumented)
+export interface VirtualMachineInstanceListResult {
+    // (undocumented)
+    nextLink?: string;
+    // (undocumented)
+    value?: VirtualMachineInstance[];
+}
+
+// @public
+export interface VirtualMachineInstancePropertiesHardwareProfile {
+    // (undocumented)
+    dynamicMemoryConfig?: VirtualMachineInstancePropertiesHardwareProfileDynamicMemoryConfig;
+    memoryMB?: number;
+    processors?: number;
+    // (undocumented)
+    vmSize?: VmSizeEnum;
+}
+
+// @public (undocumented)
+export interface VirtualMachineInstancePropertiesHardwareProfileDynamicMemoryConfig {
+    // (undocumented)
+    maximumMemoryMB?: number;
+    // (undocumented)
+    minimumMemoryMB?: number;
+    targetMemoryBuffer?: number;
+}
+
+// @public
+export interface VirtualMachineInstancePropertiesNetworkProfile {
+    networkInterfaces?: VirtualMachineInstancePropertiesNetworkProfileNetworkInterfacesItem[];
+}
+
+// @public (undocumented)
+export interface VirtualMachineInstancePropertiesNetworkProfileNetworkInterfacesItem {
+    id?: string;
+}
+
+// @public
+export interface VirtualMachineInstancePropertiesOsProfile {
+    adminPassword?: string;
+    adminUsername?: string;
+    computerName?: string;
+    linuxConfiguration?: VirtualMachineInstancePropertiesOsProfileLinuxConfiguration;
+    windowsConfiguration?: VirtualMachineInstancePropertiesOsProfileWindowsConfiguration;
+}
+
+// @public
+export interface VirtualMachineInstancePropertiesOsProfileLinuxConfiguration {
+    disablePasswordAuthentication?: boolean;
+    provisionVMAgent?: boolean;
+    provisionVMConfigAgent?: boolean;
+    ssh?: SshConfiguration;
+}
+
+// @public
+export interface VirtualMachineInstancePropertiesOsProfileWindowsConfiguration {
+    enableAutomaticUpdates?: boolean;
+    provisionVMAgent?: boolean;
+    provisionVMConfigAgent?: boolean;
+    ssh?: SshConfiguration;
+    timeZone?: string;
+}
+
+// @public
+export interface VirtualMachineInstancePropertiesSecurityProfile {
+    // (undocumented)
+    enableTPM?: boolean;
+    securityType?: SecurityTypes;
+    // (undocumented)
+    uefiSettings?: VirtualMachineInstancePropertiesSecurityProfileUefiSettings;
+}
+
+// @public (undocumented)
+export interface VirtualMachineInstancePropertiesSecurityProfileUefiSettings {
+    secureBootEnabled?: boolean;
+}
+
+// @public
+export interface VirtualMachineInstancePropertiesStorageProfile {
+    dataDisks?: VirtualMachineInstancePropertiesStorageProfileDataDisksItem[];
+    imageReference?: VirtualMachineInstancePropertiesStorageProfileImageReference;
+    osDisk?: VirtualMachineInstancePropertiesStorageProfileOsDisk;
+    vmConfigStoragePathId?: string;
+}
+
+// @public (undocumented)
+export interface VirtualMachineInstancePropertiesStorageProfileDataDisksItem {
+    id?: string;
+}
+
+// @public
+export interface VirtualMachineInstancePropertiesStorageProfileImageReference {
+    id?: string;
+}
+
+// @public
+export interface VirtualMachineInstancePropertiesStorageProfileOsDisk {
+    id?: string;
+    osType?: OperatingSystemTypes;
+}
+
+// @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>;
+}
+
+// @public
+export interface VirtualMachineInstancesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type VirtualMachineInstancesCreateOrUpdateResponse = VirtualMachineInstance;
+
+// @public
+export interface VirtualMachineInstancesDeleteHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface VirtualMachineInstancesDeleteOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type VirtualMachineInstancesDeleteResponse = VirtualMachineInstancesDeleteHeaders;
+
+// @public
+export interface VirtualMachineInstancesGetOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type VirtualMachineInstancesGetResponse = VirtualMachineInstance;
+
+// @public
+export interface VirtualMachineInstancesListNextOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type VirtualMachineInstancesListNextResponse = VirtualMachineInstanceListResult;
+
+// @public
+export interface VirtualMachineInstancesListOptionalParams extends coreClient.OperationOptions {
+}
+
+// @public
+export type VirtualMachineInstancesListResponse = VirtualMachineInstanceListResult;
+
+// @public
+export interface VirtualMachineInstancesRestartHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface VirtualMachineInstancesRestartOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type VirtualMachineInstancesRestartResponse = VirtualMachineInstance;
+
+// @public
+export interface VirtualMachineInstancesStartHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface VirtualMachineInstancesStartOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type VirtualMachineInstancesStartResponse = VirtualMachineInstance;
+
+// @public
+export interface VirtualMachineInstancesStopHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface VirtualMachineInstancesStopOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type VirtualMachineInstancesStopResponse = VirtualMachineInstance;
+
+// @public
+export interface VirtualMachineInstanceStatus {
+    errorCode?: string;
+    errorMessage?: string;
+    powerState?: PowerStateEnum;
+    // (undocumented)
+    provisioningStatus?: VirtualMachineInstanceStatusProvisioningStatus;
+}
+
 // @public (undocumented)
-export interface UploadCertificateRequest {
+export interface VirtualMachineInstanceStatusProvisioningStatus {
+    operationId?: string;
+    status?: Status;
+}
+
+// @public
+export interface VirtualMachineInstancesUpdateHeaders {
+    // (undocumented)
+    location?: string;
+}
+
+// @public
+export interface VirtualMachineInstancesUpdateOptionalParams extends coreClient.OperationOptions {
+    resumeFrom?: string;
+    updateIntervalInMs?: number;
+}
+
+// @public
+export type VirtualMachineInstancesUpdateResponse = VirtualMachineInstance;
+
+// @public
+export interface VirtualMachineInstanceUpdateProperties {
+    hardwareProfile?: HardwareProfileUpdate;
+    networkProfile?: NetworkProfileUpdate;
+    osProfile?: OsProfileUpdate;
     // (undocumented)
-    properties?: RawCertificateData;
+    storageProfile?: StorageProfileUpdate;
+}
+
+// @public
+export interface VirtualMachineInstanceUpdateRequest {
+    identity?: Identity;
+    properties?: VirtualMachineInstanceUpdateProperties;
+}
+
+// @public
+export interface VirtualMachineInstanceView {
+    vmAgent?: VirtualMachineConfigAgentInstanceView;
 }
 
 // @public
-export type WindowsServerSubscription = string;
+export type VmSizeEnum = string;
 
 // (No @packageDocumentation comment for this package)