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

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

```ts

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 { SimplePollerLike } from '@azure/core-lro';

// @public
export type ActionType = string;

// @public
export interface AllowedEnvironmentType extends Resource {
    readonly displayName?: string;
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface AllowedEnvironmentTypeListResult {
    readonly nextLink?: string;
    readonly value?: AllowedEnvironmentType[];
}

// @public
export interface AttachedNetworkConnection extends Resource {
    readonly domainJoinType?: DomainJoinType;
    readonly healthCheckStatus?: HealthCheckStatus;
    networkConnectionId?: string;
    readonly networkConnectionLocation?: string;
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface AttachedNetworkListResult {
    readonly nextLink?: string;
    readonly value?: AttachedNetworkConnection[];
}

// @public
export interface AttachedNetworks {
    beginCreateOrUpdate(resourceGroupName: string, devCenterName: string, attachedNetworkConnectionName: string, body: AttachedNetworkConnection, options?: AttachedNetworksCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<AttachedNetworksCreateOrUpdateResponse>, AttachedNetworksCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, devCenterName: string, attachedNetworkConnectionName: string, body: AttachedNetworkConnection, options?: AttachedNetworksCreateOrUpdateOptionalParams): Promise<AttachedNetworksCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, devCenterName: string, attachedNetworkConnectionName: string, options?: AttachedNetworksDeleteOptionalParams): Promise<SimplePollerLike<OperationState<AttachedNetworksDeleteResponse>, AttachedNetworksDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, devCenterName: string, attachedNetworkConnectionName: string, options?: AttachedNetworksDeleteOptionalParams): Promise<AttachedNetworksDeleteResponse>;
    getByDevCenter(resourceGroupName: string, devCenterName: string, attachedNetworkConnectionName: string, options?: AttachedNetworksGetByDevCenterOptionalParams): Promise<AttachedNetworksGetByDevCenterResponse>;
    getByProject(resourceGroupName: string, projectName: string, attachedNetworkConnectionName: string, options?: AttachedNetworksGetByProjectOptionalParams): Promise<AttachedNetworksGetByProjectResponse>;
    listByDevCenter(resourceGroupName: string, devCenterName: string, options?: AttachedNetworksListByDevCenterOptionalParams): PagedAsyncIterableIterator<AttachedNetworkConnection>;
    listByProject(resourceGroupName: string, projectName: string, options?: AttachedNetworksListByProjectOptionalParams): PagedAsyncIterableIterator<AttachedNetworkConnection>;
}

// @public
export interface AttachedNetworksCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AttachedNetworksCreateOrUpdateResponse = AttachedNetworkConnection;

// @public
export interface AttachedNetworksDeleteHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface AttachedNetworksDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AttachedNetworksDeleteResponse = AttachedNetworksDeleteHeaders;

// @public
export interface AttachedNetworksGetByDevCenterOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AttachedNetworksGetByDevCenterResponse = AttachedNetworkConnection;

// @public
export interface AttachedNetworksGetByProjectOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AttachedNetworksGetByProjectResponse = AttachedNetworkConnection;

// @public
export interface AttachedNetworksListByDevCenterNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AttachedNetworksListByDevCenterNextResponse = AttachedNetworkListResult;

// @public
export interface AttachedNetworksListByDevCenterOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type AttachedNetworksListByDevCenterResponse = AttachedNetworkListResult;

// @public
export interface AttachedNetworksListByProjectNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AttachedNetworksListByProjectNextResponse = AttachedNetworkListResult;

// @public
export interface AttachedNetworksListByProjectOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type AttachedNetworksListByProjectResponse = AttachedNetworkListResult;

// @public
export interface Capability {
    readonly name?: string;
    readonly value?: string;
}

// @public
export interface Catalog extends Resource {
    adoGit?: GitCatalog;
    readonly connectionState?: CatalogConnectionState;
    gitHub?: GitCatalog;
    readonly lastConnectionTime?: Date;
    readonly lastSyncStats?: SyncStats;
    readonly lastSyncTime?: Date;
    readonly provisioningState?: ProvisioningState;
    readonly syncState?: CatalogSyncState;
    syncType?: CatalogSyncType;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface CatalogConflictError {
    readonly name?: string;
    readonly path?: string;
}

// @public
export type CatalogConnectionState = string;

// @public
export interface CatalogErrorDetails {
    code?: string;
    message?: string;
}

// @public
export type CatalogItemSyncEnableStatus = string;

// @public
export type CatalogItemType = string;

// @public
export interface CatalogListResult {
    readonly nextLink?: string;
    readonly value?: Catalog[];
}

// @public
export interface CatalogProperties extends CatalogUpdateProperties {
    readonly connectionState?: CatalogConnectionState;
    readonly lastConnectionTime?: Date;
    readonly lastSyncStats?: SyncStats;
    readonly lastSyncTime?: Date;
    readonly provisioningState?: ProvisioningState;
    readonly syncState?: CatalogSyncState;
}

// @public
export interface CatalogResourceValidationErrorDetails {
    readonly errors?: CatalogErrorDetails[];
}

// @public
export type CatalogResourceValidationStatus = string;

// @public
export interface Catalogs {
    beginConnect(resourceGroupName: string, devCenterName: string, catalogName: string, options?: CatalogsConnectOptionalParams): Promise<SimplePollerLike<OperationState<CatalogsConnectResponse>, CatalogsConnectResponse>>;
    beginConnectAndWait(resourceGroupName: string, devCenterName: string, catalogName: string, options?: CatalogsConnectOptionalParams): Promise<CatalogsConnectResponse>;
    beginCreateOrUpdate(resourceGroupName: string, devCenterName: string, catalogName: string, body: Catalog, options?: CatalogsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<CatalogsCreateOrUpdateResponse>, CatalogsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, devCenterName: string, catalogName: string, body: Catalog, options?: CatalogsCreateOrUpdateOptionalParams): Promise<CatalogsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, devCenterName: string, catalogName: string, options?: CatalogsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<CatalogsDeleteResponse>, CatalogsDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, devCenterName: string, catalogName: string, options?: CatalogsDeleteOptionalParams): Promise<CatalogsDeleteResponse>;
    beginSync(resourceGroupName: string, devCenterName: string, catalogName: string, options?: CatalogsSyncOptionalParams): Promise<SimplePollerLike<OperationState<CatalogsSyncResponse>, CatalogsSyncResponse>>;
    beginSyncAndWait(resourceGroupName: string, devCenterName: string, catalogName: string, options?: CatalogsSyncOptionalParams): Promise<CatalogsSyncResponse>;
    beginUpdate(resourceGroupName: string, devCenterName: string, catalogName: string, body: CatalogUpdate, options?: CatalogsUpdateOptionalParams): Promise<SimplePollerLike<OperationState<CatalogsUpdateResponse>, CatalogsUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, devCenterName: string, catalogName: string, body: CatalogUpdate, options?: CatalogsUpdateOptionalParams): Promise<CatalogsUpdateResponse>;
    get(resourceGroupName: string, devCenterName: string, catalogName: string, options?: CatalogsGetOptionalParams): Promise<CatalogsGetResponse>;
    getSyncErrorDetails(resourceGroupName: string, devCenterName: string, catalogName: string, options?: CatalogsGetSyncErrorDetailsOptionalParams): Promise<CatalogsGetSyncErrorDetailsResponse>;
    listByDevCenter(resourceGroupName: string, devCenterName: string, options?: CatalogsListByDevCenterOptionalParams): PagedAsyncIterableIterator<Catalog>;
}

// @public
export interface CatalogsConnectHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface CatalogsConnectOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type CatalogsConnectResponse = CatalogsConnectHeaders;

// @public
export interface CatalogsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type CatalogsCreateOrUpdateResponse = Catalog;

// @public
export interface CatalogsDeleteHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface CatalogsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type CatalogsDeleteResponse = CatalogsDeleteHeaders;

// @public
export interface CatalogsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CatalogsGetResponse = Catalog;

// @public
export interface CatalogsGetSyncErrorDetailsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CatalogsGetSyncErrorDetailsResponse = SyncErrorDetails;

// @public
export interface CatalogsListByDevCenterNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CatalogsListByDevCenterNextResponse = CatalogListResult;

// @public
export interface CatalogsListByDevCenterOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type CatalogsListByDevCenterResponse = CatalogListResult;

// @public
export interface CatalogsSyncHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface CatalogsSyncOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type CatalogsSyncResponse = CatalogsSyncHeaders;

// @public
export interface CatalogsUpdateHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface CatalogsUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type CatalogsUpdateResponse = Catalog;

// @public
export interface CatalogSyncError {
    readonly errorDetails?: CatalogErrorDetails[];
    readonly path?: string;
}

// @public
export type CatalogSyncState = string;

// @public
export type CatalogSyncType = string;

// @public
export interface CatalogUpdate {
    adoGit?: GitCatalog;
    gitHub?: GitCatalog;
    syncType?: CatalogSyncType;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface CatalogUpdateProperties {
    adoGit?: GitCatalog;
    gitHub?: GitCatalog;
    syncType?: CatalogSyncType;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface CheckNameAvailability {
    execute(nameAvailabilityRequest: CheckNameAvailabilityRequest, options?: CheckNameAvailabilityExecuteOptionalParams): Promise<CheckNameAvailabilityExecuteResponse>;
}

// @public
export interface CheckNameAvailabilityExecuteOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CheckNameAvailabilityExecuteResponse = CheckNameAvailabilityResponse;

// @public
export type CheckNameAvailabilityReason = string;

// @public
export interface CheckNameAvailabilityRequest {
    name?: string;
    type?: string;
}

// @public
export interface CheckNameAvailabilityResponse {
    message?: string;
    nameAvailable?: boolean;
    reason?: CheckNameAvailabilityReason;
}

// @public
export interface CheckScopedNameAvailability {
    execute(nameAvailabilityRequest: CheckScopedNameAvailabilityRequest, options?: CheckScopedNameAvailabilityExecuteOptionalParams): Promise<CheckScopedNameAvailabilityExecuteResponse>;
}

// @public
export interface CheckScopedNameAvailabilityExecuteOptionalParams extends coreClient.OperationOptions {
}

// @public
export type CheckScopedNameAvailabilityExecuteResponse = CheckNameAvailabilityResponse;

// @public
export interface CheckScopedNameAvailabilityRequest {
    name?: string;
    scope?: string;
    type?: string;
}

// @public
export type CreatedByType = string;

// @public
export interface CustomerManagedKeyEncryption {
    keyEncryptionKeyIdentity?: CustomerManagedKeyEncryptionKeyIdentity;
    keyEncryptionKeyUrl?: string;
}

// @public
export interface CustomerManagedKeyEncryptionKeyIdentity {
    delegatedIdentityClientId?: string;
    identityType?: IdentityType;
    userAssignedIdentityResourceId?: string;
}

// @public
export interface DevBoxDefinition extends TrackedResource {
    readonly activeImageReference?: ImageReference;
    hibernateSupport?: HibernateSupport;
    imageReference?: ImageReference;
    readonly imageValidationErrorDetails?: ImageValidationErrorDetails;
    readonly imageValidationStatus?: ImageValidationStatus;
    osStorageType?: string;
    readonly provisioningState?: ProvisioningState;
    sku?: Sku;
    readonly validationStatus?: CatalogResourceValidationStatus;
}

// @public
export interface DevBoxDefinitionListResult {
    readonly nextLink?: string;
    readonly value?: DevBoxDefinition[];
}

// @public
export interface DevBoxDefinitionProperties extends DevBoxDefinitionUpdateProperties {
    readonly activeImageReference?: ImageReference;
    readonly imageValidationErrorDetails?: ImageValidationErrorDetails;
    readonly imageValidationStatus?: ImageValidationStatus;
    readonly provisioningState?: ProvisioningState;
    readonly validationStatus?: CatalogResourceValidationStatus;
}

// @public
export interface DevBoxDefinitions {
    beginCreateOrUpdate(resourceGroupName: string, devCenterName: string, devBoxDefinitionName: string, body: DevBoxDefinition, options?: DevBoxDefinitionsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<DevBoxDefinitionsCreateOrUpdateResponse>, DevBoxDefinitionsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, devCenterName: string, devBoxDefinitionName: string, body: DevBoxDefinition, options?: DevBoxDefinitionsCreateOrUpdateOptionalParams): Promise<DevBoxDefinitionsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, devCenterName: string, devBoxDefinitionName: string, options?: DevBoxDefinitionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<DevBoxDefinitionsDeleteResponse>, DevBoxDefinitionsDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, devCenterName: string, devBoxDefinitionName: string, options?: DevBoxDefinitionsDeleteOptionalParams): Promise<DevBoxDefinitionsDeleteResponse>;
    beginUpdate(resourceGroupName: string, devCenterName: string, devBoxDefinitionName: string, body: DevBoxDefinitionUpdate, options?: DevBoxDefinitionsUpdateOptionalParams): Promise<SimplePollerLike<OperationState<DevBoxDefinitionsUpdateResponse>, DevBoxDefinitionsUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, devCenterName: string, devBoxDefinitionName: string, body: DevBoxDefinitionUpdate, options?: DevBoxDefinitionsUpdateOptionalParams): Promise<DevBoxDefinitionsUpdateResponse>;
    get(resourceGroupName: string, devCenterName: string, devBoxDefinitionName: string, options?: DevBoxDefinitionsGetOptionalParams): Promise<DevBoxDefinitionsGetResponse>;
    getByProject(resourceGroupName: string, projectName: string, devBoxDefinitionName: string, options?: DevBoxDefinitionsGetByProjectOptionalParams): Promise<DevBoxDefinitionsGetByProjectResponse>;
    listByDevCenter(resourceGroupName: string, devCenterName: string, options?: DevBoxDefinitionsListByDevCenterOptionalParams): PagedAsyncIterableIterator<DevBoxDefinition>;
    listByProject(resourceGroupName: string, projectName: string, options?: DevBoxDefinitionsListByProjectOptionalParams): PagedAsyncIterableIterator<DevBoxDefinition>;
}

// @public
export interface DevBoxDefinitionsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type DevBoxDefinitionsCreateOrUpdateResponse = DevBoxDefinition;

// @public
export interface DevBoxDefinitionsDeleteHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface DevBoxDefinitionsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type DevBoxDefinitionsDeleteResponse = DevBoxDefinitionsDeleteHeaders;

// @public
export interface DevBoxDefinitionsGetByProjectOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DevBoxDefinitionsGetByProjectResponse = DevBoxDefinition;

// @public
export interface DevBoxDefinitionsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DevBoxDefinitionsGetResponse = DevBoxDefinition;

// @public
export interface DevBoxDefinitionsListByDevCenterNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DevBoxDefinitionsListByDevCenterNextResponse = DevBoxDefinitionListResult;

// @public
export interface DevBoxDefinitionsListByDevCenterOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type DevBoxDefinitionsListByDevCenterResponse = DevBoxDefinitionListResult;

// @public
export interface DevBoxDefinitionsListByProjectNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DevBoxDefinitionsListByProjectNextResponse = DevBoxDefinitionListResult;

// @public
export interface DevBoxDefinitionsListByProjectOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type DevBoxDefinitionsListByProjectResponse = DevBoxDefinitionListResult;

// @public
export interface DevBoxDefinitionsUpdateHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface DevBoxDefinitionsUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type DevBoxDefinitionsUpdateResponse = DevBoxDefinition;

// @public
export interface DevBoxDefinitionUpdate extends TrackedResourceUpdate {
    hibernateSupport?: HibernateSupport;
    imageReference?: ImageReference;
    osStorageType?: string;
    sku?: Sku;
}

// @public
export interface DevBoxDefinitionUpdateProperties {
    hibernateSupport?: HibernateSupport;
    imageReference?: ImageReference;
    osStorageType?: string;
    sku?: Sku;
}

// @public
export interface DevCenter extends TrackedResource {
    readonly devCenterUri?: string;
    displayName?: string;
    encryption?: Encryption;
    identity?: ManagedServiceIdentity;
    projectCatalogSettings?: DevCenterProjectCatalogSettings;
    readonly provisioningState?: ProvisioningState;
}

// @public (undocumented)
export class DevCenterClient extends coreClient.ServiceClient {
    // (undocumented)
    $host: string;
    constructor(credentials: coreAuth.TokenCredential, subscriptionId: string, options?: DevCenterClientOptionalParams);
    // (undocumented)
    apiVersion: string;
    // (undocumented)
    attachedNetworks: AttachedNetworks;
    // (undocumented)
    catalogs: Catalogs;
    // (undocumented)
    checkNameAvailability: CheckNameAvailability;
    // (undocumented)
    checkScopedNameAvailability: CheckScopedNameAvailability;
    // (undocumented)
    devBoxDefinitions: DevBoxDefinitions;
    // (undocumented)
    devCenters: DevCenters;
    // (undocumented)
    environmentDefinitions: EnvironmentDefinitions;
    // (undocumented)
    environmentTypes: EnvironmentTypes;
    // (undocumented)
    galleries: Galleries;
    // (undocumented)
    images: Images;
    // (undocumented)
    imageVersions: ImageVersions;
    // (undocumented)
    networkConnections: NetworkConnections;
    // (undocumented)
    operations: Operations;
    // (undocumented)
    operationStatuses: OperationStatuses;
    // (undocumented)
    pools: Pools;
    // (undocumented)
    projectAllowedEnvironmentTypes: ProjectAllowedEnvironmentTypes;
    // (undocumented)
    projectCatalogEnvironmentDefinitions: ProjectCatalogEnvironmentDefinitions;
    // (undocumented)
    projectCatalogs: ProjectCatalogs;
    // (undocumented)
    projectEnvironmentTypes: ProjectEnvironmentTypes;
    // (undocumented)
    projects: Projects;
    // (undocumented)
    schedules: Schedules;
    // (undocumented)
    skus: Skus;
    // (undocumented)
    subscriptionId: string;
    // (undocumented)
    usages: Usages;
}

// @public
export interface DevCenterClientOptionalParams extends coreClient.ServiceClientOptions {
    $host?: string;
    apiVersion?: string;
    endpoint?: string;
}

// @public
export interface DevCenterListResult {
    readonly nextLink?: string;
    readonly value?: DevCenter[];
}

// @public
export interface DevCenterProjectCatalogSettings {
    catalogItemSyncEnableStatus?: CatalogItemSyncEnableStatus;
}

// @public
export interface DevCenterProperties extends DevCenterUpdateProperties {
    readonly devCenterUri?: string;
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface DevCenters {
    beginCreateOrUpdate(resourceGroupName: string, devCenterName: string, body: DevCenter, options?: DevCentersCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<DevCentersCreateOrUpdateResponse>, DevCentersCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, devCenterName: string, body: DevCenter, options?: DevCentersCreateOrUpdateOptionalParams): Promise<DevCentersCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, devCenterName: string, options?: DevCentersDeleteOptionalParams): Promise<SimplePollerLike<OperationState<DevCentersDeleteResponse>, DevCentersDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, devCenterName: string, options?: DevCentersDeleteOptionalParams): Promise<DevCentersDeleteResponse>;
    beginUpdate(resourceGroupName: string, devCenterName: string, body: DevCenterUpdate, options?: DevCentersUpdateOptionalParams): Promise<SimplePollerLike<OperationState<DevCentersUpdateResponse>, DevCentersUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, devCenterName: string, body: DevCenterUpdate, options?: DevCentersUpdateOptionalParams): Promise<DevCentersUpdateResponse>;
    get(resourceGroupName: string, devCenterName: string, options?: DevCentersGetOptionalParams): Promise<DevCentersGetResponse>;
    listByResourceGroup(resourceGroupName: string, options?: DevCentersListByResourceGroupOptionalParams): PagedAsyncIterableIterator<DevCenter>;
    listBySubscription(options?: DevCentersListBySubscriptionOptionalParams): PagedAsyncIterableIterator<DevCenter>;
}

// @public
export interface DevCentersCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type DevCentersCreateOrUpdateResponse = DevCenter;

// @public
export interface DevCentersDeleteHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface DevCentersDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type DevCentersDeleteResponse = DevCentersDeleteHeaders;

// @public
export interface DevCentersGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DevCentersGetResponse = DevCenter;

// @public
export interface DevCenterSku extends Sku {
    readonly capabilities?: Capability[];
    readonly locations?: string[];
    readonly resourceType?: string;
}

// @public
export interface DevCentersListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DevCentersListByResourceGroupNextResponse = DevCenterListResult;

// @public
export interface DevCentersListByResourceGroupOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type DevCentersListByResourceGroupResponse = DevCenterListResult;

// @public
export interface DevCentersListBySubscriptionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DevCentersListBySubscriptionNextResponse = DevCenterListResult;

// @public
export interface DevCentersListBySubscriptionOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type DevCentersListBySubscriptionResponse = DevCenterListResult;

// @public
export interface DevCentersUpdateHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface DevCentersUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type DevCentersUpdateResponse = DevCenter;

// @public
export interface DevCenterUpdate extends TrackedResourceUpdate {
    displayName?: string;
    encryption?: Encryption;
    identity?: ManagedServiceIdentity;
    projectCatalogSettings?: DevCenterProjectCatalogSettings;
}

// @public
export interface DevCenterUpdateProperties {
    displayName?: string;
    encryption?: Encryption;
    projectCatalogSettings?: DevCenterProjectCatalogSettings;
}

// @public
export type DomainJoinType = string;

// @public (undocumented)
export interface Encryption {
    customerManagedKeyEncryption?: CustomerManagedKeyEncryption;
}

// @public
export interface EndpointDependency {
    readonly description?: string;
    readonly domainName?: string;
    readonly endpointDetails?: EndpointDetail[];
}

// @public
export interface EndpointDetail {
    readonly port?: number;
}

// @public
export interface EnvironmentDefinition extends ProxyResource {
    readonly description?: string;
    readonly parameters?: EnvironmentDefinitionParameter[];
    readonly templatePath?: string;
    readonly validationStatus?: CatalogResourceValidationStatus;
}

// @public
export interface EnvironmentDefinitionListResult {
    readonly nextLink?: string;
    readonly value?: EnvironmentDefinition[];
}

// @public
export interface EnvironmentDefinitionParameter {
    readonly description?: string;
    readonly id?: string;
    readonly name?: string;
    readonly readOnly?: boolean;
    readonly required?: boolean;
    readonly type?: ParameterType;
}

// @public
export interface EnvironmentDefinitions {
    get(resourceGroupName: string, devCenterName: string, catalogName: string, environmentDefinitionName: string, options?: EnvironmentDefinitionsGetOptionalParams): Promise<EnvironmentDefinitionsGetResponse>;
    getByProjectCatalog(resourceGroupName: string, projectName: string, catalogName: string, environmentDefinitionName: string, options?: EnvironmentDefinitionsGetByProjectCatalogOptionalParams): Promise<EnvironmentDefinitionsGetByProjectCatalogResponse>;
    getErrorDetails(resourceGroupName: string, devCenterName: string, catalogName: string, environmentDefinitionName: string, options?: EnvironmentDefinitionsGetErrorDetailsOptionalParams): Promise<EnvironmentDefinitionsGetErrorDetailsResponse>;
    listByCatalog(resourceGroupName: string, devCenterName: string, catalogName: string, options?: EnvironmentDefinitionsListByCatalogOptionalParams): PagedAsyncIterableIterator<EnvironmentDefinition>;
    listByProjectCatalog(resourceGroupName: string, projectName: string, catalogName: string, options?: EnvironmentDefinitionsListByProjectCatalogOptionalParams): PagedAsyncIterableIterator<EnvironmentDefinition>;
}

// @public
export interface EnvironmentDefinitionsGetByProjectCatalogOptionalParams extends coreClient.OperationOptions {
}

// @public
export type EnvironmentDefinitionsGetByProjectCatalogResponse = EnvironmentDefinition;

// @public
export interface EnvironmentDefinitionsGetErrorDetailsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type EnvironmentDefinitionsGetErrorDetailsResponse = CatalogResourceValidationErrorDetails;

// @public
export interface EnvironmentDefinitionsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type EnvironmentDefinitionsGetResponse = EnvironmentDefinition;

// @public
export interface EnvironmentDefinitionsListByCatalogNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type EnvironmentDefinitionsListByCatalogNextResponse = EnvironmentDefinitionListResult;

// @public
export interface EnvironmentDefinitionsListByCatalogOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type EnvironmentDefinitionsListByCatalogResponse = EnvironmentDefinitionListResult;

// @public
export interface EnvironmentDefinitionsListByProjectCatalogNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type EnvironmentDefinitionsListByProjectCatalogNextResponse = EnvironmentDefinitionListResult;

// @public
export interface EnvironmentDefinitionsListByProjectCatalogOptionalParams extends coreClient.OperationOptions {
}

// @public
export type EnvironmentDefinitionsListByProjectCatalogResponse = EnvironmentDefinitionListResult;

// @public
export interface EnvironmentRole {
    readonly description?: string;
    readonly roleName?: string;
}

// @public
export interface EnvironmentType extends Resource {
    displayName?: string;
    readonly provisioningState?: ProvisioningState;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export type EnvironmentTypeEnableStatus = string;

// @public
export interface EnvironmentTypeListResult {
    readonly nextLink?: string;
    readonly value?: EnvironmentType[];
}

// @public
export interface EnvironmentTypeProperties extends EnvironmentTypeUpdateProperties {
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface EnvironmentTypes {
    createOrUpdate(resourceGroupName: string, devCenterName: string, environmentTypeName: string, body: EnvironmentType, options?: EnvironmentTypesCreateOrUpdateOptionalParams): Promise<EnvironmentTypesCreateOrUpdateResponse>;
    delete(resourceGroupName: string, devCenterName: string, environmentTypeName: string, options?: EnvironmentTypesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, devCenterName: string, environmentTypeName: string, options?: EnvironmentTypesGetOptionalParams): Promise<EnvironmentTypesGetResponse>;
    listByDevCenter(resourceGroupName: string, devCenterName: string, options?: EnvironmentTypesListByDevCenterOptionalParams): PagedAsyncIterableIterator<EnvironmentType>;
    update(resourceGroupName: string, devCenterName: string, environmentTypeName: string, body: EnvironmentTypeUpdate, options?: EnvironmentTypesUpdateOptionalParams): Promise<EnvironmentTypesUpdateResponse>;
}

// @public
export interface EnvironmentTypesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type EnvironmentTypesCreateOrUpdateResponse = EnvironmentType;

// @public
export interface EnvironmentTypesDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface EnvironmentTypesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type EnvironmentTypesGetResponse = EnvironmentType;

// @public
export interface EnvironmentTypesListByDevCenterNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type EnvironmentTypesListByDevCenterNextResponse = EnvironmentTypeListResult;

// @public
export interface EnvironmentTypesListByDevCenterOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type EnvironmentTypesListByDevCenterResponse = EnvironmentTypeListResult;

// @public
export interface EnvironmentTypesUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type EnvironmentTypesUpdateResponse = EnvironmentType;

// @public
export interface EnvironmentTypeUpdate {
    displayName?: string;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface EnvironmentTypeUpdateProperties {
    displayName?: string;
}

// @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 ErrorResponse {
    error?: ErrorDetail;
}

// @public
export interface Galleries {
    beginCreateOrUpdate(resourceGroupName: string, devCenterName: string, galleryName: string, body: Gallery, options?: GalleriesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<GalleriesCreateOrUpdateResponse>, GalleriesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, devCenterName: string, galleryName: string, body: Gallery, options?: GalleriesCreateOrUpdateOptionalParams): Promise<GalleriesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, devCenterName: string, galleryName: string, options?: GalleriesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<GalleriesDeleteResponse>, GalleriesDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, devCenterName: string, galleryName: string, options?: GalleriesDeleteOptionalParams): Promise<GalleriesDeleteResponse>;
    get(resourceGroupName: string, devCenterName: string, galleryName: string, options?: GalleriesGetOptionalParams): Promise<GalleriesGetResponse>;
    listByDevCenter(resourceGroupName: string, devCenterName: string, options?: GalleriesListByDevCenterOptionalParams): PagedAsyncIterableIterator<Gallery>;
}

// @public
export interface GalleriesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type GalleriesCreateOrUpdateResponse = Gallery;

// @public
export interface GalleriesDeleteHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface GalleriesDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type GalleriesDeleteResponse = GalleriesDeleteHeaders;

// @public
export interface GalleriesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type GalleriesGetResponse = Gallery;

// @public
export interface GalleriesListByDevCenterNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type GalleriesListByDevCenterNextResponse = GalleryListResult;

// @public
export interface GalleriesListByDevCenterOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type GalleriesListByDevCenterResponse = GalleryListResult;

// @public
export interface Gallery extends Resource {
    galleryResourceId?: string;
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface GalleryListResult {
    readonly nextLink?: string;
    readonly value?: Gallery[];
}

// @public
export function getContinuationToken(page: unknown): string | undefined;

// @public
export interface GitCatalog {
    branch?: string;
    path?: string;
    secretIdentifier?: string;
    uri?: string;
}

// @public
export interface HealthCheck {
    readonly additionalDetails?: string;
    readonly displayName?: string;
    readonly endDateTime?: Date;
    readonly errorType?: string;
    readonly recommendedAction?: string;
    readonly startDateTime?: Date;
    readonly status?: HealthCheckStatus;
}

// @public
export type HealthCheckStatus = string;

// @public
export interface HealthCheckStatusDetails extends Resource {
    readonly endDateTime?: Date;
    readonly healthChecks?: HealthCheck[];
    readonly startDateTime?: Date;
}

// @public
export interface HealthCheckStatusDetailsListResult {
    readonly nextLink?: string;
    readonly value?: HealthCheckStatusDetails[];
}

// @public
export type HealthStatus = string;

// @public
export interface HealthStatusDetail {
    readonly code?: string;
    readonly message?: string;
}

// @public
export type HibernateSupport = string;

// @public
export type IdentityType = string;

// @public
interface Image_2 extends ProxyResource {
    readonly description?: string;
    readonly hibernateSupport?: HibernateSupport;
    readonly offer?: string;
    readonly provisioningState?: ProvisioningState;
    readonly publisher?: string;
    readonly recommendedMachineConfiguration?: RecommendedMachineConfiguration;
    readonly sku?: string;
}
export { Image_2 as Image }

// @public
export interface ImageListResult {
    readonly nextLink?: string;
    readonly value?: Image_2[];
}

// @public
export interface ImageReference {
    readonly exactVersion?: string;
    id?: string;
}

// @public
export interface Images {
    get(resourceGroupName: string, devCenterName: string, galleryName: string, imageName: string, options?: ImagesGetOptionalParams): Promise<ImagesGetResponse>;
    listByDevCenter(resourceGroupName: string, devCenterName: string, options?: ImagesListByDevCenterOptionalParams): PagedAsyncIterableIterator<Image_2>;
    listByGallery(resourceGroupName: string, devCenterName: string, galleryName: string, options?: ImagesListByGalleryOptionalParams): PagedAsyncIterableIterator<Image_2>;
}

// @public
export interface ImagesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ImagesGetResponse = Image_2;

// @public
export interface ImagesListByDevCenterNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ImagesListByDevCenterNextResponse = ImageListResult;

// @public
export interface ImagesListByDevCenterOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type ImagesListByDevCenterResponse = ImageListResult;

// @public
export interface ImagesListByGalleryNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ImagesListByGalleryNextResponse = ImageListResult;

// @public
export interface ImagesListByGalleryOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type ImagesListByGalleryResponse = ImageListResult;

// @public
export interface ImageValidationErrorDetails {
    code?: string;
    message?: string;
}

// @public
export type ImageValidationStatus = string;

// @public
export interface ImageVersion extends ProxyResource {
    readonly excludeFromLatest?: boolean;
    readonly namePropertiesName?: string;
    readonly osDiskImageSizeInGb?: number;
    readonly provisioningState?: ProvisioningState;
    readonly publishedDate?: Date;
}

// @public
export interface ImageVersionListResult {
    readonly nextLink?: string;
    readonly value?: ImageVersion[];
}

// @public
export interface ImageVersions {
    get(resourceGroupName: string, devCenterName: string, galleryName: string, imageName: string, versionName: string, options?: ImageVersionsGetOptionalParams): Promise<ImageVersionsGetResponse>;
    listByImage(resourceGroupName: string, devCenterName: string, galleryName: string, imageName: string, options?: ImageVersionsListByImageOptionalParams): PagedAsyncIterableIterator<ImageVersion>;
}

// @public
export interface ImageVersionsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ImageVersionsGetResponse = ImageVersion;

// @public
export interface ImageVersionsListByImageNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ImageVersionsListByImageNextResponse = ImageVersionListResult;

// @public
export interface ImageVersionsListByImageOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ImageVersionsListByImageResponse = ImageVersionListResult;

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

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

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

// @public
export enum KnownCatalogItemType {
    EnvironmentDefinition = "EnvironmentDefinition"
}

// @public
export enum KnownCatalogResourceValidationStatus {
    Failed = "Failed",
    Pending = "Pending",
    Succeeded = "Succeeded",
    Unknown = "Unknown"
}

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

// @public
export enum KnownCatalogSyncType {
    Manual = "Manual",
    Scheduled = "Scheduled"
}

// @public
export enum KnownCheckNameAvailabilityReason {
    AlreadyExists = "AlreadyExists",
    Invalid = "Invalid"
}

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

// @public
export enum KnownDomainJoinType {
    AzureADJoin = "AzureADJoin",
    HybridAzureADJoin = "HybridAzureADJoin"
}

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

// @public
export enum KnownHealthCheckStatus {
    Failed = "Failed",
    Passed = "Passed",
    Pending = "Pending",
    Running = "Running",
    Unknown = "Unknown",
    Warning = "Warning"
}

// @public
export enum KnownHealthStatus {
    Healthy = "Healthy",
    Pending = "Pending",
    Unhealthy = "Unhealthy",
    Unknown = "Unknown",
    Warning = "Warning"
}

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

// @public
export enum KnownIdentityType {
    DelegatedResourceIdentity = "delegatedResourceIdentity",
    SystemAssignedIdentity = "systemAssignedIdentity",
    UserAssignedIdentity = "userAssignedIdentity"
}

// @public
export enum KnownImageValidationStatus {
    Failed = "Failed",
    Pending = "Pending",
    Succeeded = "Succeeded",
    TimedOut = "TimedOut",
    Unknown = "Unknown"
}

// @public
export enum KnownLicenseType {
    WindowsClient = "Windows_Client"
}

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

// @public
export enum KnownManagedServiceIdentityType {
    None = "None",
    SystemAssigned = "SystemAssigned",
    SystemAssignedUserAssigned = "SystemAssigned, UserAssigned",
    UserAssigned = "UserAssigned"
}

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

// @public
export enum KnownParameterType {
    Array = "array",
    Boolean = "boolean",
    Integer = "integer",
    Number = "number",
    Object = "object",
    String = "string"
}

// @public
export enum KnownProvisioningState {
    Accepted = "Accepted",
    Canceled = "Canceled",
    Created = "Created",
    Creating = "Creating",
    Deleted = "Deleted",
    Deleting = "Deleting",
    Failed = "Failed",
    MovingResources = "MovingResources",
    NotSpecified = "NotSpecified",
    RolloutInProgress = "RolloutInProgress",
    Running = "Running",
    StorageProvisioningFailed = "StorageProvisioningFailed",
    Succeeded = "Succeeded",
    TransientFailure = "TransientFailure",
    Updated = "Updated",
    Updating = "Updating"
}

// @public
export enum KnownScheduledFrequency {
    Daily = "Daily"
}

// @public
export enum KnownScheduledType {
    StopDevBox = "StopDevBox"
}

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

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

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

// @public
export enum KnownUsageUnit {
    Count = "Count"
}

// @public
export enum KnownVirtualNetworkType {
    Managed = "Managed",
    Unmanaged = "Unmanaged"
}

// @public
export type LicenseType = string;

// @public
export interface ListUsagesResult {
    readonly nextLink?: string;
    readonly value?: Usage[];
}

// @public
export type LocalAdminStatus = string;

// @public
export interface ManagedServiceIdentity {
    readonly principalId?: string;
    readonly tenantId?: string;
    type: ManagedServiceIdentityType;
    userAssignedIdentities?: {
        [propertyName: string]: UserAssignedIdentity;
    };
}

// @public
export type ManagedServiceIdentityType = string;

// @public
export interface NetworkConnection extends TrackedResource {
    domainJoinType?: DomainJoinType;
    domainName?: string;
    domainPassword?: string;
    domainUsername?: string;
    readonly healthCheckStatus?: HealthCheckStatus;
    networkingResourceGroupName?: string;
    organizationUnit?: string;
    readonly provisioningState?: ProvisioningState;
    subnetId?: string;
}

// @public
export interface NetworkConnectionListResult {
    readonly nextLink?: string;
    readonly value?: NetworkConnection[];
}

// @public
export interface NetworkConnections {
    beginCreateOrUpdate(resourceGroupName: string, networkConnectionName: string, body: NetworkConnection, options?: NetworkConnectionsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NetworkConnectionsCreateOrUpdateResponse>, NetworkConnectionsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, networkConnectionName: string, body: NetworkConnection, options?: NetworkConnectionsCreateOrUpdateOptionalParams): Promise<NetworkConnectionsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, networkConnectionName: string, options?: NetworkConnectionsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<NetworkConnectionsDeleteResponse>, NetworkConnectionsDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, networkConnectionName: string, options?: NetworkConnectionsDeleteOptionalParams): Promise<NetworkConnectionsDeleteResponse>;
    beginRunHealthChecks(resourceGroupName: string, networkConnectionName: string, options?: NetworkConnectionsRunHealthChecksOptionalParams): Promise<SimplePollerLike<OperationState<NetworkConnectionsRunHealthChecksResponse>, NetworkConnectionsRunHealthChecksResponse>>;
    beginRunHealthChecksAndWait(resourceGroupName: string, networkConnectionName: string, options?: NetworkConnectionsRunHealthChecksOptionalParams): Promise<NetworkConnectionsRunHealthChecksResponse>;
    beginUpdate(resourceGroupName: string, networkConnectionName: string, body: NetworkConnectionUpdate, options?: NetworkConnectionsUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NetworkConnectionsUpdateResponse>, NetworkConnectionsUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, networkConnectionName: string, body: NetworkConnectionUpdate, options?: NetworkConnectionsUpdateOptionalParams): Promise<NetworkConnectionsUpdateResponse>;
    get(resourceGroupName: string, networkConnectionName: string, options?: NetworkConnectionsGetOptionalParams): Promise<NetworkConnectionsGetResponse>;
    getHealthDetails(resourceGroupName: string, networkConnectionName: string, options?: NetworkConnectionsGetHealthDetailsOptionalParams): Promise<NetworkConnectionsGetHealthDetailsResponse>;
    listByResourceGroup(resourceGroupName: string, options?: NetworkConnectionsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<NetworkConnection>;
    listBySubscription(options?: NetworkConnectionsListBySubscriptionOptionalParams): PagedAsyncIterableIterator<NetworkConnection>;
    listHealthDetails(resourceGroupName: string, networkConnectionName: string, options?: NetworkConnectionsListHealthDetailsOptionalParams): PagedAsyncIterableIterator<HealthCheckStatusDetails>;
    listOutboundNetworkDependenciesEndpoints(resourceGroupName: string, networkConnectionName: string, options?: NetworkConnectionsListOutboundNetworkDependenciesEndpointsOptionalParams): PagedAsyncIterableIterator<OutboundEnvironmentEndpoint>;
}

// @public
export interface NetworkConnectionsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type NetworkConnectionsCreateOrUpdateResponse = NetworkConnection;

// @public
export interface NetworkConnectionsDeleteHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface NetworkConnectionsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type NetworkConnectionsDeleteResponse = NetworkConnectionsDeleteHeaders;

// @public
export interface NetworkConnectionsGetHealthDetailsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type NetworkConnectionsGetHealthDetailsResponse = HealthCheckStatusDetails;

// @public
export interface NetworkConnectionsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type NetworkConnectionsGetResponse = NetworkConnection;

// @public
export interface NetworkConnectionsListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type NetworkConnectionsListByResourceGroupNextResponse = NetworkConnectionListResult;

// @public
export interface NetworkConnectionsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type NetworkConnectionsListByResourceGroupResponse = NetworkConnectionListResult;

// @public
export interface NetworkConnectionsListBySubscriptionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type NetworkConnectionsListBySubscriptionNextResponse = NetworkConnectionListResult;

// @public
export interface NetworkConnectionsListBySubscriptionOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type NetworkConnectionsListBySubscriptionResponse = NetworkConnectionListResult;

// @public
export interface NetworkConnectionsListHealthDetailsOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type NetworkConnectionsListHealthDetailsResponse = HealthCheckStatusDetailsListResult;

// @public
export interface NetworkConnectionsListOutboundNetworkDependenciesEndpointsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type NetworkConnectionsListOutboundNetworkDependenciesEndpointsNextResponse = OutboundEnvironmentEndpointCollection;

// @public
export interface NetworkConnectionsListOutboundNetworkDependenciesEndpointsOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type NetworkConnectionsListOutboundNetworkDependenciesEndpointsResponse = OutboundEnvironmentEndpointCollection;

// @public
export interface NetworkConnectionsRunHealthChecksHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface NetworkConnectionsRunHealthChecksOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type NetworkConnectionsRunHealthChecksResponse = NetworkConnectionsRunHealthChecksHeaders;

// @public
export interface NetworkConnectionsUpdateHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface NetworkConnectionsUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type NetworkConnectionsUpdateResponse = NetworkConnection;

// @public
export interface NetworkConnectionUpdate extends TrackedResourceUpdate {
    domainName?: string;
    domainPassword?: string;
    domainUsername?: string;
    organizationUnit?: string;
    subnetId?: string;
}

// @public
export interface NetworkConnectionUpdateProperties {
    domainName?: string;
    domainPassword?: string;
    domainUsername?: string;
    organizationUnit?: string;
    subnetId?: string;
}

// @public
export interface NetworkProperties extends NetworkConnectionUpdateProperties {
    domainJoinType: DomainJoinType;
    readonly healthCheckStatus?: HealthCheckStatus;
    networkingResourceGroupName?: string;
    readonly provisioningState?: ProvisioningState;
}

// @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 interface OperationStatus extends OperationStatusResult {
    readonly properties?: Record<string, unknown>;
}

// @public
export interface OperationStatuses {
    get(location: string, operationId: string, options?: OperationStatusesGetOptionalParams): Promise<OperationStatusesGetResponse>;
}

// @public
export interface OperationStatusesGetHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface OperationStatusesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type OperationStatusesGetResponse = OperationStatus;

// @public
export interface OperationStatusResult {
    endTime?: Date;
    error?: ErrorDetail;
    id?: string;
    name?: string;
    operations?: OperationStatusResult[];
    percentComplete?: number;
    readonly resourceId?: string;
    startTime?: Date;
    status: string;
}

// @public
export type Origin = string;

// @public
export interface OutboundEnvironmentEndpoint {
    readonly category?: string;
    readonly endpoints?: EndpointDependency[];
}

// @public
export interface OutboundEnvironmentEndpointCollection {
    nextLink?: string;
    readonly value?: OutboundEnvironmentEndpoint[];
}

// @public
export type ParameterType = string;

// @public
export interface Pool extends TrackedResource {
    readonly devBoxCount?: number;
    devBoxDefinitionName?: string;
    displayName?: string;
    readonly healthStatus?: HealthStatus;
    readonly healthStatusDetails?: HealthStatusDetail[];
    licenseType?: LicenseType;
    localAdministrator?: LocalAdminStatus;
    managedVirtualNetworkRegions?: string[];
    networkConnectionName?: string;
    readonly provisioningState?: ProvisioningState;
    singleSignOnStatus?: SingleSignOnStatus;
    stopOnDisconnect?: StopOnDisconnectConfiguration;
    virtualNetworkType?: VirtualNetworkType;
}

// @public
export interface PoolListResult {
    readonly nextLink?: string;
    readonly value?: Pool[];
}

// @public
export interface PoolProperties extends PoolUpdateProperties {
    readonly devBoxCount?: number;
    readonly healthStatus?: HealthStatus;
    readonly healthStatusDetails?: HealthStatusDetail[];
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface Pools {
    beginCreateOrUpdate(resourceGroupName: string, projectName: string, poolName: string, body: Pool, options?: PoolsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<PoolsCreateOrUpdateResponse>, PoolsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, projectName: string, poolName: string, body: Pool, options?: PoolsCreateOrUpdateOptionalParams): Promise<PoolsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, projectName: string, poolName: string, options?: PoolsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<PoolsDeleteResponse>, PoolsDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, projectName: string, poolName: string, options?: PoolsDeleteOptionalParams): Promise<PoolsDeleteResponse>;
    beginRunHealthChecks(resourceGroupName: string, projectName: string, poolName: string, options?: PoolsRunHealthChecksOptionalParams): Promise<SimplePollerLike<OperationState<PoolsRunHealthChecksResponse>, PoolsRunHealthChecksResponse>>;
    beginRunHealthChecksAndWait(resourceGroupName: string, projectName: string, poolName: string, options?: PoolsRunHealthChecksOptionalParams): Promise<PoolsRunHealthChecksResponse>;
    beginUpdate(resourceGroupName: string, projectName: string, poolName: string, body: PoolUpdate, options?: PoolsUpdateOptionalParams): Promise<SimplePollerLike<OperationState<PoolsUpdateResponse>, PoolsUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, projectName: string, poolName: string, body: PoolUpdate, options?: PoolsUpdateOptionalParams): Promise<PoolsUpdateResponse>;
    get(resourceGroupName: string, projectName: string, poolName: string, options?: PoolsGetOptionalParams): Promise<PoolsGetResponse>;
    listByProject(resourceGroupName: string, projectName: string, options?: PoolsListByProjectOptionalParams): PagedAsyncIterableIterator<Pool>;
}

// @public
export interface PoolsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type PoolsCreateOrUpdateResponse = Pool;

// @public
export interface PoolsDeleteHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface PoolsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type PoolsDeleteResponse = PoolsDeleteHeaders;

// @public
export interface PoolsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PoolsGetResponse = Pool;

// @public
export interface PoolsListByProjectNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PoolsListByProjectNextResponse = PoolListResult;

// @public
export interface PoolsListByProjectOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type PoolsListByProjectResponse = PoolListResult;

// @public
export interface PoolsRunHealthChecksHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface PoolsRunHealthChecksOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type PoolsRunHealthChecksResponse = PoolsRunHealthChecksHeaders;

// @public
export interface PoolsUpdateHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface PoolsUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type PoolsUpdateResponse = Pool;

// @public
export interface PoolUpdate extends TrackedResourceUpdate {
    devBoxDefinitionName?: string;
    displayName?: string;
    licenseType?: LicenseType;
    localAdministrator?: LocalAdminStatus;
    managedVirtualNetworkRegions?: string[];
    networkConnectionName?: string;
    singleSignOnStatus?: SingleSignOnStatus;
    stopOnDisconnect?: StopOnDisconnectConfiguration;
    virtualNetworkType?: VirtualNetworkType;
}

// @public
export interface PoolUpdateProperties {
    devBoxDefinitionName?: string;
    displayName?: string;
    licenseType?: LicenseType;
    localAdministrator?: LocalAdminStatus;
    managedVirtualNetworkRegions?: string[];
    networkConnectionName?: string;
    singleSignOnStatus?: SingleSignOnStatus;
    stopOnDisconnect?: StopOnDisconnectConfiguration;
    virtualNetworkType?: VirtualNetworkType;
}

// @public
export interface Project extends TrackedResource {
    catalogSettings?: ProjectCatalogSettings;
    description?: string;
    devCenterId?: string;
    readonly devCenterUri?: string;
    displayName?: string;
    identity?: ManagedServiceIdentity;
    maxDevBoxesPerUser?: number;
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface ProjectAllowedEnvironmentTypes {
    get(resourceGroupName: string, projectName: string, environmentTypeName: string, options?: ProjectAllowedEnvironmentTypesGetOptionalParams): Promise<ProjectAllowedEnvironmentTypesGetResponse>;
    list(resourceGroupName: string, projectName: string, options?: ProjectAllowedEnvironmentTypesListOptionalParams): PagedAsyncIterableIterator<AllowedEnvironmentType>;
}

// @public
export interface ProjectAllowedEnvironmentTypesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProjectAllowedEnvironmentTypesGetResponse = AllowedEnvironmentType;

// @public
export interface ProjectAllowedEnvironmentTypesListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProjectAllowedEnvironmentTypesListNextResponse = AllowedEnvironmentTypeListResult;

// @public
export interface ProjectAllowedEnvironmentTypesListOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type ProjectAllowedEnvironmentTypesListResponse = AllowedEnvironmentTypeListResult;

// @public
export interface ProjectCatalogEnvironmentDefinitions {
    getErrorDetails(resourceGroupName: string, projectName: string, catalogName: string, environmentDefinitionName: string, options?: ProjectCatalogEnvironmentDefinitionsGetErrorDetailsOptionalParams): Promise<ProjectCatalogEnvironmentDefinitionsGetErrorDetailsResponse>;
}

// @public
export interface ProjectCatalogEnvironmentDefinitionsGetErrorDetailsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProjectCatalogEnvironmentDefinitionsGetErrorDetailsResponse = CatalogResourceValidationErrorDetails;

// @public
export interface ProjectCatalogs {
    beginConnect(resourceGroupName: string, projectName: string, catalogName: string, options?: ProjectCatalogsConnectOptionalParams): Promise<SimplePollerLike<OperationState<ProjectCatalogsConnectResponse>, ProjectCatalogsConnectResponse>>;
    beginConnectAndWait(resourceGroupName: string, projectName: string, catalogName: string, options?: ProjectCatalogsConnectOptionalParams): Promise<ProjectCatalogsConnectResponse>;
    beginCreateOrUpdate(resourceGroupName: string, projectName: string, catalogName: string, body: Catalog, options?: ProjectCatalogsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ProjectCatalogsCreateOrUpdateResponse>, ProjectCatalogsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, projectName: string, catalogName: string, body: Catalog, options?: ProjectCatalogsCreateOrUpdateOptionalParams): Promise<ProjectCatalogsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, projectName: string, catalogName: string, options?: ProjectCatalogsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<ProjectCatalogsDeleteResponse>, ProjectCatalogsDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, projectName: string, catalogName: string, options?: ProjectCatalogsDeleteOptionalParams): Promise<ProjectCatalogsDeleteResponse>;
    beginPatch(resourceGroupName: string, projectName: string, catalogName: string, body: CatalogUpdate, options?: ProjectCatalogsPatchOptionalParams): Promise<SimplePollerLike<OperationState<ProjectCatalogsPatchResponse>, ProjectCatalogsPatchResponse>>;
    beginPatchAndWait(resourceGroupName: string, projectName: string, catalogName: string, body: CatalogUpdate, options?: ProjectCatalogsPatchOptionalParams): Promise<ProjectCatalogsPatchResponse>;
    beginSync(resourceGroupName: string, projectName: string, catalogName: string, options?: ProjectCatalogsSyncOptionalParams): Promise<SimplePollerLike<OperationState<ProjectCatalogsSyncResponse>, ProjectCatalogsSyncResponse>>;
    beginSyncAndWait(resourceGroupName: string, projectName: string, catalogName: string, options?: ProjectCatalogsSyncOptionalParams): Promise<ProjectCatalogsSyncResponse>;
    get(resourceGroupName: string, projectName: string, catalogName: string, options?: ProjectCatalogsGetOptionalParams): Promise<ProjectCatalogsGetResponse>;
    getSyncErrorDetails(resourceGroupName: string, projectName: string, catalogName: string, options?: ProjectCatalogsGetSyncErrorDetailsOptionalParams): Promise<ProjectCatalogsGetSyncErrorDetailsResponse>;
    list(resourceGroupName: string, projectName: string, options?: ProjectCatalogsListOptionalParams): PagedAsyncIterableIterator<Catalog>;
}

// @public
export interface ProjectCatalogsConnectHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface ProjectCatalogsConnectOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ProjectCatalogsConnectResponse = ProjectCatalogsConnectHeaders;

// @public
export interface ProjectCatalogsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ProjectCatalogsCreateOrUpdateResponse = Catalog;

// @public
export interface ProjectCatalogsDeleteHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface ProjectCatalogsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ProjectCatalogsDeleteResponse = ProjectCatalogsDeleteHeaders;

// @public
export interface ProjectCatalogSettings {
    catalogItemSyncTypes?: CatalogItemType[];
}

// @public
export interface ProjectCatalogsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProjectCatalogsGetResponse = Catalog;

// @public
export interface ProjectCatalogsGetSyncErrorDetailsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProjectCatalogsGetSyncErrorDetailsResponse = SyncErrorDetails;

// @public
export interface ProjectCatalogsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProjectCatalogsListNextResponse = CatalogListResult;

// @public
export interface ProjectCatalogsListOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type ProjectCatalogsListResponse = CatalogListResult;

// @public
export interface ProjectCatalogsPatchHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface ProjectCatalogsPatchOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ProjectCatalogsPatchResponse = Catalog;

// @public
export interface ProjectCatalogsSyncHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface ProjectCatalogsSyncOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ProjectCatalogsSyncResponse = ProjectCatalogsSyncHeaders;

// @public
export interface ProjectEnvironmentType extends Resource {
    creatorRoleAssignment?: ProjectEnvironmentTypeUpdatePropertiesCreatorRoleAssignment;
    deploymentTargetId?: string;
    displayName?: string;
    readonly environmentCount?: number;
    identity?: ManagedServiceIdentity;
    location?: string;
    readonly provisioningState?: ProvisioningState;
    status?: EnvironmentTypeEnableStatus;
    tags?: {
        [propertyName: string]: string;
    };
    userRoleAssignments?: {
        [propertyName: string]: UserRoleAssignmentValue;
    };
}

// @public
export interface ProjectEnvironmentTypeListResult {
    readonly nextLink?: string;
    readonly value?: ProjectEnvironmentType[];
}

// @public
export interface ProjectEnvironmentTypeProperties extends ProjectEnvironmentTypeUpdateProperties {
    readonly environmentCount?: number;
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface ProjectEnvironmentTypes {
    createOrUpdate(resourceGroupName: string, projectName: string, environmentTypeName: string, body: ProjectEnvironmentType, options?: ProjectEnvironmentTypesCreateOrUpdateOptionalParams): Promise<ProjectEnvironmentTypesCreateOrUpdateResponse>;
    delete(resourceGroupName: string, projectName: string, environmentTypeName: string, options?: ProjectEnvironmentTypesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, projectName: string, environmentTypeName: string, options?: ProjectEnvironmentTypesGetOptionalParams): Promise<ProjectEnvironmentTypesGetResponse>;
    list(resourceGroupName: string, projectName: string, options?: ProjectEnvironmentTypesListOptionalParams): PagedAsyncIterableIterator<ProjectEnvironmentType>;
    update(resourceGroupName: string, projectName: string, environmentTypeName: string, body: ProjectEnvironmentTypeUpdate, options?: ProjectEnvironmentTypesUpdateOptionalParams): Promise<ProjectEnvironmentTypesUpdateResponse>;
}

// @public
export interface ProjectEnvironmentTypesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProjectEnvironmentTypesCreateOrUpdateResponse = ProjectEnvironmentType;

// @public
export interface ProjectEnvironmentTypesDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface ProjectEnvironmentTypesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProjectEnvironmentTypesGetResponse = ProjectEnvironmentType;

// @public
export interface ProjectEnvironmentTypesListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProjectEnvironmentTypesListNextResponse = ProjectEnvironmentTypeListResult;

// @public
export interface ProjectEnvironmentTypesListOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type ProjectEnvironmentTypesListResponse = ProjectEnvironmentTypeListResult;

// @public
export interface ProjectEnvironmentTypesUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProjectEnvironmentTypesUpdateResponse = ProjectEnvironmentType;

// @public
export interface ProjectEnvironmentTypeUpdate {
    creatorRoleAssignment?: ProjectEnvironmentTypeUpdatePropertiesCreatorRoleAssignment;
    deploymentTargetId?: string;
    displayName?: string;
    identity?: ManagedServiceIdentity;
    status?: EnvironmentTypeEnableStatus;
    tags?: {
        [propertyName: string]: string;
    };
    userRoleAssignments?: {
        [propertyName: string]: UserRoleAssignmentValue;
    };
}

// @public
export interface ProjectEnvironmentTypeUpdateProperties {
    creatorRoleAssignment?: ProjectEnvironmentTypeUpdatePropertiesCreatorRoleAssignment;
    deploymentTargetId?: string;
    displayName?: string;
    status?: EnvironmentTypeEnableStatus;
    userRoleAssignments?: {
        [propertyName: string]: UserRoleAssignmentValue;
    };
}

// @public
export interface ProjectEnvironmentTypeUpdatePropertiesCreatorRoleAssignment {
    roles?: {
        [propertyName: string]: EnvironmentRole;
    };
}

// @public
export interface ProjectListResult {
    readonly nextLink?: string;
    readonly value?: Project[];
}

// @public
export interface ProjectProperties extends ProjectUpdateProperties {
    readonly devCenterUri?: string;
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface Projects {
    beginCreateOrUpdate(resourceGroupName: string, projectName: string, body: Project, options?: ProjectsCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ProjectsCreateOrUpdateResponse>, ProjectsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, projectName: string, body: Project, options?: ProjectsCreateOrUpdateOptionalParams): Promise<ProjectsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, projectName: string, options?: ProjectsDeleteOptionalParams): Promise<SimplePollerLike<OperationState<ProjectsDeleteResponse>, ProjectsDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, projectName: string, options?: ProjectsDeleteOptionalParams): Promise<ProjectsDeleteResponse>;
    beginUpdate(resourceGroupName: string, projectName: string, body: ProjectUpdate, options?: ProjectsUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ProjectsUpdateResponse>, ProjectsUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, projectName: string, body: ProjectUpdate, options?: ProjectsUpdateOptionalParams): Promise<ProjectsUpdateResponse>;
    get(resourceGroupName: string, projectName: string, options?: ProjectsGetOptionalParams): Promise<ProjectsGetResponse>;
    listByResourceGroup(resourceGroupName: string, options?: ProjectsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<Project>;
    listBySubscription(options?: ProjectsListBySubscriptionOptionalParams): PagedAsyncIterableIterator<Project>;
}

// @public
export interface ProjectsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ProjectsCreateOrUpdateResponse = Project;

// @public
export interface ProjectsDeleteHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface ProjectsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ProjectsDeleteResponse = ProjectsDeleteHeaders;

// @public
export interface ProjectsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProjectsGetResponse = Project;

// @public
export interface ProjectsListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProjectsListByResourceGroupNextResponse = ProjectListResult;

// @public
export interface ProjectsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type ProjectsListByResourceGroupResponse = ProjectListResult;

// @public
export interface ProjectsListBySubscriptionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ProjectsListBySubscriptionNextResponse = ProjectListResult;

// @public
export interface ProjectsListBySubscriptionOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type ProjectsListBySubscriptionResponse = ProjectListResult;

// @public
export interface ProjectsUpdateHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface ProjectsUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ProjectsUpdateResponse = Project;

// @public
export interface ProjectUpdate extends TrackedResourceUpdate {
    catalogSettings?: ProjectCatalogSettings;
    description?: string;
    devCenterId?: string;
    displayName?: string;
    identity?: ManagedServiceIdentity;
    maxDevBoxesPerUser?: number;
}

// @public
export interface ProjectUpdateProperties {
    catalogSettings?: ProjectCatalogSettings;
    description?: string;
    devCenterId?: string;
    displayName?: string;
    maxDevBoxesPerUser?: number;
}

// @public
export type ProvisioningState = string;

// @public
export interface ProxyResource extends Resource {
}

// @public
export interface RecommendedMachineConfiguration {
    readonly memory?: ResourceRange;
    readonly vCPUs?: ResourceRange;
}

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

// @public
export interface ResourceRange {
    readonly max?: number;
    readonly min?: number;
}

// @public
export interface Schedule extends Resource {
    frequency?: ScheduledFrequency;
    location?: string;
    readonly provisioningState?: ProvisioningState;
    state?: ScheduleEnableStatus;
    tags?: {
        [propertyName: string]: string;
    };
    time?: string;
    timeZone?: string;
    typePropertiesType?: ScheduledType;
}

// @public
export type ScheduledFrequency = string;

// @public
export type ScheduledType = string;

// @public
export type ScheduleEnableStatus = string;

// @public
export interface ScheduleListResult {
    readonly nextLink?: string;
    readonly value?: Schedule[];
}

// @public
export interface ScheduleProperties extends ScheduleUpdateProperties {
    readonly provisioningState?: ProvisioningState;
}

// @public
export interface Schedules {
    beginCreateOrUpdate(resourceGroupName: string, projectName: string, poolName: string, scheduleName: string, body: Schedule, options?: SchedulesCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<SchedulesCreateOrUpdateResponse>, SchedulesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, projectName: string, poolName: string, scheduleName: string, body: Schedule, options?: SchedulesCreateOrUpdateOptionalParams): Promise<SchedulesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, projectName: string, poolName: string, scheduleName: string, options?: SchedulesDeleteOptionalParams): Promise<SimplePollerLike<OperationState<SchedulesDeleteResponse>, SchedulesDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, projectName: string, poolName: string, scheduleName: string, options?: SchedulesDeleteOptionalParams): Promise<SchedulesDeleteResponse>;
    beginUpdate(resourceGroupName: string, projectName: string, poolName: string, scheduleName: string, body: ScheduleUpdate, options?: SchedulesUpdateOptionalParams): Promise<SimplePollerLike<OperationState<SchedulesUpdateResponse>, SchedulesUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, projectName: string, poolName: string, scheduleName: string, body: ScheduleUpdate, options?: SchedulesUpdateOptionalParams): Promise<SchedulesUpdateResponse>;
    get(resourceGroupName: string, projectName: string, poolName: string, scheduleName: string, options?: SchedulesGetOptionalParams): Promise<SchedulesGetResponse>;
    listByPool(resourceGroupName: string, projectName: string, poolName: string, options?: SchedulesListByPoolOptionalParams): PagedAsyncIterableIterator<Schedule>;
}

// @public
export interface SchedulesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    top?: number;
    updateIntervalInMs?: number;
}

// @public
export type SchedulesCreateOrUpdateResponse = Schedule;

// @public
export interface SchedulesDeleteHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface SchedulesDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    top?: number;
    updateIntervalInMs?: number;
}

// @public
export type SchedulesDeleteResponse = SchedulesDeleteHeaders;

// @public
export interface SchedulesGetOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type SchedulesGetResponse = Schedule;

// @public
export interface SchedulesListByPoolNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type SchedulesListByPoolNextResponse = ScheduleListResult;

// @public
export interface SchedulesListByPoolOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type SchedulesListByPoolResponse = ScheduleListResult;

// @public
export interface SchedulesUpdateHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface SchedulesUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    top?: number;
    updateIntervalInMs?: number;
}

// @public
export type SchedulesUpdateResponse = Schedule;

// @public
export interface ScheduleUpdate {
    frequency?: ScheduledFrequency;
    location?: string;
    state?: ScheduleEnableStatus;
    tags?: {
        [propertyName: string]: string;
    };
    time?: string;
    timeZone?: string;
    type?: ScheduledType;
}

// @public
export interface ScheduleUpdateProperties extends TrackedResourceUpdate {
    frequency?: ScheduledFrequency;
    state?: ScheduleEnableStatus;
    time?: string;
    timeZone?: string;
    type?: ScheduledType;
}

// @public
export type SingleSignOnStatus = string;

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

// @public
export interface SkuListResult {
    readonly nextLink?: string;
    readonly value?: DevCenterSku[];
}

// @public
export interface Skus {
    listBySubscription(options?: SkusListBySubscriptionOptionalParams): PagedAsyncIterableIterator<DevCenterSku>;
}

// @public
export interface SkusListBySubscriptionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type SkusListBySubscriptionNextResponse = SkuListResult;

// @public
export interface SkusListBySubscriptionOptionalParams extends coreClient.OperationOptions {
    top?: number;
}

// @public
export type SkusListBySubscriptionResponse = SkuListResult;

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

// @public
export interface StopOnDisconnectConfiguration {
    gracePeriodMinutes?: number;
    status?: StopOnDisconnectEnableStatus;
}

// @public
export type StopOnDisconnectEnableStatus = string;

// @public
export interface SyncErrorDetails {
    readonly conflicts?: CatalogConflictError[];
    readonly errors?: CatalogSyncError[];
    readonly operationError?: CatalogErrorDetails;
}

// @public
export interface SyncStats {
    readonly added?: number;
    readonly removed?: number;
    syncedCatalogItemTypes?: CatalogItemType[];
    readonly synchronizationErrors?: number;
    readonly unchanged?: number;
    readonly updated?: number;
    readonly validationErrors?: number;
}

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

// @public
export interface TrackedResource extends Resource {
    location: string;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface TrackedResourceUpdate {
    location?: string;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface Usage {
    currentValue?: number;
    id?: string;
    limit?: number;
    name?: UsageName;
    unit?: UsageUnit;
}

// @public
export interface UsageName {
    localizedValue?: string;
    value?: string;
}

// @public
export interface Usages {
    listByLocation(location: string, options?: UsagesListByLocationOptionalParams): PagedAsyncIterableIterator<Usage>;
}

// @public
export interface UsagesListByLocationNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type UsagesListByLocationNextResponse = ListUsagesResult;

// @public
export interface UsagesListByLocationOptionalParams extends coreClient.OperationOptions {
}

// @public
export type UsagesListByLocationResponse = ListUsagesResult;

// @public
export type UsageUnit = string;

// @public
export interface UserAssignedIdentity {
    readonly clientId?: string;
    readonly principalId?: string;
}

// @public
export interface UserRoleAssignmentValue {
    roles?: {
        [propertyName: string]: EnvironmentRole;
    };
}

// @public
export type VirtualNetworkType = string;

// (No @packageDocumentation comment for this package)

```