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

> 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 AccessIdName = string;

// @public
export interface AccessInformationCollection {
    count?: number;
    readonly nextLink?: string;
    readonly value?: AccessInformationContract[];
}

// @public
export interface AccessInformationContract extends ProxyResource {
    enabled?: boolean;
    idPropertiesId?: string;
    principalId?: string;
}

// @public
export interface AccessInformationCreateParameters {
    enabled?: boolean;
    primaryKey?: string;
    principalId?: string;
    secondaryKey?: string;
}

// @public
export interface AccessInformationSecretsContract {
    enabled?: boolean;
    id?: string;
    primaryKey?: string;
    principalId?: string;
    secondaryKey?: string;
}

// @public
export interface AccessInformationUpdateParameters {
    enabled?: boolean;
}

// @public
export type AccessType = string;

// @public
export interface AdditionalLocation {
    disableGateway?: boolean;
    readonly gatewayRegionalUrl?: string;
    location: string;
    natGatewayState?: NatGatewayState;
    readonly outboundPublicIPAddresses?: string[];
    readonly platformVersion?: PlatformVersion;
    readonly privateIPAddresses?: string[];
    readonly publicIPAddresses?: string[];
    publicIpAddressId?: string;
    sku: ApiManagementServiceSkuProperties;
    virtualNetworkConfiguration?: VirtualNetworkConfiguration;
    zones?: string[];
}

// @public
export interface AllPolicies {
    listByService(resourceGroupName: string, serviceName: string, options?: AllPoliciesListByServiceOptionalParams): PagedAsyncIterableIterator<AllPoliciesContract>;
}

// @public
export interface AllPoliciesCollection {
    nextLink?: string;
    value?: AllPoliciesContract[];
}

// @public
export interface AllPoliciesContract extends ProxyResource {
    complianceState?: PolicyComplianceState;
    referencePolicyId?: string;
}

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

// @public
export type AllPoliciesListByServiceNextResponse = AllPoliciesCollection;

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

// @public
export type AllPoliciesListByServiceResponse = AllPoliciesCollection;

// @public
export type AlwaysLog = string;

// @public
export interface Api {
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, parameters: ApiCreateOrUpdateParameter, options?: ApiCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ApiCreateOrUpdateResponse>, ApiCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, apiId: string, parameters: ApiCreateOrUpdateParameter, options?: ApiCreateOrUpdateOptionalParams): Promise<ApiCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, serviceName: string, apiId: string, ifMatch: string, options?: ApiDeleteOptionalParams): Promise<SimplePollerLike<OperationState<ApiDeleteResponse>, ApiDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, serviceName: string, apiId: string, ifMatch: string, options?: ApiDeleteOptionalParams): Promise<ApiDeleteResponse>;
    get(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiGetOptionalParams): Promise<ApiGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiGetEntityTagOptionalParams): Promise<ApiGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: ApiListByServiceOptionalParams): PagedAsyncIterableIterator<ApiContract>;
    listByTags(resourceGroupName: string, serviceName: string, options?: ApiListByTagsOptionalParams): PagedAsyncIterableIterator<TagResourceContract>;
    update(resourceGroupName: string, serviceName: string, apiId: string, ifMatch: string, parameters: ApiUpdateContract, options?: ApiUpdateOptionalParams): Promise<ApiUpdateResponse>;
}

// @public
export interface ApiCollection {
    count?: number;
    readonly nextLink?: string;
    readonly value?: ApiContract[];
}

// @public
export interface ApiContactInformation {
    email?: string;
    name?: string;
    url?: string;
}

// @public
export interface ApiContract extends ProxyResource {
    apiRevision?: string;
    apiRevisionDescription?: string;
    apiType?: ApiType;
    apiVersion?: string;
    apiVersionDescription?: string;
    apiVersionSet?: ApiVersionSetContractDetails;
    apiVersionSetId?: string;
    authenticationSettings?: AuthenticationSettingsContract;
    contact?: ApiContactInformation;
    description?: string;
    displayName?: string;
    isCurrent?: boolean;
    readonly isOnline?: boolean;
    license?: ApiLicenseInformation;
    path?: string;
    protocols?: Protocol[];
    readonly provisioningState?: string;
    serviceUrl?: string;
    sourceApiId?: string;
    subscriptionKeyParameterNames?: SubscriptionKeyParameterNamesContract;
    subscriptionRequired?: boolean;
    termsOfServiceUrl?: string;
}

// @public
export interface ApiContractProperties extends ApiEntityBaseContract {
    apiVersionSet?: ApiVersionSetContractDetails;
    displayName?: string;
    path: string;
    protocols?: Protocol[];
    readonly provisioningState?: string;
    serviceUrl?: string;
    sourceApiId?: string;
}

// @public
export interface ApiContractUpdateProperties extends ApiEntityBaseContract {
    displayName?: string;
    path?: string;
    protocols?: Protocol[];
    serviceUrl?: string;
}

// @public
export interface ApiCreateOrUpdateHeaders {
    azureAsyncOperation?: string;
    eTag?: string;
    location?: string;
}

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

// @public
export interface ApiCreateOrUpdateParameter {
    apiRevision?: string;
    apiRevisionDescription?: string;
    apiType?: ApiType;
    apiVersion?: string;
    apiVersionDescription?: string;
    apiVersionSet?: ApiVersionSetContractDetails;
    apiVersionSetId?: string;
    authenticationSettings?: AuthenticationSettingsContract;
    contact?: ApiContactInformation;
    description?: string;
    displayName?: string;
    format?: ContentFormat;
    isCurrent?: boolean;
    readonly isOnline?: boolean;
    license?: ApiLicenseInformation;
    path?: string;
    protocols?: Protocol[];
    readonly provisioningState?: string;
    serviceUrl?: string;
    soapApiType?: SoapApiType;
    sourceApiId?: string;
    subscriptionKeyParameterNames?: SubscriptionKeyParameterNamesContract;
    subscriptionRequired?: boolean;
    termsOfServiceUrl?: string;
    translateRequiredQueryParametersConduct?: TranslateRequiredQueryParametersConduct;
    value?: string;
    wsdlSelector?: ApiCreateOrUpdatePropertiesWsdlSelector;
}

// @public
export interface ApiCreateOrUpdateProperties extends ApiContractProperties {
    format?: ContentFormat;
    soapApiType?: SoapApiType;
    translateRequiredQueryParametersConduct?: TranslateRequiredQueryParametersConduct;
    value?: string;
    wsdlSelector?: ApiCreateOrUpdatePropertiesWsdlSelector;
}

// @public
export interface ApiCreateOrUpdatePropertiesWsdlSelector {
    wsdlEndpointName?: string;
    wsdlServiceName?: string;
}

// @public
export type ApiCreateOrUpdateResponse = ApiCreateOrUpdateHeaders & ApiContract;

// @public
export interface ApiDeleteHeaders {
    azureAsyncOperation?: string;
    location?: string;
}

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

// @public
export type ApiDeleteResponse = ApiDeleteHeaders;

// @public
export interface ApiDiagnostic {
    createOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, diagnosticId: string, parameters: DiagnosticContract, options?: ApiDiagnosticCreateOrUpdateOptionalParams): Promise<ApiDiagnosticCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, apiId: string, diagnosticId: string, ifMatch: string, options?: ApiDiagnosticDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, apiId: string, diagnosticId: string, options?: ApiDiagnosticGetOptionalParams): Promise<ApiDiagnosticGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, diagnosticId: string, options?: ApiDiagnosticGetEntityTagOptionalParams): Promise<ApiDiagnosticGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiDiagnosticListByServiceOptionalParams): PagedAsyncIterableIterator<DiagnosticContract>;
    update(resourceGroupName: string, serviceName: string, apiId: string, diagnosticId: string, ifMatch: string, parameters: DiagnosticContract, options?: ApiDiagnosticUpdateOptionalParams): Promise<ApiDiagnosticUpdateResponse>;
}

// @public
export interface ApiDiagnosticCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ApiDiagnosticCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ApiDiagnosticCreateOrUpdateResponse = ApiDiagnosticCreateOrUpdateHeaders & DiagnosticContract;

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

// @public
export interface ApiDiagnosticGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ApiDiagnosticGetEntityTagResponse = ApiDiagnosticGetEntityTagHeaders;

// @public
export interface ApiDiagnosticGetHeaders {
    eTag?: string;
}

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

// @public
export type ApiDiagnosticGetResponse = ApiDiagnosticGetHeaders & DiagnosticContract;

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

// @public
export type ApiDiagnosticListByServiceNextResponse = DiagnosticCollection;

// @public
export interface ApiDiagnosticListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ApiDiagnosticListByServiceResponse = DiagnosticCollection;

// @public
export interface ApiDiagnosticUpdateHeaders {
    eTag?: string;
}

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

// @public
export type ApiDiagnosticUpdateResponse = ApiDiagnosticUpdateHeaders & DiagnosticContract;

// @public
export interface ApiEntityBaseContract {
    apiRevision?: string;
    apiRevisionDescription?: string;
    apiType?: ApiType;
    apiVersion?: string;
    apiVersionDescription?: string;
    apiVersionSetId?: string;
    authenticationSettings?: AuthenticationSettingsContract;
    contact?: ApiContactInformation;
    description?: string;
    isCurrent?: boolean;
    readonly isOnline?: boolean;
    license?: ApiLicenseInformation;
    subscriptionKeyParameterNames?: SubscriptionKeyParameterNamesContract;
    subscriptionRequired?: boolean;
    termsOfServiceUrl?: string;
}

// @public
export interface ApiExport {
    get(resourceGroupName: string, serviceName: string, apiId: string, format: ExportFormat, exportParam: ExportApi, options?: ApiExportGetOptionalParams): Promise<ApiExportGetResponse>;
}

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

// @public
export type ApiExportGetResponse = ApiExportResult;

// @public
export interface ApiExportResult {
    exportResultFormat?: ExportResultFormat;
    id?: string;
    value?: ApiExportResultValue;
}

// @public
export interface ApiExportResultValue {
    link?: string;
}

// @public
export interface ApiGateway {
    beginCreateOrUpdate(resourceGroupName: string, gatewayName: string, parameters: ApiManagementGatewayResource, options?: ApiGatewayCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ApiGatewayCreateOrUpdateResponse>, ApiGatewayCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, gatewayName: string, parameters: ApiManagementGatewayResource, options?: ApiGatewayCreateOrUpdateOptionalParams): Promise<ApiGatewayCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, gatewayName: string, options?: ApiGatewayDeleteOptionalParams): Promise<SimplePollerLike<OperationState<ApiGatewayDeleteResponse>, ApiGatewayDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, gatewayName: string, options?: ApiGatewayDeleteOptionalParams): Promise<ApiGatewayDeleteResponse>;
    beginUpdate(resourceGroupName: string, gatewayName: string, parameters: ApiManagementGatewayUpdateParameters, options?: ApiGatewayUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ApiGatewayUpdateResponse>, ApiGatewayUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, gatewayName: string, parameters: ApiManagementGatewayUpdateParameters, options?: ApiGatewayUpdateOptionalParams): Promise<ApiGatewayUpdateResponse>;
    get(resourceGroupName: string, gatewayName: string, options?: ApiGatewayGetOptionalParams): Promise<ApiGatewayGetResponse>;
    list(options?: ApiGatewayListOptionalParams): PagedAsyncIterableIterator<ApiManagementGatewayResource>;
    listByResourceGroup(resourceGroupName: string, options?: ApiGatewayListByResourceGroupOptionalParams): PagedAsyncIterableIterator<ApiManagementGatewayResource>;
}

// @public
export interface ApiGatewayConfigConnection {
    beginCreateOrUpdate(resourceGroupName: string, gatewayName: string, configConnectionName: string, parameters: ApiManagementGatewayConfigConnectionResource, options?: ApiGatewayConfigConnectionCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ApiGatewayConfigConnectionCreateOrUpdateResponse>, ApiGatewayConfigConnectionCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, gatewayName: string, configConnectionName: string, parameters: ApiManagementGatewayConfigConnectionResource, options?: ApiGatewayConfigConnectionCreateOrUpdateOptionalParams): Promise<ApiGatewayConfigConnectionCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, gatewayName: string, configConnectionName: string, ifMatch: string, options?: ApiGatewayConfigConnectionDeleteOptionalParams): Promise<SimplePollerLike<OperationState<ApiGatewayConfigConnectionDeleteResponse>, ApiGatewayConfigConnectionDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, gatewayName: string, configConnectionName: string, ifMatch: string, options?: ApiGatewayConfigConnectionDeleteOptionalParams): Promise<ApiGatewayConfigConnectionDeleteResponse>;
    get(resourceGroupName: string, gatewayName: string, configConnectionName: string, options?: ApiGatewayConfigConnectionGetOptionalParams): Promise<ApiGatewayConfigConnectionGetResponse>;
    listByGateway(resourceGroupName: string, gatewayName: string, options?: ApiGatewayConfigConnectionListByGatewayOptionalParams): PagedAsyncIterableIterator<ApiManagementGatewayConfigConnectionResource>;
}

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

// @public
export type ApiGatewayConfigConnectionCreateOrUpdateResponse = ApiManagementGatewayConfigConnectionResource;

// @public
export interface ApiGatewayConfigConnectionDeleteHeaders {
    location?: string;
}

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

// @public
export type ApiGatewayConfigConnectionDeleteResponse = ApiGatewayConfigConnectionDeleteHeaders;

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

// @public
export type ApiGatewayConfigConnectionGetResponse = ApiManagementGatewayConfigConnectionResource;

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

// @public
export type ApiGatewayConfigConnectionListByGatewayNextResponse = ApiManagementGatewayConfigConnectionListResult;

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

// @public
export type ApiGatewayConfigConnectionListByGatewayResponse = ApiManagementGatewayConfigConnectionListResult;

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

// @public
export type ApiGatewayCreateOrUpdateResponse = ApiManagementGatewayResource;

// @public
export interface ApiGatewayDeleteHeaders {
    location?: string;
}

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

// @public
export type ApiGatewayDeleteResponse = ApiGatewayDeleteHeaders & ApiManagementGatewayResource;

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

// @public
export type ApiGatewayGetResponse = ApiManagementGatewayResource;

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

// @public
export type ApiGatewayListByResourceGroupNextResponse = ApiManagementGatewayListResult;

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

// @public
export type ApiGatewayListByResourceGroupResponse = ApiManagementGatewayListResult;

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

// @public
export type ApiGatewayListNextResponse = ApiManagementGatewayListResult;

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

// @public
export type ApiGatewayListResponse = ApiManagementGatewayListResult;

// @public
export type ApiGatewaySkuType = string;

// @public
export interface ApiGatewayUpdateHeaders {
    location?: string;
}

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

// @public
export type ApiGatewayUpdateResponse = ApiManagementGatewayResource;

// @public
export interface ApiGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ApiGetEntityTagResponse = ApiGetEntityTagHeaders;

// @public
export interface ApiGetHeaders {
    eTag?: string;
}

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

// @public
export type ApiGetResponse = ApiGetHeaders & ApiContract;

// @public
export interface ApiIssue {
    createOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, parameters: IssueContract, options?: ApiIssueCreateOrUpdateOptionalParams): Promise<ApiIssueCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, ifMatch: string, options?: ApiIssueDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, options?: ApiIssueGetOptionalParams): Promise<ApiIssueGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, options?: ApiIssueGetEntityTagOptionalParams): Promise<ApiIssueGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiIssueListByServiceOptionalParams): PagedAsyncIterableIterator<IssueContract>;
    update(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, ifMatch: string, parameters: IssueUpdateContract, options?: ApiIssueUpdateOptionalParams): Promise<ApiIssueUpdateResponse>;
}

// @public
export interface ApiIssueAttachment {
    createOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, attachmentId: string, parameters: IssueAttachmentContract, options?: ApiIssueAttachmentCreateOrUpdateOptionalParams): Promise<ApiIssueAttachmentCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, attachmentId: string, ifMatch: string, options?: ApiIssueAttachmentDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, attachmentId: string, options?: ApiIssueAttachmentGetOptionalParams): Promise<ApiIssueAttachmentGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, attachmentId: string, options?: ApiIssueAttachmentGetEntityTagOptionalParams): Promise<ApiIssueAttachmentGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, options?: ApiIssueAttachmentListByServiceOptionalParams): PagedAsyncIterableIterator<IssueAttachmentContract>;
}

// @public
export interface ApiIssueAttachmentCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ApiIssueAttachmentCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ApiIssueAttachmentCreateOrUpdateResponse = ApiIssueAttachmentCreateOrUpdateHeaders & IssueAttachmentContract;

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

// @public
export interface ApiIssueAttachmentGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ApiIssueAttachmentGetEntityTagResponse = ApiIssueAttachmentGetEntityTagHeaders;

// @public
export interface ApiIssueAttachmentGetHeaders {
    eTag?: string;
}

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

// @public
export type ApiIssueAttachmentGetResponse = ApiIssueAttachmentGetHeaders & IssueAttachmentContract;

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

// @public
export type ApiIssueAttachmentListByServiceNextResponse = IssueAttachmentCollection;

// @public
export interface ApiIssueAttachmentListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ApiIssueAttachmentListByServiceResponse = IssueAttachmentCollection;

// @public
export interface ApiIssueComment {
    createOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, commentId: string, parameters: IssueCommentContract, options?: ApiIssueCommentCreateOrUpdateOptionalParams): Promise<ApiIssueCommentCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, commentId: string, ifMatch: string, options?: ApiIssueCommentDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, commentId: string, options?: ApiIssueCommentGetOptionalParams): Promise<ApiIssueCommentGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, commentId: string, options?: ApiIssueCommentGetEntityTagOptionalParams): Promise<ApiIssueCommentGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, apiId: string, issueId: string, options?: ApiIssueCommentListByServiceOptionalParams): PagedAsyncIterableIterator<IssueCommentContract>;
}

// @public
export interface ApiIssueCommentCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ApiIssueCommentCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ApiIssueCommentCreateOrUpdateResponse = ApiIssueCommentCreateOrUpdateHeaders & IssueCommentContract;

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

// @public
export interface ApiIssueCommentGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ApiIssueCommentGetEntityTagResponse = ApiIssueCommentGetEntityTagHeaders;

// @public
export interface ApiIssueCommentGetHeaders {
    eTag?: string;
}

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

// @public
export type ApiIssueCommentGetResponse = ApiIssueCommentGetHeaders & IssueCommentContract;

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

// @public
export type ApiIssueCommentListByServiceNextResponse = IssueCommentCollection;

// @public
export interface ApiIssueCommentListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ApiIssueCommentListByServiceResponse = IssueCommentCollection;

// @public
export interface ApiIssueCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ApiIssueCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ApiIssueCreateOrUpdateResponse = ApiIssueCreateOrUpdateHeaders & IssueContract;

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

// @public
export interface ApiIssueGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ApiIssueGetEntityTagResponse = ApiIssueGetEntityTagHeaders;

// @public
export interface ApiIssueGetHeaders {
    eTag?: string;
}

// @public
export interface ApiIssueGetOptionalParams extends coreClient.OperationOptions {
    expandCommentsAttachments?: boolean;
}

// @public
export type ApiIssueGetResponse = ApiIssueGetHeaders & IssueContract;

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

// @public
export type ApiIssueListByServiceNextResponse = IssueCollection;

// @public
export interface ApiIssueListByServiceOptionalParams extends coreClient.OperationOptions {
    expandCommentsAttachments?: boolean;
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ApiIssueListByServiceResponse = IssueCollection;

// @public
export interface ApiIssueUpdateHeaders {
    eTag?: string;
}

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

// @public
export type ApiIssueUpdateResponse = ApiIssueUpdateHeaders & IssueContract;

// @public
export interface ApiLicenseInformation {
    name?: string;
    url?: string;
}

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

// @public
export type ApiListByServiceNextResponse = ApiCollection;

// @public
export interface ApiListByServiceOptionalParams extends coreClient.OperationOptions {
    expandApiVersionSet?: boolean;
    filter?: string;
    skip?: number;
    tags?: string;
    top?: number;
}

// @public
export type ApiListByServiceResponse = ApiCollection;

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

// @public
export type ApiListByTagsNextResponse = TagResourceCollection;

// @public
export interface ApiListByTagsOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    includeNotTaggedApis?: boolean;
    skip?: number;
    top?: number;
}

// @public
export type ApiListByTagsResponse = TagResourceCollection;

// @public (undocumented)
export class ApiManagementClient extends coreClient.ServiceClient {
    // (undocumented)
    $host: string;
    constructor(credentials: coreAuth.TokenCredential, subscriptionId: string, options?: ApiManagementClientOptionalParams);
    constructor(credentials: coreAuth.TokenCredential, options?: ApiManagementClientOptionalParams);
    // (undocumented)
    allPolicies: AllPolicies;
    // (undocumented)
    api: Api;
    // (undocumented)
    apiDiagnostic: ApiDiagnostic;
    // (undocumented)
    apiExport: ApiExport;
    // (undocumented)
    apiGateway: ApiGateway;
    // (undocumented)
    apiGatewayConfigConnection: ApiGatewayConfigConnection;
    // (undocumented)
    apiIssue: ApiIssue;
    // (undocumented)
    apiIssueAttachment: ApiIssueAttachment;
    // (undocumented)
    apiIssueComment: ApiIssueComment;
    // (undocumented)
    apiManagementGatewaySkus: ApiManagementGatewaySkus;
    // (undocumented)
    apiManagementOperations: ApiManagementOperations;
    // (undocumented)
    apiManagementService: ApiManagementService;
    // (undocumented)
    apiManagementServiceSkus: ApiManagementServiceSkus;
    // (undocumented)
    apiManagementSkus: ApiManagementSkus;
    // (undocumented)
    apiManagementWorkspaceLink: ApiManagementWorkspaceLink;
    // (undocumented)
    apiManagementWorkspaceLinks: ApiManagementWorkspaceLinks;
    // (undocumented)
    apiOperation: ApiOperation;
    // (undocumented)
    apiOperationPolicy: ApiOperationPolicy;
    // (undocumented)
    apiPolicy: ApiPolicy;
    // (undocumented)
    apiProduct: ApiProduct;
    // (undocumented)
    apiRelease: ApiRelease;
    // (undocumented)
    apiRevision: ApiRevision;
    // (undocumented)
    apiSchema: ApiSchema;
    // (undocumented)
    apiTagDescription: ApiTagDescription;
    // (undocumented)
    apiVersion: string;
    // (undocumented)
    apiVersionSet: ApiVersionSet;
    // (undocumented)
    apiWiki: ApiWiki;
    // (undocumented)
    apiWikis: ApiWikis;
    // (undocumented)
    authorization: Authorization;
    // (undocumented)
    authorizationAccessPolicy: AuthorizationAccessPolicy;
    // (undocumented)
    authorizationLoginLinks: AuthorizationLoginLinks;
    // (undocumented)
    authorizationProvider: AuthorizationProvider;
    // (undocumented)
    authorizationServer: AuthorizationServer;
    // (undocumented)
    backend: Backend;
    beginPerformConnectivityCheckAsync(resourceGroupName: string, serviceName: string, connectivityCheckRequestParams: ConnectivityCheckRequest, options?: PerformConnectivityCheckAsyncOptionalParams): Promise<SimplePollerLike<OperationState<PerformConnectivityCheckAsyncResponse>, PerformConnectivityCheckAsyncResponse>>;
    beginPerformConnectivityCheckAsyncAndWait(resourceGroupName: string, serviceName: string, connectivityCheckRequestParams: ConnectivityCheckRequest, options?: PerformConnectivityCheckAsyncOptionalParams): Promise<PerformConnectivityCheckAsyncResponse>;
    // (undocumented)
    cache: Cache_2;
    // (undocumented)
    certificate: Certificate;
    // (undocumented)
    contentItem: ContentItem;
    // (undocumented)
    contentType: ContentType;
    // (undocumented)
    delegationSettings: DelegationSettings;
    // (undocumented)
    deletedServices: DeletedServices;
    // (undocumented)
    diagnostic: Diagnostic;
    // (undocumented)
    documentation: Documentation;
    // (undocumented)
    emailTemplate: EmailTemplate;
    // (undocumented)
    gateway: Gateway;
    // (undocumented)
    gatewayApi: GatewayApi;
    // (undocumented)
    gatewayCertificateAuthority: GatewayCertificateAuthority;
    // (undocumented)
    gatewayHostnameConfiguration: GatewayHostnameConfiguration;
    // (undocumented)
    globalSchema: GlobalSchema;
    // (undocumented)
    graphQLApiResolver: GraphQLApiResolver;
    // (undocumented)
    graphQLApiResolverPolicy: GraphQLApiResolverPolicy;
    // (undocumented)
    group: Group;
    // (undocumented)
    groupUser: GroupUser;
    // (undocumented)
    identityProvider: IdentityProvider;
    // (undocumented)
    issue: Issue;
    // (undocumented)
    logger: Logger;
    // (undocumented)
    namedValue: NamedValue;
    // (undocumented)
    networkStatus: NetworkStatus;
    // (undocumented)
    notification: Notification_2;
    // (undocumented)
    notificationRecipientEmail: NotificationRecipientEmail;
    // (undocumented)
    notificationRecipientUser: NotificationRecipientUser;
    // (undocumented)
    openIdConnectProvider: OpenIdConnectProvider;
    // (undocumented)
    operationOperations: OperationOperations;
    // (undocumented)
    operationsResults: OperationsResults;
    // (undocumented)
    operationStatus: OperationStatus;
    // (undocumented)
    outboundNetworkDependenciesEndpoints: OutboundNetworkDependenciesEndpoints;
    // (undocumented)
    policy: Policy;
    // (undocumented)
    policyDescription: PolicyDescription;
    // (undocumented)
    policyFragment: PolicyFragment;
    // (undocumented)
    policyRestriction: PolicyRestriction;
    // (undocumented)
    policyRestrictionValidations: PolicyRestrictionValidations;
    // (undocumented)
    portalConfig: PortalConfig;
    // (undocumented)
    portalRevision: PortalRevision;
    // (undocumented)
    portalSettings: PortalSettings;
    // (undocumented)
    privateEndpointConnectionOperations: PrivateEndpointConnectionOperations;
    // (undocumented)
    product: Product;
    // (undocumented)
    productApi: ProductApi;
    // (undocumented)
    productApiLink: ProductApiLink;
    // (undocumented)
    productGroup: ProductGroup;
    // (undocumented)
    productGroupLink: ProductGroupLink;
    // (undocumented)
    productPolicy: ProductPolicy;
    // (undocumented)
    productSubscriptions: ProductSubscriptions;
    // (undocumented)
    productWiki: ProductWiki;
    // (undocumented)
    productWikis: ProductWikis;
    // (undocumented)
    quotaByCounterKeys: QuotaByCounterKeys;
    // (undocumented)
    quotaByPeriodKeys: QuotaByPeriodKeys;
    // (undocumented)
    region: Region;
    // (undocumented)
    reports: Reports;
    // (undocumented)
    signInSettings: SignInSettings;
    // (undocumented)
    signUpSettings: SignUpSettings;
    // (undocumented)
    subscription: Subscription;
    // (undocumented)
    subscriptionId?: string;
    // (undocumented)
    tag: Tag;
    // (undocumented)
    tagApiLink: TagApiLink;
    // (undocumented)
    tagOperationLink: TagOperationLink;
    // (undocumented)
    tagProductLink: TagProductLink;
    // (undocumented)
    tagResource: TagResource;
    // (undocumented)
    tenantAccess: TenantAccess;
    // (undocumented)
    tenantAccessGit: TenantAccessGit;
    // (undocumented)
    tenantConfiguration: TenantConfiguration;
    // (undocumented)
    tenantSettings: TenantSettings;
    // (undocumented)
    user: User;
    // (undocumented)
    userConfirmationPassword: UserConfirmationPassword;
    // (undocumented)
    userGroup: UserGroup;
    // (undocumented)
    userIdentities: UserIdentities;
    // (undocumented)
    userSubscription: UserSubscription;
    // (undocumented)
    workspace: Workspace;
    // (undocumented)
    workspaceApi: WorkspaceApi;
    // (undocumented)
    workspaceApiDiagnostic: WorkspaceApiDiagnostic;
    // (undocumented)
    workspaceApiExport: WorkspaceApiExport;
    // (undocumented)
    workspaceApiOperation: WorkspaceApiOperation;
    // (undocumented)
    workspaceApiOperationPolicy: WorkspaceApiOperationPolicy;
    // (undocumented)
    workspaceApiPolicy: WorkspaceApiPolicy;
    // (undocumented)
    workspaceApiRelease: WorkspaceApiRelease;
    // (undocumented)
    workspaceApiRevision: WorkspaceApiRevision;
    // (undocumented)
    workspaceApiSchema: WorkspaceApiSchema;
    // (undocumented)
    workspaceApiVersionSet: WorkspaceApiVersionSet;
    // (undocumented)
    workspaceBackend: WorkspaceBackend;
    // (undocumented)
    workspaceCertificate: WorkspaceCertificate;
    // (undocumented)
    workspaceDiagnostic: WorkspaceDiagnostic;
    // (undocumented)
    workspaceGlobalSchema: WorkspaceGlobalSchema;
    // (undocumented)
    workspaceGroup: WorkspaceGroup;
    // (undocumented)
    workspaceGroupUser: WorkspaceGroupUser;
    // (undocumented)
    workspaceLogger: WorkspaceLogger;
    // (undocumented)
    workspaceNamedValue: WorkspaceNamedValue;
    // (undocumented)
    workspaceNotification: WorkspaceNotification;
    // (undocumented)
    workspaceNotificationRecipientEmail: WorkspaceNotificationRecipientEmail;
    // (undocumented)
    workspaceNotificationRecipientUser: WorkspaceNotificationRecipientUser;
    // (undocumented)
    workspacePolicy: WorkspacePolicy;
    // (undocumented)
    workspacePolicyFragment: WorkspacePolicyFragment;
    // (undocumented)
    workspaceProduct: WorkspaceProduct;
    // (undocumented)
    workspaceProductApiLink: WorkspaceProductApiLink;
    // (undocumented)
    workspaceProductGroupLink: WorkspaceProductGroupLink;
    // (undocumented)
    workspaceProductPolicy: WorkspaceProductPolicy;
    // (undocumented)
    workspaceSubscription: WorkspaceSubscription;
    // (undocumented)
    workspaceTag: WorkspaceTag;
    // (undocumented)
    workspaceTagApiLink: WorkspaceTagApiLink;
    // (undocumented)
    workspaceTagOperationLink: WorkspaceTagOperationLink;
    // (undocumented)
    workspaceTagProductLink: WorkspaceTagProductLink;
}

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

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

// @public
export interface ApiManagementGatewayBaseProperties {
    backend?: BackendConfiguration;
    configurationApi?: GatewayConfigurationApi;
    readonly createdAtUtc?: Date;
    frontend?: FrontendConfiguration;
    readonly provisioningState?: string;
    readonly targetProvisioningState?: string;
    virtualNetworkType?: VirtualNetworkType;
}

// @public
export interface ApiManagementGatewayConfigConnectionListResult {
    nextLink?: string;
    value: ApiManagementGatewayConfigConnectionResource[];
}

// @public
export interface ApiManagementGatewayConfigConnectionResource extends ProxyResource {
    readonly defaultHostname?: string;
    readonly etag?: string;
    hostnames?: string[];
    readonly provisioningState?: string;
    sourceId?: string;
}

// @public
export interface ApiManagementGatewayListResult {
    nextLink?: string;
    value: ApiManagementGatewayResource[];
}

// @public
export interface ApiManagementGatewayProperties extends ApiManagementGatewayBaseProperties {
}

// @public
export interface ApiManagementGatewayResource extends ApimResource {
    backend?: BackendConfiguration;
    configurationApi?: GatewayConfigurationApi;
    readonly createdAtUtc?: Date;
    readonly etag?: string;
    frontend?: FrontendConfiguration;
    location: string;
    readonly provisioningState?: string;
    sku: ApiManagementGatewaySkuProperties;
    readonly systemData?: SystemData;
    readonly targetProvisioningState?: string;
    virtualNetworkType?: VirtualNetworkType;
}

// @public
export interface ApiManagementGatewaySkuProperties {
    capacity?: number;
    name: ApiGatewaySkuType;
}

// @public
export interface ApiManagementGatewaySkuPropertiesForPatch {
    capacity?: number;
    name?: ApiGatewaySkuType;
}

// @public
export interface ApiManagementGatewaySkus {
    listAvailableSkus(resourceGroupName: string, gatewayName: string, options?: ApiManagementGatewaySkusListAvailableSkusOptionalParams): PagedAsyncIterableIterator<GatewayResourceSkuResult>;
}

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

// @public
export type ApiManagementGatewaySkusListAvailableSkusNextResponse = GatewayResourceSkuResults;

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

// @public
export type ApiManagementGatewaySkusListAvailableSkusResponse = GatewayResourceSkuResults;

// @public
export interface ApiManagementGatewayUpdateParameters extends ApimResource {
    backend?: BackendConfiguration;
    configurationApi?: GatewayConfigurationApi;
    readonly createdAtUtc?: Date;
    readonly etag?: string;
    frontend?: FrontendConfiguration;
    readonly provisioningState?: string;
    sku?: ApiManagementGatewaySkuPropertiesForPatch;
    readonly targetProvisioningState?: string;
    virtualNetworkType?: VirtualNetworkType;
}

// @public
export interface ApiManagementGatewayUpdateProperties extends ApiManagementGatewayBaseProperties {
}

// @public
export interface ApiManagementOperations {
    list(options?: ApiManagementOperationsListOptionalParams): PagedAsyncIterableIterator<Operation>;
}

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

// @public
export type ApiManagementOperationsListNextResponse = OperationListResult;

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

// @public
export type ApiManagementOperationsListResponse = OperationListResult;

// @public
export interface ApiManagementService {
    beginApplyNetworkConfigurationUpdates(resourceGroupName: string, serviceName: string, options?: ApiManagementServiceApplyNetworkConfigurationUpdatesOptionalParams): Promise<SimplePollerLike<OperationState<ApiManagementServiceApplyNetworkConfigurationUpdatesResponse>, ApiManagementServiceApplyNetworkConfigurationUpdatesResponse>>;
    beginApplyNetworkConfigurationUpdatesAndWait(resourceGroupName: string, serviceName: string, options?: ApiManagementServiceApplyNetworkConfigurationUpdatesOptionalParams): Promise<ApiManagementServiceApplyNetworkConfigurationUpdatesResponse>;
    beginBackup(resourceGroupName: string, serviceName: string, parameters: ApiManagementServiceBackupRestoreParameters, options?: ApiManagementServiceBackupOptionalParams): Promise<SimplePollerLike<OperationState<ApiManagementServiceBackupResponse>, ApiManagementServiceBackupResponse>>;
    beginBackupAndWait(resourceGroupName: string, serviceName: string, parameters: ApiManagementServiceBackupRestoreParameters, options?: ApiManagementServiceBackupOptionalParams): Promise<ApiManagementServiceBackupResponse>;
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, parameters: ApiManagementServiceResource, options?: ApiManagementServiceCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ApiManagementServiceCreateOrUpdateResponse>, ApiManagementServiceCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, parameters: ApiManagementServiceResource, options?: ApiManagementServiceCreateOrUpdateOptionalParams): Promise<ApiManagementServiceCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, serviceName: string, options?: ApiManagementServiceDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, serviceName: string, options?: ApiManagementServiceDeleteOptionalParams): Promise<void>;
    beginMigrateToStv2(resourceGroupName: string, serviceName: string, options?: ApiManagementServiceMigrateToStv2OptionalParams): Promise<SimplePollerLike<OperationState<ApiManagementServiceMigrateToStv2Response>, ApiManagementServiceMigrateToStv2Response>>;
    beginMigrateToStv2AndWait(resourceGroupName: string, serviceName: string, options?: ApiManagementServiceMigrateToStv2OptionalParams): Promise<ApiManagementServiceMigrateToStv2Response>;
    beginRestore(resourceGroupName: string, serviceName: string, parameters: ApiManagementServiceBackupRestoreParameters, options?: ApiManagementServiceRestoreOptionalParams): Promise<SimplePollerLike<OperationState<ApiManagementServiceRestoreResponse>, ApiManagementServiceRestoreResponse>>;
    beginRestoreAndWait(resourceGroupName: string, serviceName: string, parameters: ApiManagementServiceBackupRestoreParameters, options?: ApiManagementServiceRestoreOptionalParams): Promise<ApiManagementServiceRestoreResponse>;
    beginUpdate(resourceGroupName: string, serviceName: string, parameters: ApiManagementServiceUpdateParameters, options?: ApiManagementServiceUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ApiManagementServiceUpdateResponse>, ApiManagementServiceUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, serviceName: string, parameters: ApiManagementServiceUpdateParameters, options?: ApiManagementServiceUpdateOptionalParams): Promise<ApiManagementServiceUpdateResponse>;
    checkNameAvailability(parameters: ApiManagementServiceCheckNameAvailabilityParameters, options?: ApiManagementServiceCheckNameAvailabilityOptionalParams): Promise<ApiManagementServiceCheckNameAvailabilityResponse>;
    get(resourceGroupName: string, serviceName: string, options?: ApiManagementServiceGetOptionalParams): Promise<ApiManagementServiceGetResponse>;
    getDomainOwnershipIdentifier(options?: ApiManagementServiceGetDomainOwnershipIdentifierOptionalParams): Promise<ApiManagementServiceGetDomainOwnershipIdentifierResponse>;
    getSsoToken(resourceGroupName: string, serviceName: string, options?: ApiManagementServiceGetSsoTokenOptionalParams): Promise<ApiManagementServiceGetSsoTokenResponse>;
    list(options?: ApiManagementServiceListOptionalParams): PagedAsyncIterableIterator<ApiManagementServiceResource>;
    listByResourceGroup(resourceGroupName: string, options?: ApiManagementServiceListByResourceGroupOptionalParams): PagedAsyncIterableIterator<ApiManagementServiceResource>;
}

// @public
export interface ApiManagementServiceApplyNetworkConfigurationParameters {
    location?: string;
}

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

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

// @public
export type ApiManagementServiceApplyNetworkConfigurationUpdatesResponse = ApiManagementServiceResource;

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

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

// @public
export type ApiManagementServiceBackupResponse = ApiManagementServiceResource;

// @public
export interface ApiManagementServiceBackupRestoreParameters {
    accessKey?: string;
    accessType?: AccessType;
    backupName: string;
    clientId?: string;
    containerName: string;
    storageAccount: string;
}

// @public
export interface ApiManagementServiceBaseProperties {
    additionalLocations?: AdditionalLocation[];
    apiVersionConstraint?: ApiVersionConstraint;
    certificates?: CertificateConfiguration[];
    configurationApi?: ConfigurationApi;
    readonly createdAtUtc?: Date;
    customProperties?: {
        [propertyName: string]: string;
    };
    developerPortalStatus?: DeveloperPortalStatus;
    readonly developerPortalUrl?: string;
    disableGateway?: boolean;
    enableClientCertificate?: boolean;
    readonly gatewayRegionalUrl?: string;
    readonly gatewayUrl?: string;
    hostnameConfigurations?: HostnameConfiguration[];
    legacyPortalStatus?: LegacyPortalStatus;
    readonly managementApiUrl?: string;
    natGatewayState?: NatGatewayState;
    notificationSenderEmail?: string;
    readonly outboundPublicIPAddresses?: string[];
    readonly platformVersion?: PlatformVersion;
    readonly portalUrl?: string;
    privateEndpointConnections?: RemotePrivateEndpointConnectionWrapper[];
    readonly privateIPAddresses?: string[];
    readonly provisioningState?: string;
    readonly publicIPAddresses?: string[];
    publicIpAddressId?: string;
    publicNetworkAccess?: PublicNetworkAccess;
    restore?: boolean;
    readonly scmUrl?: string;
    readonly targetProvisioningState?: string;
    virtualNetworkConfiguration?: VirtualNetworkConfiguration;
    virtualNetworkType?: VirtualNetworkType;
}

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

// @public
export interface ApiManagementServiceCheckNameAvailabilityParameters {
    name: string;
}

// @public
export type ApiManagementServiceCheckNameAvailabilityResponse = ApiManagementServiceNameAvailabilityResult;

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

// @public
export type ApiManagementServiceCreateOrUpdateResponse = ApiManagementServiceResource;

// @public
export interface ApiManagementServiceDeleteHeaders {
    location?: string;
}

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

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

// @public
export type ApiManagementServiceGetDomainOwnershipIdentifierResponse = ApiManagementServiceGetDomainOwnershipIdentifierResult;

// @public
export interface ApiManagementServiceGetDomainOwnershipIdentifierResult {
    readonly domainOwnershipIdentifier?: string;
}

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

// @public
export type ApiManagementServiceGetResponse = ApiManagementServiceResource;

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

// @public
export type ApiManagementServiceGetSsoTokenResponse = ApiManagementServiceGetSsoTokenResult;

// @public
export interface ApiManagementServiceGetSsoTokenResult {
    redirectUri?: string;
}

// @public
export interface ApiManagementServiceIdentity {
    readonly principalId?: string;
    readonly tenantId?: string;
    type: ApimIdentityType;
    userAssignedIdentities?: {
        [propertyName: string]: UserIdentityProperties;
    };
}

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

// @public
export type ApiManagementServiceListByResourceGroupNextResponse = ApiManagementServiceListResult;

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

// @public
export type ApiManagementServiceListByResourceGroupResponse = ApiManagementServiceListResult;

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

// @public
export type ApiManagementServiceListNextResponse = ApiManagementServiceListResult;

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

// @public
export type ApiManagementServiceListResponse = ApiManagementServiceListResult;

// @public
export interface ApiManagementServiceListResult {
    nextLink?: string;
    value: ApiManagementServiceResource[];
}

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

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

// @public
export type ApiManagementServiceMigrateToStv2Response = ApiManagementServiceResource;

// @public
export interface ApiManagementServiceNameAvailabilityResult {
    readonly message?: string;
    readonly nameAvailable?: boolean;
    reason?: NameAvailabilityReason;
}

// @public
export interface ApiManagementServiceProperties extends ApiManagementServiceBaseProperties {
    publisherEmail: string;
    publisherName: string;
}

// @public
export interface ApiManagementServiceResource extends ApimResource {
    additionalLocations?: AdditionalLocation[];
    apiVersionConstraint?: ApiVersionConstraint;
    certificates?: CertificateConfiguration[];
    configurationApi?: ConfigurationApi;
    readonly createdAtUtc?: Date;
    customProperties?: {
        [propertyName: string]: string;
    };
    developerPortalStatus?: DeveloperPortalStatus;
    readonly developerPortalUrl?: string;
    disableGateway?: boolean;
    enableClientCertificate?: boolean;
    readonly etag?: string;
    readonly gatewayRegionalUrl?: string;
    readonly gatewayUrl?: string;
    hostnameConfigurations?: HostnameConfiguration[];
    identity?: ApiManagementServiceIdentity;
    legacyPortalStatus?: LegacyPortalStatus;
    location: string;
    readonly managementApiUrl?: string;
    natGatewayState?: NatGatewayState;
    notificationSenderEmail?: string;
    readonly outboundPublicIPAddresses?: string[];
    readonly platformVersion?: PlatformVersion;
    readonly portalUrl?: string;
    privateEndpointConnections?: RemotePrivateEndpointConnectionWrapper[];
    readonly privateIPAddresses?: string[];
    readonly provisioningState?: string;
    readonly publicIPAddresses?: string[];
    publicIpAddressId?: string;
    publicNetworkAccess?: PublicNetworkAccess;
    publisherEmail: string;
    publisherName: string;
    restore?: boolean;
    readonly scmUrl?: string;
    sku: ApiManagementServiceSkuProperties;
    readonly systemData?: SystemData;
    readonly targetProvisioningState?: string;
    virtualNetworkConfiguration?: VirtualNetworkConfiguration;
    virtualNetworkType?: VirtualNetworkType;
    zones?: string[];
}

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

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

// @public
export type ApiManagementServiceRestoreResponse = ApiManagementServiceResource;

// @public
export interface ApiManagementServiceSkuProperties {
    capacity: number;
    name: SkuType;
}

// @public
export interface ApiManagementServiceSkus {
    listAvailableServiceSkus(resourceGroupName: string, serviceName: string, options?: ApiManagementServiceSkusListAvailableServiceSkusOptionalParams): PagedAsyncIterableIterator<ResourceSkuResult>;
}

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

// @public
export type ApiManagementServiceSkusListAvailableServiceSkusNextResponse = ResourceSkuResults;

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

// @public
export type ApiManagementServiceSkusListAvailableServiceSkusResponse = ResourceSkuResults;

// @public
export interface ApiManagementServiceUpdateHeaders {
    location?: string;
}

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

// @public
export interface ApiManagementServiceUpdateParameters extends ApimResource {
    additionalLocations?: AdditionalLocation[];
    apiVersionConstraint?: ApiVersionConstraint;
    certificates?: CertificateConfiguration[];
    configurationApi?: ConfigurationApi;
    readonly createdAtUtc?: Date;
    customProperties?: {
        [propertyName: string]: string;
    };
    developerPortalStatus?: DeveloperPortalStatus;
    readonly developerPortalUrl?: string;
    disableGateway?: boolean;
    enableClientCertificate?: boolean;
    readonly etag?: string;
    readonly gatewayRegionalUrl?: string;
    readonly gatewayUrl?: string;
    hostnameConfigurations?: HostnameConfiguration[];
    identity?: ApiManagementServiceIdentity;
    legacyPortalStatus?: LegacyPortalStatus;
    readonly managementApiUrl?: string;
    natGatewayState?: NatGatewayState;
    notificationSenderEmail?: string;
    readonly outboundPublicIPAddresses?: string[];
    readonly platformVersion?: PlatformVersion;
    readonly portalUrl?: string;
    privateEndpointConnections?: RemotePrivateEndpointConnectionWrapper[];
    readonly privateIPAddresses?: string[];
    readonly provisioningState?: string;
    readonly publicIPAddresses?: string[];
    publicIpAddressId?: string;
    publicNetworkAccess?: PublicNetworkAccess;
    publisherEmail?: string;
    publisherName?: string;
    restore?: boolean;
    readonly scmUrl?: string;
    sku?: ApiManagementServiceSkuProperties;
    readonly targetProvisioningState?: string;
    virtualNetworkConfiguration?: VirtualNetworkConfiguration;
    virtualNetworkType?: VirtualNetworkType;
    zones?: string[];
}

// @public
export interface ApiManagementServiceUpdateProperties extends ApiManagementServiceBaseProperties {
    publisherEmail?: string;
    publisherName?: string;
}

// @public
export type ApiManagementServiceUpdateResponse = ApiManagementServiceResource;

// @public
export interface ApiManagementSku {
    readonly apiVersions?: string[];
    readonly capabilities?: ApiManagementSkuCapabilities[];
    readonly capacity?: ApiManagementSkuCapacity;
    readonly costs?: ApiManagementSkuCosts[];
    readonly family?: string;
    readonly kind?: string;
    readonly locationInfo?: ApiManagementSkuLocationInfo[];
    readonly locations?: string[];
    readonly name?: string;
    readonly resourceType?: string;
    readonly restrictions?: ApiManagementSkuRestrictions[];
    readonly size?: string;
    readonly tier?: string;
}

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

// @public
export interface ApiManagementSkuCapacity {
    readonly default?: number;
    readonly maximum?: number;
    readonly minimum?: number;
    readonly scaleType?: ApiManagementSkuCapacityScaleType;
}

// @public
export type ApiManagementSkuCapacityScaleType = "Automatic" | "Manual" | "None";

// @public
export interface ApiManagementSkuCosts {
    readonly extendedUnit?: string;
    readonly meterID?: string;
    readonly quantity?: number;
}

// @public (undocumented)
export interface ApiManagementSkuLocationInfo {
    readonly location?: string;
    readonly zoneDetails?: ApiManagementSkuZoneDetails[];
    readonly zones?: string[];
}

// @public (undocumented)
export interface ApiManagementSkuRestrictionInfo {
    readonly locations?: string[];
    readonly zones?: string[];
}

// @public
export interface ApiManagementSkuRestrictions {
    readonly reasonCode?: ApiManagementSkuRestrictionsReasonCode;
    readonly restrictionInfo?: ApiManagementSkuRestrictionInfo;
    readonly type?: ApiManagementSkuRestrictionsType;
    readonly values?: string[];
}

// @public
export type ApiManagementSkuRestrictionsReasonCode = "QuotaId" | "NotAvailableForSubscription";

// @public
export type ApiManagementSkuRestrictionsType = "Location" | "Zone";

// @public
export interface ApiManagementSkus {
    list(options?: ApiManagementSkusListOptionalParams): PagedAsyncIterableIterator<ApiManagementSku>;
}

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

// @public
export type ApiManagementSkusListNextResponse = ApiManagementSkusResult;

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

// @public
export type ApiManagementSkusListResponse = ApiManagementSkusResult;

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

// @public
export interface ApiManagementSkuZoneDetails {
    readonly capabilities?: ApiManagementSkuCapabilities[];
    readonly name?: string[];
}

// @public
export interface ApiManagementWorkspaceLink {
    get(resourceGroupName: string, serviceName: string, workspaceId: string, options?: ApiManagementWorkspaceLinkGetOptionalParams): Promise<ApiManagementWorkspaceLinkGetResponse>;
}

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

// @public
export type ApiManagementWorkspaceLinkGetResponse = ApiManagementWorkspaceLinksResource;

// @public
export interface ApiManagementWorkspaceLinks {
    listByService(resourceGroupName: string, serviceName: string, options?: ApiManagementWorkspaceLinksListByServiceOptionalParams): PagedAsyncIterableIterator<ApiManagementWorkspaceLinksResource>;
}

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

// @public
export type ApiManagementWorkspaceLinksListByServiceNextResponse = ApiManagementWorkspaceLinksListResult;

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

// @public
export type ApiManagementWorkspaceLinksListByServiceResponse = ApiManagementWorkspaceLinksListResult;

// @public
export interface ApiManagementWorkspaceLinksListResult {
    nextLink?: string;
    value: ApiManagementWorkspaceLinksResource[];
}

// @public
export interface ApiManagementWorkspaceLinksProperties extends WorkspaceLinksBaseProperties {
}

// @public
export interface ApiManagementWorkspaceLinksResource extends ProxyResource {
    readonly etag?: string;
    gateways?: WorkspaceLinksGateway[];
    workspaceId?: string;
}

// @public
export type ApimIdentityType = string;

// @public
export interface ApimResource {
    readonly id?: string;
    readonly name?: string;
    tags?: {
        [propertyName: string]: string;
    };
    readonly type?: string;
}

// @public
export interface ApiOperation {
    createOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, parameters: OperationContract, options?: ApiOperationCreateOrUpdateOptionalParams): Promise<ApiOperationCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, ifMatch: string, options?: ApiOperationDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, options?: ApiOperationGetOptionalParams): Promise<ApiOperationGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, options?: ApiOperationGetEntityTagOptionalParams): Promise<ApiOperationGetEntityTagResponse>;
    listByApi(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiOperationListByApiOptionalParams): PagedAsyncIterableIterator<OperationContract>;
    update(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, ifMatch: string, parameters: OperationUpdateContract, options?: ApiOperationUpdateOptionalParams): Promise<ApiOperationUpdateResponse>;
}

// @public
export interface ApiOperationCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ApiOperationCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ApiOperationCreateOrUpdateResponse = ApiOperationCreateOrUpdateHeaders & OperationContract;

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

// @public
export interface ApiOperationGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ApiOperationGetEntityTagResponse = ApiOperationGetEntityTagHeaders;

// @public
export interface ApiOperationGetHeaders {
    eTag?: string;
}

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

// @public
export type ApiOperationGetResponse = ApiOperationGetHeaders & OperationContract;

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

// @public
export type ApiOperationListByApiNextResponse = OperationCollection;

// @public
export interface ApiOperationListByApiOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    tags?: string;
    top?: number;
}

// @public
export type ApiOperationListByApiResponse = OperationCollection;

// @public
export interface ApiOperationPolicy {
    createOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, policyId: PolicyIdName, parameters: PolicyContract, options?: ApiOperationPolicyCreateOrUpdateOptionalParams): Promise<ApiOperationPolicyCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, policyId: PolicyIdName, ifMatch: string, options?: ApiOperationPolicyDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, policyId: PolicyIdName, options?: ApiOperationPolicyGetOptionalParams): Promise<ApiOperationPolicyGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, policyId: PolicyIdName, options?: ApiOperationPolicyGetEntityTagOptionalParams): Promise<ApiOperationPolicyGetEntityTagResponse>;
    listByOperation(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, options?: ApiOperationPolicyListByOperationOptionalParams): Promise<ApiOperationPolicyListByOperationResponse>;
}

// @public
export interface ApiOperationPolicyCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ApiOperationPolicyCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ApiOperationPolicyCreateOrUpdateResponse = ApiOperationPolicyCreateOrUpdateHeaders & PolicyContract;

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

// @public
export interface ApiOperationPolicyGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ApiOperationPolicyGetEntityTagResponse = ApiOperationPolicyGetEntityTagHeaders;

// @public
export interface ApiOperationPolicyGetHeaders {
    eTag?: string;
}

// @public
export interface ApiOperationPolicyGetOptionalParams extends coreClient.OperationOptions {
    format?: PolicyExportFormat;
}

// @public
export type ApiOperationPolicyGetResponse = ApiOperationPolicyGetHeaders & PolicyContract;

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

// @public
export type ApiOperationPolicyListByOperationResponse = PolicyCollection;

// @public
export interface ApiOperationUpdateHeaders {
    eTag?: string;
}

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

// @public
export type ApiOperationUpdateResponse = ApiOperationUpdateHeaders & OperationContract;

// @public
export interface ApiPolicy {
    createOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, policyId: PolicyIdName, parameters: PolicyContract, options?: ApiPolicyCreateOrUpdateOptionalParams): Promise<ApiPolicyCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, apiId: string, policyId: PolicyIdName, ifMatch: string, options?: ApiPolicyDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, apiId: string, policyId: PolicyIdName, options?: ApiPolicyGetOptionalParams): Promise<ApiPolicyGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, policyId: PolicyIdName, options?: ApiPolicyGetEntityTagOptionalParams): Promise<ApiPolicyGetEntityTagResponse>;
    listByApi(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiPolicyListByApiOptionalParams): Promise<ApiPolicyListByApiResponse>;
}

// @public
export interface ApiPolicyCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ApiPolicyCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ApiPolicyCreateOrUpdateResponse = ApiPolicyCreateOrUpdateHeaders & PolicyContract;

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

// @public
export interface ApiPolicyGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ApiPolicyGetEntityTagResponse = ApiPolicyGetEntityTagHeaders;

// @public
export interface ApiPolicyGetHeaders {
    eTag?: string;
}

// @public
export interface ApiPolicyGetOptionalParams extends coreClient.OperationOptions {
    format?: PolicyExportFormat;
}

// @public
export type ApiPolicyGetResponse = ApiPolicyGetHeaders & PolicyContract;

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

// @public
export type ApiPolicyListByApiResponse = PolicyCollection;

// @public
export interface ApiProduct {
    listByApis(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiProductListByApisOptionalParams): PagedAsyncIterableIterator<ProductContract>;
}

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

// @public
export type ApiProductListByApisNextResponse = ProductCollection;

// @public
export interface ApiProductListByApisOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ApiProductListByApisResponse = ProductCollection;

// @public
export interface ApiRelease {
    createOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, releaseId: string, parameters: ApiReleaseContract, options?: ApiReleaseCreateOrUpdateOptionalParams): Promise<ApiReleaseCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, apiId: string, releaseId: string, ifMatch: string, options?: ApiReleaseDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, apiId: string, releaseId: string, options?: ApiReleaseGetOptionalParams): Promise<ApiReleaseGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, releaseId: string, options?: ApiReleaseGetEntityTagOptionalParams): Promise<ApiReleaseGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiReleaseListByServiceOptionalParams): PagedAsyncIterableIterator<ApiReleaseContract>;
    update(resourceGroupName: string, serviceName: string, apiId: string, releaseId: string, ifMatch: string, parameters: ApiReleaseContract, options?: ApiReleaseUpdateOptionalParams): Promise<ApiReleaseUpdateResponse>;
}

// @public
export interface ApiReleaseCollection {
    count?: number;
    readonly nextLink?: string;
    readonly value?: ApiReleaseContract[];
}

// @public
export interface ApiReleaseContract extends ProxyResource {
    apiId?: string;
    readonly createdDateTime?: Date;
    notes?: string;
    readonly updatedDateTime?: Date;
}

// @public
export interface ApiReleaseCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ApiReleaseCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ApiReleaseCreateOrUpdateResponse = ApiReleaseCreateOrUpdateHeaders & ApiReleaseContract;

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

// @public
export interface ApiReleaseGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ApiReleaseGetEntityTagResponse = ApiReleaseGetEntityTagHeaders;

// @public
export interface ApiReleaseGetHeaders {
    eTag?: string;
}

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

// @public
export type ApiReleaseGetResponse = ApiReleaseGetHeaders & ApiReleaseContract;

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

// @public
export type ApiReleaseListByServiceNextResponse = ApiReleaseCollection;

// @public
export interface ApiReleaseListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ApiReleaseListByServiceResponse = ApiReleaseCollection;

// @public
export interface ApiReleaseUpdateHeaders {
    eTag?: string;
}

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

// @public
export type ApiReleaseUpdateResponse = ApiReleaseUpdateHeaders & ApiReleaseContract;

// @public
export interface ApiRevision {
    listByService(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiRevisionListByServiceOptionalParams): PagedAsyncIterableIterator<ApiRevisionContract>;
}

// @public
export interface ApiRevisionCollection {
    count?: number;
    readonly nextLink?: string;
    readonly value?: ApiRevisionContract[];
}

// @public
export interface ApiRevisionContract {
    readonly apiId?: string;
    readonly apiRevision?: string;
    readonly createdDateTime?: Date;
    readonly description?: string;
    readonly isCurrent?: boolean;
    readonly isOnline?: boolean;
    readonly privateUrl?: string;
    readonly updatedDateTime?: Date;
}

// @public
export interface ApiRevisionInfoContract {
    apiRevisionDescription?: string;
    apiVersionName?: string;
    apiVersionSet?: ApiVersionSetContractDetails;
    sourceApiId?: string;
}

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

// @public
export type ApiRevisionListByServiceNextResponse = ApiRevisionCollection;

// @public
export interface ApiRevisionListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ApiRevisionListByServiceResponse = ApiRevisionCollection;

// @public
export interface ApiSchema {
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, schemaId: string, parameters: SchemaContract, options?: ApiSchemaCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<ApiSchemaCreateOrUpdateResponse>, ApiSchemaCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, apiId: string, schemaId: string, parameters: SchemaContract, options?: ApiSchemaCreateOrUpdateOptionalParams): Promise<ApiSchemaCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, apiId: string, schemaId: string, ifMatch: string, options?: ApiSchemaDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, apiId: string, schemaId: string, options?: ApiSchemaGetOptionalParams): Promise<ApiSchemaGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, schemaId: string, options?: ApiSchemaGetEntityTagOptionalParams): Promise<ApiSchemaGetEntityTagResponse>;
    listByApi(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiSchemaListByApiOptionalParams): PagedAsyncIterableIterator<SchemaContract>;
}

// @public
export interface ApiSchemaCreateOrUpdateHeaders {
    azureAsyncOperation?: string;
    eTag?: string;
    location?: string;
}

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

// @public
export type ApiSchemaCreateOrUpdateResponse = ApiSchemaCreateOrUpdateHeaders & SchemaContract;

// @public
export interface ApiSchemaDeleteOptionalParams extends coreClient.OperationOptions {
    force?: boolean;
}

// @public
export interface ApiSchemaGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ApiSchemaGetEntityTagResponse = ApiSchemaGetEntityTagHeaders;

// @public
export interface ApiSchemaGetHeaders {
    eTag?: string;
}

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

// @public
export type ApiSchemaGetResponse = ApiSchemaGetHeaders & SchemaContract;

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

// @public
export type ApiSchemaListByApiNextResponse = SchemaCollection;

// @public
export interface ApiSchemaListByApiOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ApiSchemaListByApiResponse = SchemaCollection;

// @public
export interface ApiTagDescription {
    createOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, tagDescriptionId: string, parameters: TagDescriptionCreateParameters, options?: ApiTagDescriptionCreateOrUpdateOptionalParams): Promise<ApiTagDescriptionCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, apiId: string, tagDescriptionId: string, ifMatch: string, options?: ApiTagDescriptionDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, apiId: string, tagDescriptionId: string, options?: ApiTagDescriptionGetOptionalParams): Promise<ApiTagDescriptionGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, tagDescriptionId: string, options?: ApiTagDescriptionGetEntityTagOptionalParams): Promise<ApiTagDescriptionGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiTagDescriptionListByServiceOptionalParams): PagedAsyncIterableIterator<TagDescriptionContract>;
}

// @public
export interface ApiTagDescriptionCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ApiTagDescriptionCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ApiTagDescriptionCreateOrUpdateResponse = ApiTagDescriptionCreateOrUpdateHeaders & TagDescriptionContract;

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

// @public
export interface ApiTagDescriptionGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ApiTagDescriptionGetEntityTagResponse = ApiTagDescriptionGetEntityTagHeaders;

// @public
export interface ApiTagDescriptionGetHeaders {
    eTag?: string;
}

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

// @public
export type ApiTagDescriptionGetResponse = ApiTagDescriptionGetHeaders & TagDescriptionContract;

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

// @public
export type ApiTagDescriptionListByServiceNextResponse = TagDescriptionCollection;

// @public
export interface ApiTagDescriptionListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ApiTagDescriptionListByServiceResponse = TagDescriptionCollection;

// @public
export interface ApiTagResourceContractProperties extends ApiEntityBaseContract {
    id?: string;
    name?: string;
    path?: string;
    protocols?: Protocol[];
    serviceUrl?: string;
}

// @public
export type ApiType = string;

// @public
export interface ApiUpdateContract {
    apiRevision?: string;
    apiRevisionDescription?: string;
    apiType?: ApiType;
    apiVersion?: string;
    apiVersionDescription?: string;
    apiVersionSetId?: string;
    authenticationSettings?: AuthenticationSettingsContract;
    contact?: ApiContactInformation;
    description?: string;
    displayName?: string;
    isCurrent?: boolean;
    readonly isOnline?: boolean;
    license?: ApiLicenseInformation;
    path?: string;
    protocols?: Protocol[];
    serviceUrl?: string;
    subscriptionKeyParameterNames?: SubscriptionKeyParameterNamesContract;
    subscriptionRequired?: boolean;
    termsOfServiceUrl?: string;
}

// @public
export interface ApiUpdateHeaders {
    eTag?: string;
}

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

// @public
export type ApiUpdateResponse = ApiUpdateHeaders & ApiContract;

// @public
export interface ApiVersionConstraint {
    minApiVersion?: string;
}

// @public
export interface ApiVersionSet {
    createOrUpdate(resourceGroupName: string, serviceName: string, versionSetId: string, parameters: ApiVersionSetContract, options?: ApiVersionSetCreateOrUpdateOptionalParams): Promise<ApiVersionSetCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, versionSetId: string, ifMatch: string, options?: ApiVersionSetDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, versionSetId: string, options?: ApiVersionSetGetOptionalParams): Promise<ApiVersionSetGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, versionSetId: string, options?: ApiVersionSetGetEntityTagOptionalParams): Promise<ApiVersionSetGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: ApiVersionSetListByServiceOptionalParams): PagedAsyncIterableIterator<ApiVersionSetContract>;
    update(resourceGroupName: string, serviceName: string, versionSetId: string, ifMatch: string, parameters: ApiVersionSetUpdateParameters, options?: ApiVersionSetUpdateOptionalParams): Promise<ApiVersionSetUpdateResponse>;
}

// @public
export interface ApiVersionSetCollection {
    count?: number;
    nextLink?: string;
    value?: ApiVersionSetContract[];
}

// @public
export interface ApiVersionSetContract extends ProxyResource {
    description?: string;
    displayName?: string;
    versionHeaderName?: string;
    versioningScheme?: VersioningScheme;
    versionQueryName?: string;
}

// @public
export interface ApiVersionSetContractDetails {
    description?: string;
    id?: string;
    name?: string;
    versionHeaderName?: string;
    versioningScheme?: ApiVersionSetContractDetailsVersioningScheme;
    versionQueryName?: string;
}

// @public
export type ApiVersionSetContractDetailsVersioningScheme = string;

// @public
export interface ApiVersionSetContractProperties extends ApiVersionSetEntityBase {
    displayName: string;
    versioningScheme: VersioningScheme;
}

// @public
export interface ApiVersionSetCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ApiVersionSetCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ApiVersionSetCreateOrUpdateResponse = ApiVersionSetCreateOrUpdateHeaders & ApiVersionSetContract;

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

// @public
export interface ApiVersionSetEntityBase {
    description?: string;
    versionHeaderName?: string;
    versionQueryName?: string;
}

// @public
export interface ApiVersionSetGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ApiVersionSetGetEntityTagResponse = ApiVersionSetGetEntityTagHeaders;

// @public
export interface ApiVersionSetGetHeaders {
    eTag?: string;
}

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

// @public
export type ApiVersionSetGetResponse = ApiVersionSetGetHeaders & ApiVersionSetContract;

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

// @public
export type ApiVersionSetListByServiceNextResponse = ApiVersionSetCollection;

// @public
export interface ApiVersionSetListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ApiVersionSetListByServiceResponse = ApiVersionSetCollection;

// @public
export interface ApiVersionSetUpdateHeaders {
    eTag?: string;
}

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

// @public
export interface ApiVersionSetUpdateParameters {
    description?: string;
    displayName?: string;
    versionHeaderName?: string;
    versioningScheme?: VersioningScheme;
    versionQueryName?: string;
}

// @public
export interface ApiVersionSetUpdateParametersProperties extends ApiVersionSetEntityBase {
    displayName?: string;
    versioningScheme?: VersioningScheme;
}

// @public
export type ApiVersionSetUpdateResponse = ApiVersionSetUpdateHeaders & ApiVersionSetContract;

// @public
export interface ApiWiki {
    createOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, parameters: WikiContract, options?: ApiWikiCreateOrUpdateOptionalParams): Promise<ApiWikiCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, apiId: string, ifMatch: string, options?: ApiWikiDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiWikiGetOptionalParams): Promise<ApiWikiGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiWikiGetEntityTagOptionalParams): Promise<ApiWikiGetEntityTagResponse>;
    update(resourceGroupName: string, serviceName: string, apiId: string, ifMatch: string, parameters: WikiUpdateContract, options?: ApiWikiUpdateOptionalParams): Promise<ApiWikiUpdateResponse>;
}

// @public
export interface ApiWikiCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ApiWikiCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ApiWikiCreateOrUpdateResponse = ApiWikiCreateOrUpdateHeaders & WikiContract;

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

// @public
export interface ApiWikiGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ApiWikiGetEntityTagResponse = ApiWikiGetEntityTagHeaders;

// @public
export interface ApiWikiGetHeaders {
    eTag?: string;
}

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

// @public
export type ApiWikiGetResponse = ApiWikiGetHeaders & WikiContract;

// @public
export interface ApiWikis {
    list(resourceGroupName: string, serviceName: string, apiId: string, options?: ApiWikisListOptionalParams): PagedAsyncIterableIterator<WikiContract>;
}

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

// @public
export type ApiWikisListNextResponse = WikiCollection;

// @public
export interface ApiWikisListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ApiWikisListResponse = WikiCollection;

// @public
export interface ApiWikiUpdateHeaders {
    eTag?: string;
}

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

// @public
export type ApiWikiUpdateResponse = ApiWikiUpdateHeaders & WikiContract;

// @public
export type AppType = string;

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

// @public
export interface AssociationContract extends ProxyResource {
    provisioningState?: "created";
}

// @public
export type AsyncOperationStatus = "Started" | "InProgress" | "Succeeded" | "Failed";

// @public
export type AsyncResolverStatus = "Started" | "InProgress" | "Succeeded" | "Failed";

// @public
export interface AuthenticationSettingsContract {
    oAuth2?: OAuth2AuthenticationSettingsContract;
    oAuth2AuthenticationSettings?: OAuth2AuthenticationSettingsContract[];
    openid?: OpenIdAuthenticationSettingsContract;
    openidAuthenticationSettings?: OpenIdAuthenticationSettingsContract[];
}

// @public
export interface Authorization {
    confirmConsentCode(resourceGroupName: string, serviceName: string, authorizationProviderId: string, authorizationId: string, parameters: AuthorizationConfirmConsentCodeRequestContract, options?: AuthorizationConfirmConsentCodeOptionalParams): Promise<AuthorizationConfirmConsentCodeResponse>;
    createOrUpdate(resourceGroupName: string, serviceName: string, authorizationProviderId: string, authorizationId: string, parameters: AuthorizationContract, options?: AuthorizationCreateOrUpdateOptionalParams): Promise<AuthorizationCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, authorizationProviderId: string, authorizationId: string, ifMatch: string, options?: AuthorizationDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, authorizationProviderId: string, authorizationId: string, options?: AuthorizationGetOptionalParams): Promise<AuthorizationGetResponse>;
    listByAuthorizationProvider(resourceGroupName: string, serviceName: string, authorizationProviderId: string, options?: AuthorizationListByAuthorizationProviderOptionalParams): PagedAsyncIterableIterator<AuthorizationContract>;
}

// @public
export interface AuthorizationAccessPolicy {
    createOrUpdate(resourceGroupName: string, serviceName: string, authorizationProviderId: string, authorizationId: string, authorizationAccessPolicyId: string, parameters: AuthorizationAccessPolicyContract, options?: AuthorizationAccessPolicyCreateOrUpdateOptionalParams): Promise<AuthorizationAccessPolicyCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, authorizationProviderId: string, authorizationId: string, authorizationAccessPolicyId: string, ifMatch: string, options?: AuthorizationAccessPolicyDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, authorizationProviderId: string, authorizationId: string, authorizationAccessPolicyId: string, options?: AuthorizationAccessPolicyGetOptionalParams): Promise<AuthorizationAccessPolicyGetResponse>;
    listByAuthorization(resourceGroupName: string, serviceName: string, authorizationProviderId: string, authorizationId: string, options?: AuthorizationAccessPolicyListByAuthorizationOptionalParams): PagedAsyncIterableIterator<AuthorizationAccessPolicyContract>;
}

// @public
export interface AuthorizationAccessPolicyCollection {
    count?: number;
    nextLink?: string;
    value?: AuthorizationAccessPolicyContract[];
}

// @public
export interface AuthorizationAccessPolicyContract extends ProxyResource {
    appIds?: string[];
    objectId?: string;
    tenantId?: string;
}

// @public
export interface AuthorizationAccessPolicyCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface AuthorizationAccessPolicyCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type AuthorizationAccessPolicyCreateOrUpdateResponse = AuthorizationAccessPolicyCreateOrUpdateHeaders & AuthorizationAccessPolicyContract;

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

// @public
export interface AuthorizationAccessPolicyGetHeaders {
    eTag?: string;
}

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

// @public
export type AuthorizationAccessPolicyGetResponse = AuthorizationAccessPolicyGetHeaders & AuthorizationAccessPolicyContract;

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

// @public
export type AuthorizationAccessPolicyListByAuthorizationNextResponse = AuthorizationAccessPolicyCollection;

// @public
export interface AuthorizationAccessPolicyListByAuthorizationOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type AuthorizationAccessPolicyListByAuthorizationResponse = AuthorizationAccessPolicyCollection;

// @public
export interface AuthorizationCollection {
    count?: number;
    nextLink?: string;
    value?: AuthorizationContract[];
}

// @public
export interface AuthorizationConfirmConsentCodeHeaders {
    eTag?: string;
}

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

// @public
export interface AuthorizationConfirmConsentCodeRequestContract {
    consentCode?: string;
}

// @public
export type AuthorizationConfirmConsentCodeResponse = AuthorizationConfirmConsentCodeHeaders;

// @public
export interface AuthorizationContract extends ProxyResource {
    authorizationType?: AuthorizationType;
    error?: AuthorizationError;
    oAuth2GrantType?: OAuth2GrantType;
    parameters?: {
        [propertyName: string]: string;
    };
    status?: string;
}

// @public
export interface AuthorizationCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface AuthorizationCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type AuthorizationCreateOrUpdateResponse = AuthorizationCreateOrUpdateHeaders & AuthorizationContract;

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

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

// @public
export interface AuthorizationGetHeaders {
    eTag?: string;
}

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

// @public
export type AuthorizationGetResponse = AuthorizationGetHeaders & AuthorizationContract;

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

// @public
export type AuthorizationListByAuthorizationProviderNextResponse = AuthorizationCollection;

// @public
export interface AuthorizationListByAuthorizationProviderOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type AuthorizationListByAuthorizationProviderResponse = AuthorizationCollection;

// @public
export interface AuthorizationLoginLinks {
    post(resourceGroupName: string, serviceName: string, authorizationProviderId: string, authorizationId: string, parameters: AuthorizationLoginRequestContract, options?: AuthorizationLoginLinksPostOptionalParams): Promise<AuthorizationLoginLinksPostResponse>;
}

// @public
export interface AuthorizationLoginLinksPostHeaders {
    eTag?: string;
}

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

// @public
export type AuthorizationLoginLinksPostResponse = AuthorizationLoginLinksPostHeaders & AuthorizationLoginResponseContract;

// @public
export interface AuthorizationLoginRequestContract {
    postLoginRedirectUrl?: string;
}

// @public
export interface AuthorizationLoginResponseContract {
    loginLink?: string;
}

// @public
export type AuthorizationMethod = "HEAD" | "OPTIONS" | "TRACE" | "GET" | "POST" | "PUT" | "PATCH" | "DELETE";

// @public
export interface AuthorizationProvider {
    createOrUpdate(resourceGroupName: string, serviceName: string, authorizationProviderId: string, parameters: AuthorizationProviderContract, options?: AuthorizationProviderCreateOrUpdateOptionalParams): Promise<AuthorizationProviderCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, authorizationProviderId: string, ifMatch: string, options?: AuthorizationProviderDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, authorizationProviderId: string, options?: AuthorizationProviderGetOptionalParams): Promise<AuthorizationProviderGetResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: AuthorizationProviderListByServiceOptionalParams): PagedAsyncIterableIterator<AuthorizationProviderContract>;
}

// @public
export interface AuthorizationProviderCollection {
    nextLink?: string;
    value?: AuthorizationProviderContract[];
}

// @public
export interface AuthorizationProviderContract extends ProxyResource {
    displayName?: string;
    identityProvider?: string;
    oauth2?: AuthorizationProviderOAuth2Settings;
}

// @public
export interface AuthorizationProviderCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface AuthorizationProviderCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type AuthorizationProviderCreateOrUpdateResponse = AuthorizationProviderCreateOrUpdateHeaders & AuthorizationProviderContract;

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

// @public
export interface AuthorizationProviderGetHeaders {
    eTag?: string;
}

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

// @public
export type AuthorizationProviderGetResponse = AuthorizationProviderGetHeaders & AuthorizationProviderContract;

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

// @public
export type AuthorizationProviderListByServiceNextResponse = AuthorizationProviderCollection;

// @public
export interface AuthorizationProviderListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type AuthorizationProviderListByServiceResponse = AuthorizationProviderCollection;

// @public
export interface AuthorizationProviderOAuth2GrantTypes {
    authorizationCode?: {
        [propertyName: string]: string;
    };
    clientCredentials?: {
        [propertyName: string]: string;
    };
}

// @public
export interface AuthorizationProviderOAuth2Settings {
    grantTypes?: AuthorizationProviderOAuth2GrantTypes;
    redirectUrl?: string;
}

// @public
export interface AuthorizationServer {
    createOrUpdate(resourceGroupName: string, serviceName: string, authsid: string, parameters: AuthorizationServerContract, options?: AuthorizationServerCreateOrUpdateOptionalParams): Promise<AuthorizationServerCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, authsid: string, ifMatch: string, options?: AuthorizationServerDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, authsid: string, options?: AuthorizationServerGetOptionalParams): Promise<AuthorizationServerGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, authsid: string, options?: AuthorizationServerGetEntityTagOptionalParams): Promise<AuthorizationServerGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: AuthorizationServerListByServiceOptionalParams): PagedAsyncIterableIterator<AuthorizationServerContract>;
    listSecrets(resourceGroupName: string, serviceName: string, authsid: string, options?: AuthorizationServerListSecretsOptionalParams): Promise<AuthorizationServerListSecretsResponse>;
    update(resourceGroupName: string, serviceName: string, authsid: string, ifMatch: string, parameters: AuthorizationServerUpdateContract, options?: AuthorizationServerUpdateOptionalParams): Promise<AuthorizationServerUpdateResponse>;
}

// @public
export interface AuthorizationServerCollection {
    count?: number;
    nextLink?: string;
    value?: AuthorizationServerContract[];
}

// @public
export interface AuthorizationServerContract extends ProxyResource {
    authorizationEndpoint?: string;
    authorizationMethods?: AuthorizationMethod[];
    bearerTokenSendingMethods?: BearerTokenSendingMethod[];
    clientAuthenticationMethod?: ClientAuthenticationMethod[];
    clientId?: string;
    clientRegistrationEndpoint?: string;
    clientSecret?: string;
    defaultScope?: string;
    description?: string;
    displayName?: string;
    grantTypes?: GrantType[];
    resourceOwnerPassword?: string;
    resourceOwnerUsername?: string;
    supportState?: boolean;
    tokenBodyParameters?: TokenBodyParameterContract[];
    tokenEndpoint?: string;
    useInApiDocumentation?: boolean;
    useInTestConsole?: boolean;
}

// @public
export interface AuthorizationServerContractBaseProperties {
    authorizationMethods?: AuthorizationMethod[];
    bearerTokenSendingMethods?: BearerTokenSendingMethod[];
    clientAuthenticationMethod?: ClientAuthenticationMethod[];
    defaultScope?: string;
    description?: string;
    resourceOwnerPassword?: string;
    resourceOwnerUsername?: string;
    supportState?: boolean;
    tokenBodyParameters?: TokenBodyParameterContract[];
    tokenEndpoint?: string;
}

// @public
export interface AuthorizationServerContractProperties extends AuthorizationServerContractBaseProperties {
    authorizationEndpoint: string;
    clientId: string;
    clientRegistrationEndpoint: string;
    clientSecret?: string;
    displayName: string;
    grantTypes: GrantType[];
    useInApiDocumentation?: boolean;
    useInTestConsole?: boolean;
}

// @public
export interface AuthorizationServerCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface AuthorizationServerCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type AuthorizationServerCreateOrUpdateResponse = AuthorizationServerCreateOrUpdateHeaders & AuthorizationServerContract;

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

// @public
export interface AuthorizationServerGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type AuthorizationServerGetEntityTagResponse = AuthorizationServerGetEntityTagHeaders;

// @public
export interface AuthorizationServerGetHeaders {
    eTag?: string;
}

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

// @public
export type AuthorizationServerGetResponse = AuthorizationServerGetHeaders & AuthorizationServerContract;

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

// @public
export type AuthorizationServerListByServiceNextResponse = AuthorizationServerCollection;

// @public
export interface AuthorizationServerListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type AuthorizationServerListByServiceResponse = AuthorizationServerCollection;

// @public
export interface AuthorizationServerListSecretsHeaders {
    eTag?: string;
}

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

// @public
export type AuthorizationServerListSecretsResponse = AuthorizationServerListSecretsHeaders & AuthorizationServerSecretsContract;

// @public
export interface AuthorizationServerSecretsContract {
    clientSecret?: string;
    resourceOwnerPassword?: string;
    resourceOwnerUsername?: string;
}

// @public
export interface AuthorizationServerUpdateContract extends ProxyResource {
    authorizationEndpoint?: string;
    authorizationMethods?: AuthorizationMethod[];
    bearerTokenSendingMethods?: BearerTokenSendingMethod[];
    clientAuthenticationMethod?: ClientAuthenticationMethod[];
    clientId?: string;
    clientRegistrationEndpoint?: string;
    clientSecret?: string;
    defaultScope?: string;
    description?: string;
    displayName?: string;
    grantTypes?: GrantType[];
    resourceOwnerPassword?: string;
    resourceOwnerUsername?: string;
    supportState?: boolean;
    tokenBodyParameters?: TokenBodyParameterContract[];
    tokenEndpoint?: string;
    useInApiDocumentation?: boolean;
    useInTestConsole?: boolean;
}

// @public
export interface AuthorizationServerUpdateContractProperties extends AuthorizationServerContractBaseProperties {
    authorizationEndpoint?: string;
    clientId?: string;
    clientRegistrationEndpoint?: string;
    clientSecret?: string;
    displayName?: string;
    grantTypes?: GrantType[];
    useInApiDocumentation?: boolean;
    useInTestConsole?: boolean;
}

// @public
export interface AuthorizationServerUpdateHeaders {
    eTag?: string;
}

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

// @public
export type AuthorizationServerUpdateResponse = AuthorizationServerUpdateHeaders & AuthorizationServerContract;

// @public
export type AuthorizationType = string;

// @public
export interface Backend {
    createOrUpdate(resourceGroupName: string, serviceName: string, backendId: string, parameters: BackendContract, options?: BackendCreateOrUpdateOptionalParams): Promise<BackendCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, backendId: string, ifMatch: string, options?: BackendDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, backendId: string, options?: BackendGetOptionalParams): Promise<BackendGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, backendId: string, options?: BackendGetEntityTagOptionalParams): Promise<BackendGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: BackendListByServiceOptionalParams): PagedAsyncIterableIterator<BackendContract>;
    reconnect(resourceGroupName: string, serviceName: string, backendId: string, options?: BackendReconnectOptionalParams): Promise<void>;
    update(resourceGroupName: string, serviceName: string, backendId: string, ifMatch: string, parameters: BackendUpdateParameters, options?: BackendUpdateOptionalParams): Promise<BackendUpdateResponse>;
}

// @public
export interface BackendAuthorizationHeaderCredentials {
    parameter: string;
    scheme: string;
}

// @public
export interface BackendBaseParameters {
    circuitBreaker?: BackendCircuitBreaker;
    credentials?: BackendCredentialsContract;
    description?: string;
    // (undocumented)
    pool?: BackendBaseParametersPool;
    properties?: BackendProperties;
    proxy?: BackendProxyContract;
    resourceId?: string;
    title?: string;
    tls?: BackendTlsProperties;
    type?: BackendType;
}

// @public (undocumented)
export interface BackendBaseParametersPool extends BackendPool {
}

// @public
export interface BackendCircuitBreaker {
    rules?: CircuitBreakerRule[];
}

// @public
export interface BackendCollection {
    count?: number;
    nextLink?: string;
    value?: BackendContract[];
}

// @public
export interface BackendConfiguration {
    subnet?: BackendSubnetConfiguration;
}

// @public
export interface BackendContract extends ProxyResource {
    circuitBreaker?: BackendCircuitBreaker;
    credentials?: BackendCredentialsContract;
    description?: string;
    // (undocumented)
    pool?: BackendBaseParametersPool;
    properties?: BackendProperties;
    protocol?: BackendProtocol;
    proxy?: BackendProxyContract;
    resourceId?: string;
    title?: string;
    tls?: BackendTlsProperties;
    typePropertiesType?: BackendType;
    url?: string;
}

// @public
export interface BackendContractProperties extends BackendBaseParameters {
    protocol: BackendProtocol;
    url: string;
}

// @public
export interface BackendCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface BackendCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type BackendCreateOrUpdateResponse = BackendCreateOrUpdateHeaders & BackendContract;

// @public
export interface BackendCredentialsContract {
    authorization?: BackendAuthorizationHeaderCredentials;
    certificate?: string[];
    certificateIds?: string[];
    header?: {
        [propertyName: string]: string[];
    };
    query?: {
        [propertyName: string]: string[];
    };
}

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

// @public
export interface BackendGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type BackendGetEntityTagResponse = BackendGetEntityTagHeaders;

// @public
export interface BackendGetHeaders {
    eTag?: string;
}

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

// @public
export type BackendGetResponse = BackendGetHeaders & BackendContract;

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

// @public
export type BackendListByServiceNextResponse = BackendCollection;

// @public
export interface BackendListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type BackendListByServiceResponse = BackendCollection;

// @public
export interface BackendPool {
    services?: BackendPoolItem[];
}

// @public
export interface BackendPoolItem {
    id: string;
    priority?: number;
    weight?: number;
}

// @public
export interface BackendProperties {
    serviceFabricCluster?: BackendServiceFabricClusterProperties;
}

// @public
export type BackendProtocol = string;

// @public
export interface BackendProxyContract {
    password?: string;
    url: string;
    username?: string;
}

// @public
export interface BackendReconnectContract extends ProxyResource {
    after?: string;
}

// @public
export interface BackendReconnectOptionalParams extends coreClient.OperationOptions {
    parameters?: BackendReconnectContract;
}

// @public
export interface BackendServiceFabricClusterProperties {
    clientCertificateId?: string;
    clientCertificatethumbprint?: string;
    managementEndpoints: string[];
    maxPartitionResolutionRetries?: number;
    serverCertificateThumbprints?: string[];
    serverX509Names?: X509CertificateName[];
}

// @public
export interface BackendSubnetConfiguration {
    id?: string;
}

// @public
export interface BackendTlsProperties {
    validateCertificateChain?: boolean;
    validateCertificateName?: boolean;
}

// @public
export type BackendType = string;

// @public
export interface BackendUpdateHeaders {
    eTag?: string;
}

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

// @public
export interface BackendUpdateParameterProperties extends BackendBaseParameters {
    protocol?: BackendProtocol;
    url?: string;
}

// @public
export interface BackendUpdateParameters {
    circuitBreaker?: BackendCircuitBreaker;
    credentials?: BackendCredentialsContract;
    description?: string;
    // (undocumented)
    pool?: BackendBaseParametersPool;
    properties?: BackendProperties;
    protocol?: BackendProtocol;
    proxy?: BackendProxyContract;
    resourceId?: string;
    title?: string;
    tls?: BackendTlsProperties;
    type?: BackendType;
    url?: string;
}

// @public
export type BackendUpdateResponse = BackendUpdateHeaders & BackendContract;

// @public
export type BearerTokenSendingMethod = string;

// @public
export type BearerTokenSendingMethods = string;

// @public
export interface BodyDiagnosticSettings {
    bytes?: number;
}

// @public
interface Cache_2 {
    createOrUpdate(resourceGroupName: string, serviceName: string, cacheId: string, parameters: CacheContract, options?: CacheCreateOrUpdateOptionalParams): Promise<CacheCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, cacheId: string, ifMatch: string, options?: CacheDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, cacheId: string, options?: CacheGetOptionalParams): Promise<CacheGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, cacheId: string, options?: CacheGetEntityTagOptionalParams): Promise<CacheGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: CacheListByServiceOptionalParams): PagedAsyncIterableIterator<CacheContract>;
    update(resourceGroupName: string, serviceName: string, cacheId: string, ifMatch: string, parameters: CacheUpdateParameters, options?: CacheUpdateOptionalParams): Promise<CacheUpdateResponse>;
}
export { Cache_2 as Cache }

// @public
export interface CacheCollection {
    count?: number;
    nextLink?: string;
    value?: CacheContract[];
}

// @public
export interface CacheContract extends ProxyResource {
    connectionString?: string;
    description?: string;
    resourceId?: string;
    useFromLocation?: string;
}

// @public
export interface CacheCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface CacheCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type CacheCreateOrUpdateResponse = CacheCreateOrUpdateHeaders & CacheContract;

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

// @public
export interface CacheGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type CacheGetEntityTagResponse = CacheGetEntityTagHeaders;

// @public
export interface CacheGetHeaders {
    eTag?: string;
}

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

// @public
export type CacheGetResponse = CacheGetHeaders & CacheContract;

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

// @public
export type CacheListByServiceNextResponse = CacheCollection;

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

// @public
export type CacheListByServiceResponse = CacheCollection;

// @public
export interface CacheUpdateHeaders {
    eTag?: string;
}

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

// @public
export interface CacheUpdateParameters {
    connectionString?: string;
    description?: string;
    resourceId?: string;
    useFromLocation?: string;
}

// @public
export type CacheUpdateResponse = CacheUpdateHeaders & CacheContract;

// @public
export interface Certificate {
    createOrUpdate(resourceGroupName: string, serviceName: string, certificateId: string, parameters: CertificateCreateOrUpdateParameters, options?: CertificateCreateOrUpdateOptionalParams): Promise<CertificateCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, certificateId: string, ifMatch: string, options?: CertificateDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, certificateId: string, options?: CertificateGetOptionalParams): Promise<CertificateGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, certificateId: string, options?: CertificateGetEntityTagOptionalParams): Promise<CertificateGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: CertificateListByServiceOptionalParams): PagedAsyncIterableIterator<CertificateContract>;
    refreshSecret(resourceGroupName: string, serviceName: string, certificateId: string, options?: CertificateRefreshSecretOptionalParams): Promise<CertificateRefreshSecretResponse>;
}

// @public
export interface CertificateCollection {
    count?: number;
    nextLink?: string;
    value?: CertificateContract[];
}

// @public
export interface CertificateConfiguration {
    certificate?: CertificateInformation;
    certificatePassword?: string;
    encodedCertificate?: string;
    storeName: CertificateConfigurationStoreName;
}

// @public
export type CertificateConfigurationStoreName = string;

// @public
export interface CertificateContract extends ProxyResource {
    expirationDate?: Date;
    keyVault?: KeyVaultContractProperties;
    subject?: string;
    thumbprint?: string;
}

// @public
export interface CertificateCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface CertificateCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export interface CertificateCreateOrUpdateParameters {
    data?: string;
    keyVault?: KeyVaultContractCreateProperties;
    password?: string;
}

// @public
export type CertificateCreateOrUpdateResponse = CertificateCreateOrUpdateHeaders & CertificateContract;

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

// @public
export interface CertificateGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type CertificateGetEntityTagResponse = CertificateGetEntityTagHeaders;

// @public
export interface CertificateGetHeaders {
    eTag?: string;
}

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

// @public
export type CertificateGetResponse = CertificateGetHeaders & CertificateContract;

// @public
export interface CertificateInformation {
    expiry: Date;
    subject: string;
    thumbprint: string;
}

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

// @public
export type CertificateListByServiceNextResponse = CertificateCollection;

// @public
export interface CertificateListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    isKeyVaultRefreshFailed?: boolean;
    skip?: number;
    top?: number;
}

// @public
export type CertificateListByServiceResponse = CertificateCollection;

// @public
export interface CertificateRefreshSecretHeaders {
    eTag?: string;
}

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

// @public
export type CertificateRefreshSecretResponse = CertificateRefreshSecretHeaders & CertificateContract;

// @public
export type CertificateSource = string;

// @public
export type CertificateStatus = string;

// @public
export interface CircuitBreakerFailureCondition {
    count?: number;
    errorReasons?: string[];
    interval?: string;
    percentage?: number;
    statusCodeRanges?: FailureStatusCodeRange[];
}

// @public
export interface CircuitBreakerRule {
    acceptRetryAfter?: boolean;
    failureCondition?: CircuitBreakerFailureCondition;
    name?: string;
    tripDuration?: string;
}

// @public
export type ClientAuthenticationMethod = string;

// @public
export interface ClientSecretContract {
    clientSecret?: string;
}

// @public
export interface ConfigurationApi {
    legacyApi?: LegacyApiState;
}

// @public
export type ConfigurationIdName = string;

// @public
export type Confirmation = string;

// @public
export type ConnectionStatus = string;

// @public
export type ConnectivityCheckProtocol = string;

// @public
export interface ConnectivityCheckRequest {
    destination: ConnectivityCheckRequestDestination;
    preferredIPVersion?: PreferredIPVersion;
    protocol?: ConnectivityCheckProtocol;
    protocolConfiguration?: ConnectivityCheckRequestProtocolConfiguration;
    source: ConnectivityCheckRequestSource;
}

// @public
export interface ConnectivityCheckRequestDestination {
    address: string;
    port: number;
}

// @public
export interface ConnectivityCheckRequestProtocolConfiguration {
    httpConfiguration?: ConnectivityCheckRequestProtocolConfigurationHttpConfiguration;
}

// @public
export interface ConnectivityCheckRequestProtocolConfigurationHttpConfiguration {
    headers?: HttpHeader[];
    method?: Method;
    validStatusCodes?: number[];
}

// @public
export interface ConnectivityCheckRequestSource {
    instance?: number;
    region: string;
}

// @public
export interface ConnectivityCheckResponse {
    readonly avgLatencyInMs?: number;
    readonly connectionStatus?: ConnectionStatus;
    readonly hops?: ConnectivityHop[];
    readonly maxLatencyInMs?: number;
    readonly minLatencyInMs?: number;
    readonly probesFailed?: number;
    readonly probesSent?: number;
}

// @public
export interface ConnectivityHop {
    readonly address?: string;
    readonly id?: string;
    readonly issues?: ConnectivityIssue[];
    readonly nextHopIds?: string[];
    readonly resourceId?: string;
    readonly type?: string;
}

// @public
export interface ConnectivityIssue {
    readonly context?: {
        [propertyName: string]: string;
    }[];
    readonly origin?: Origin;
    readonly severity?: Severity;
    readonly type?: IssueType;
}

// @public
export interface ConnectivityStatusContract {
    error?: string;
    isOptional: boolean;
    lastStatusChange: Date;
    lastUpdated: Date;
    name: string;
    resourceType: string;
    status: ConnectivityStatusType;
}

// @public
export type ConnectivityStatusType = string;

// @public
export type ContentFormat = string;

// @public
export interface ContentItem {
    createOrUpdate(resourceGroupName: string, serviceName: string, contentTypeId: string, contentItemId: string, parameters: ContentItemContract, options?: ContentItemCreateOrUpdateOptionalParams): Promise<ContentItemCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, contentTypeId: string, contentItemId: string, ifMatch: string, options?: ContentItemDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, contentTypeId: string, contentItemId: string, options?: ContentItemGetOptionalParams): Promise<ContentItemGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, contentTypeId: string, contentItemId: string, options?: ContentItemGetEntityTagOptionalParams): Promise<ContentItemGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, contentTypeId: string, options?: ContentItemListByServiceOptionalParams): PagedAsyncIterableIterator<ContentItemContract>;
}

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

// @public
export interface ContentItemContract extends ProxyResource {
    properties?: {
        [propertyName: string]: any;
    };
}

// @public
export interface ContentItemCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ContentItemCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ContentItemCreateOrUpdateResponse = ContentItemCreateOrUpdateHeaders & ContentItemContract;

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

// @public
export interface ContentItemGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ContentItemGetEntityTagResponse = ContentItemGetEntityTagHeaders;

// @public
export interface ContentItemGetHeaders {
    eTag?: string;
}

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

// @public
export type ContentItemGetResponse = ContentItemGetHeaders & ContentItemContract;

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

// @public
export type ContentItemListByServiceNextResponse = ContentItemCollection;

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

// @public
export type ContentItemListByServiceResponse = ContentItemCollection;

// @public
export interface ContentType {
    createOrUpdate(resourceGroupName: string, serviceName: string, contentTypeId: string, parameters: ContentTypeContract, options?: ContentTypeCreateOrUpdateOptionalParams): Promise<ContentTypeCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, contentTypeId: string, ifMatch: string, options?: ContentTypeDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, contentTypeId: string, options?: ContentTypeGetOptionalParams): Promise<ContentTypeGetResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: ContentTypeListByServiceOptionalParams): PagedAsyncIterableIterator<ContentTypeContract>;
}

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

// @public
export interface ContentTypeContract extends ProxyResource {
    description?: string;
    idPropertiesId?: string;
    namePropertiesName?: string;
    schema?: Record<string, unknown>;
    version?: string;
}

// @public
export interface ContentTypeCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ContentTypeCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ContentTypeCreateOrUpdateResponse = ContentTypeCreateOrUpdateHeaders & ContentTypeContract;

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

// @public
export interface ContentTypeGetHeaders {
    eTag?: string;
}

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

// @public
export type ContentTypeGetResponse = ContentTypeGetHeaders & ContentTypeContract;

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

// @public
export type ContentTypeListByServiceNextResponse = ContentTypeCollection;

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

// @public
export type ContentTypeListByServiceResponse = ContentTypeCollection;

// @public
export type CreatedByType = string;

// @public (undocumented)
export interface DataMasking {
    headers?: DataMaskingEntity[];
    queryParams?: DataMaskingEntity[];
}

// @public (undocumented)
export interface DataMaskingEntity {
    mode?: DataMaskingMode;
    value?: string;
}

// @public
export type DataMaskingMode = string;

// @public
export interface DelegationSettings {
    createOrUpdate(resourceGroupName: string, serviceName: string, parameters: PortalDelegationSettings, options?: DelegationSettingsCreateOrUpdateOptionalParams): Promise<DelegationSettingsCreateOrUpdateResponse>;
    get(resourceGroupName: string, serviceName: string, options?: DelegationSettingsGetOptionalParams): Promise<DelegationSettingsGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, options?: DelegationSettingsGetEntityTagOptionalParams): Promise<DelegationSettingsGetEntityTagResponse>;
    listSecrets(resourceGroupName: string, serviceName: string, options?: DelegationSettingsListSecretsOptionalParams): Promise<DelegationSettingsListSecretsResponse>;
    update(resourceGroupName: string, serviceName: string, ifMatch: string, parameters: PortalDelegationSettings, options?: DelegationSettingsUpdateOptionalParams): Promise<void>;
}

// @public
export interface DelegationSettingsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type DelegationSettingsCreateOrUpdateResponse = PortalDelegationSettings;

// @public
export interface DelegationSettingsGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type DelegationSettingsGetEntityTagResponse = DelegationSettingsGetEntityTagHeaders;

// @public
export interface DelegationSettingsGetHeaders {
    eTag?: string;
}

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

// @public
export type DelegationSettingsGetResponse = DelegationSettingsGetHeaders & PortalDelegationSettings;

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

// @public
export type DelegationSettingsListSecretsResponse = PortalSettingValidationKeyContract;

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

// @public
export interface DeletedServiceContract extends ProxyResource {
    deletionDate?: Date;
    readonly location?: string;
    scheduledPurgeDate?: Date;
    serviceId?: string;
}

// @public
export interface DeletedServices {
    beginPurge(serviceName: string, location: string, options?: DeletedServicesPurgeOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginPurgeAndWait(serviceName: string, location: string, options?: DeletedServicesPurgeOptionalParams): Promise<void>;
    getByName(serviceName: string, location: string, options?: DeletedServicesGetByNameOptionalParams): Promise<DeletedServicesGetByNameResponse>;
    listBySubscription(options?: DeletedServicesListBySubscriptionOptionalParams): PagedAsyncIterableIterator<DeletedServiceContract>;
}

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

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

// @public
export type DeletedServicesGetByNameResponse = DeletedServiceContract;

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

// @public
export type DeletedServicesListBySubscriptionNextResponse = DeletedServicesCollection;

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

// @public
export type DeletedServicesListBySubscriptionResponse = DeletedServicesCollection;

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

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

// @public
export interface DeployConfigurationParameters {
    branch?: string;
    force?: boolean;
}

// @public
export type DeveloperPortalStatus = string;

// @public
export interface Diagnostic {
    createOrUpdate(resourceGroupName: string, serviceName: string, diagnosticId: string, parameters: DiagnosticContract, options?: DiagnosticCreateOrUpdateOptionalParams): Promise<DiagnosticCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, diagnosticId: string, ifMatch: string, options?: DiagnosticDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, diagnosticId: string, options?: DiagnosticGetOptionalParams): Promise<DiagnosticGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, diagnosticId: string, options?: DiagnosticGetEntityTagOptionalParams): Promise<DiagnosticGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: DiagnosticListByServiceOptionalParams): PagedAsyncIterableIterator<DiagnosticContract>;
    update(resourceGroupName: string, serviceName: string, diagnosticId: string, ifMatch: string, parameters: DiagnosticContract, options?: DiagnosticUpdateOptionalParams): Promise<DiagnosticUpdateResponse>;
}

// @public
export interface DiagnosticCollection {
    count?: number;
    nextLink?: string;
    value?: DiagnosticContract[];
}

// @public
export interface DiagnosticContract extends ProxyResource {
    alwaysLog?: AlwaysLog;
    backend?: PipelineDiagnosticSettings;
    frontend?: PipelineDiagnosticSettings;
    httpCorrelationProtocol?: HttpCorrelationProtocol;
    logClientIp?: boolean;
    loggerId?: string;
    metrics?: boolean;
    operationNameFormat?: OperationNameFormat;
    sampling?: SamplingSettings;
    verbosity?: Verbosity;
}

// @public
export interface DiagnosticCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface DiagnosticCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type DiagnosticCreateOrUpdateResponse = DiagnosticCreateOrUpdateHeaders & DiagnosticContract;

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

// @public
export interface DiagnosticGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type DiagnosticGetEntityTagResponse = DiagnosticGetEntityTagHeaders;

// @public
export interface DiagnosticGetHeaders {
    eTag?: string;
}

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

// @public
export type DiagnosticGetResponse = DiagnosticGetHeaders & DiagnosticContract;

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

// @public
export type DiagnosticListByServiceNextResponse = DiagnosticCollection;

// @public
export interface DiagnosticListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type DiagnosticListByServiceResponse = DiagnosticCollection;

// @public
export interface DiagnosticUpdateContract extends ProxyResource {
    alwaysLog?: AlwaysLog;
    backend?: PipelineDiagnosticSettings;
    frontend?: PipelineDiagnosticSettings;
    httpCorrelationProtocol?: HttpCorrelationProtocol;
    logClientIp?: boolean;
    loggerId?: string;
    metrics?: boolean;
    operationNameFormat?: OperationNameFormat;
    sampling?: SamplingSettings;
    verbosity?: Verbosity;
}

// @public
export interface DiagnosticUpdateHeaders {
    eTag?: string;
}

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

// @public
export type DiagnosticUpdateResponse = DiagnosticUpdateHeaders & DiagnosticContract;

// @public
export interface Documentation {
    createOrUpdate(resourceGroupName: string, serviceName: string, documentationId: string, parameters: DocumentationContract, options?: DocumentationCreateOrUpdateOptionalParams): Promise<DocumentationCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, documentationId: string, ifMatch: string, options?: DocumentationDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, documentationId: string, options?: DocumentationGetOptionalParams): Promise<DocumentationGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, documentationId: string, options?: DocumentationGetEntityTagOptionalParams): Promise<DocumentationGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: DocumentationListByServiceOptionalParams): PagedAsyncIterableIterator<DocumentationContract>;
    update(resourceGroupName: string, serviceName: string, documentationId: string, ifMatch: string, parameters: DocumentationUpdateContract, options?: DocumentationUpdateOptionalParams): Promise<DocumentationUpdateResponse>;
}

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

// @public
export interface DocumentationContract extends ProxyResource {
    content?: string;
    title?: string;
}

// @public
export interface DocumentationCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface DocumentationCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type DocumentationCreateOrUpdateResponse = DocumentationCreateOrUpdateHeaders & DocumentationContract;

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

// @public
export interface DocumentationGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type DocumentationGetEntityTagResponse = DocumentationGetEntityTagHeaders;

// @public
export interface DocumentationGetHeaders {
    eTag?: string;
}

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

// @public
export type DocumentationGetResponse = DocumentationGetHeaders & DocumentationContract;

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

// @public
export type DocumentationListByServiceNextResponse = DocumentationCollection;

// @public
export interface DocumentationListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type DocumentationListByServiceResponse = DocumentationCollection;

// @public
export interface DocumentationUpdateContract {
    content?: string;
    title?: string;
}

// @public
export interface DocumentationUpdateHeaders {
    eTag?: string;
}

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

// @public
export type DocumentationUpdateResponse = DocumentationUpdateHeaders & DocumentationContract;

// @public
export interface EmailTemplate {
    createOrUpdate(resourceGroupName: string, serviceName: string, templateName: TemplateName, parameters: EmailTemplateUpdateParameters, options?: EmailTemplateCreateOrUpdateOptionalParams): Promise<EmailTemplateCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, templateName: TemplateName, ifMatch: string, options?: EmailTemplateDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, templateName: TemplateName, options?: EmailTemplateGetOptionalParams): Promise<EmailTemplateGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, templateName: TemplateName, options?: EmailTemplateGetEntityTagOptionalParams): Promise<EmailTemplateGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: EmailTemplateListByServiceOptionalParams): PagedAsyncIterableIterator<EmailTemplateContract>;
    update(resourceGroupName: string, serviceName: string, templateName: TemplateName, ifMatch: string, parameters: EmailTemplateUpdateParameters, options?: EmailTemplateUpdateOptionalParams): Promise<EmailTemplateUpdateResponse>;
}

// @public
export interface EmailTemplateCollection {
    count?: number;
    nextLink?: string;
    value?: EmailTemplateContract[];
}

// @public
export interface EmailTemplateContract extends ProxyResource {
    body?: string;
    description?: string;
    readonly isDefault?: boolean;
    parameters?: EmailTemplateParametersContractProperties[];
    subject?: string;
    title?: string;
}

// @public
export interface EmailTemplateCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type EmailTemplateCreateOrUpdateResponse = EmailTemplateContract;

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

// @public
export interface EmailTemplateGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type EmailTemplateGetEntityTagResponse = EmailTemplateGetEntityTagHeaders;

// @public
export interface EmailTemplateGetHeaders {
    eTag?: string;
}

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

// @public
export type EmailTemplateGetResponse = EmailTemplateGetHeaders & EmailTemplateContract;

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

// @public
export type EmailTemplateListByServiceNextResponse = EmailTemplateCollection;

// @public
export interface EmailTemplateListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type EmailTemplateListByServiceResponse = EmailTemplateCollection;

// @public
export interface EmailTemplateParametersContractProperties {
    description?: string;
    name?: string;
    title?: string;
}

// @public
export interface EmailTemplateUpdateHeaders {
    eTag?: string;
}

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

// @public
export interface EmailTemplateUpdateParameters {
    body?: string;
    description?: string;
    parameters?: EmailTemplateParametersContractProperties[];
    subject?: string;
    title?: string;
}

// @public
export type EmailTemplateUpdateResponse = EmailTemplateUpdateHeaders & EmailTemplateContract;

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

// @public
export interface EndpointDetail {
    port?: number;
    region?: 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 ErrorFieldContract {
    code?: string;
    message?: string;
    target?: string;
}

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

// @public
export interface ErrorResponseBody {
    code?: string;
    details?: ErrorFieldContract[];
    message?: string;
}

// @public
export type ExportApi = string;

// @public
export type ExportFormat = string;

// @public
export type ExportResultFormat = string;

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

// @public
export interface FrontendConfiguration {
    readonly defaultHostname?: string;
}

// @public
export interface Gateway {
    createOrUpdate(resourceGroupName: string, serviceName: string, gatewayId: string, parameters: GatewayContract, options?: GatewayCreateOrUpdateOptionalParams): Promise<GatewayCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, gatewayId: string, ifMatch: string, options?: GatewayDeleteOptionalParams): Promise<void>;
    generateToken(resourceGroupName: string, serviceName: string, gatewayId: string, parameters: GatewayTokenRequestContract, options?: GatewayGenerateTokenOptionalParams): Promise<GatewayGenerateTokenResponse>;
    get(resourceGroupName: string, serviceName: string, gatewayId: string, options?: GatewayGetOptionalParams): Promise<GatewayGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, gatewayId: string, options?: GatewayGetEntityTagOptionalParams): Promise<GatewayGetEntityTagResponse>;
    invalidateDebugCredentials(resourceGroupName: string, serviceName: string, gatewayId: string, options?: GatewayInvalidateDebugCredentialsOptionalParams): Promise<void>;
    listByService(resourceGroupName: string, serviceName: string, options?: GatewayListByServiceOptionalParams): PagedAsyncIterableIterator<GatewayContract>;
    listDebugCredentials(resourceGroupName: string, serviceName: string, gatewayId: string, parameters: GatewayListDebugCredentialsContract, options?: GatewayListDebugCredentialsOptionalParams): Promise<GatewayListDebugCredentialsResponse>;
    listKeys(resourceGroupName: string, serviceName: string, gatewayId: string, options?: GatewayListKeysOptionalParams): Promise<GatewayListKeysResponse>;
    listTrace(resourceGroupName: string, serviceName: string, gatewayId: string, parameters: GatewayListTraceContract, options?: GatewayListTraceOptionalParams): Promise<GatewayListTraceResponse>;
    regenerateKey(resourceGroupName: string, serviceName: string, gatewayId: string, parameters: GatewayKeyRegenerationRequestContract, options?: GatewayRegenerateKeyOptionalParams): Promise<void>;
    update(resourceGroupName: string, serviceName: string, gatewayId: string, ifMatch: string, parameters: GatewayContract, options?: GatewayUpdateOptionalParams): Promise<GatewayUpdateResponse>;
}

// @public
export interface GatewayApi {
    createOrUpdate(resourceGroupName: string, serviceName: string, gatewayId: string, apiId: string, options?: GatewayApiCreateOrUpdateOptionalParams): Promise<GatewayApiCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, gatewayId: string, apiId: string, options?: GatewayApiDeleteOptionalParams): Promise<void>;
    getEntityTag(resourceGroupName: string, serviceName: string, gatewayId: string, apiId: string, options?: GatewayApiGetEntityTagOptionalParams): Promise<GatewayApiGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, gatewayId: string, options?: GatewayApiListByServiceOptionalParams): PagedAsyncIterableIterator<ApiContract>;
}

// @public
export interface GatewayApiCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    parameters?: AssociationContract;
}

// @public
export type GatewayApiCreateOrUpdateResponse = ApiContract;

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

// @public
export interface GatewayApiGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type GatewayApiGetEntityTagResponse = GatewayApiGetEntityTagHeaders;

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

// @public
export type GatewayApiListByServiceNextResponse = ApiCollection;

// @public
export interface GatewayApiListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type GatewayApiListByServiceResponse = ApiCollection;

// @public
export interface GatewayCertificateAuthority {
    createOrUpdate(resourceGroupName: string, serviceName: string, gatewayId: string, certificateId: string, parameters: GatewayCertificateAuthorityContract, options?: GatewayCertificateAuthorityCreateOrUpdateOptionalParams): Promise<GatewayCertificateAuthorityCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, gatewayId: string, certificateId: string, ifMatch: string, options?: GatewayCertificateAuthorityDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, gatewayId: string, certificateId: string, options?: GatewayCertificateAuthorityGetOptionalParams): Promise<GatewayCertificateAuthorityGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, gatewayId: string, certificateId: string, options?: GatewayCertificateAuthorityGetEntityTagOptionalParams): Promise<GatewayCertificateAuthorityGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, gatewayId: string, options?: GatewayCertificateAuthorityListByServiceOptionalParams): PagedAsyncIterableIterator<GatewayCertificateAuthorityContract>;
}

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

// @public
export interface GatewayCertificateAuthorityContract extends ProxyResource {
    isTrusted?: boolean;
}

// @public
export interface GatewayCertificateAuthorityCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface GatewayCertificateAuthorityCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type GatewayCertificateAuthorityCreateOrUpdateResponse = GatewayCertificateAuthorityCreateOrUpdateHeaders & GatewayCertificateAuthorityContract;

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

// @public
export interface GatewayCertificateAuthorityGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type GatewayCertificateAuthorityGetEntityTagResponse = GatewayCertificateAuthorityGetEntityTagHeaders;

// @public
export interface GatewayCertificateAuthorityGetHeaders {
    eTag?: string;
}

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

// @public
export type GatewayCertificateAuthorityGetResponse = GatewayCertificateAuthorityGetHeaders & GatewayCertificateAuthorityContract;

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

// @public
export type GatewayCertificateAuthorityListByServiceNextResponse = GatewayCertificateAuthorityCollection;

// @public
export interface GatewayCertificateAuthorityListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type GatewayCertificateAuthorityListByServiceResponse = GatewayCertificateAuthorityCollection;

// @public
export interface GatewayCollection {
    count?: number;
    readonly nextLink?: string;
    readonly value?: GatewayContract[];
}

// @public
export interface GatewayConfigurationApi {
    readonly hostname?: string;
}

// @public
export interface GatewayContract extends ProxyResource {
    description?: string;
    locationData?: ResourceLocationDataContract;
}

// @public
export interface GatewayCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface GatewayCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type GatewayCreateOrUpdateResponse = GatewayCreateOrUpdateHeaders & GatewayContract;

// @public
export interface GatewayDebugCredentialsContract {
    token?: string;
}

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

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

// @public
export type GatewayGenerateTokenResponse = GatewayTokenContract;

// @public
export interface GatewayGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type GatewayGetEntityTagResponse = GatewayGetEntityTagHeaders;

// @public
export interface GatewayGetHeaders {
    eTag?: string;
}

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

// @public
export type GatewayGetResponse = GatewayGetHeaders & GatewayContract;

// @public
export interface GatewayHostnameConfiguration {
    createOrUpdate(resourceGroupName: string, serviceName: string, gatewayId: string, hcId: string, parameters: GatewayHostnameConfigurationContract, options?: GatewayHostnameConfigurationCreateOrUpdateOptionalParams): Promise<GatewayHostnameConfigurationCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, gatewayId: string, hcId: string, ifMatch: string, options?: GatewayHostnameConfigurationDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, gatewayId: string, hcId: string, options?: GatewayHostnameConfigurationGetOptionalParams): Promise<GatewayHostnameConfigurationGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, gatewayId: string, hcId: string, options?: GatewayHostnameConfigurationGetEntityTagOptionalParams): Promise<GatewayHostnameConfigurationGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, gatewayId: string, options?: GatewayHostnameConfigurationListByServiceOptionalParams): PagedAsyncIterableIterator<GatewayHostnameConfigurationContract>;
}

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

// @public
export interface GatewayHostnameConfigurationContract extends ProxyResource {
    certificateId?: string;
    hostname?: string;
    http2Enabled?: boolean;
    negotiateClientCertificate?: boolean;
    tls10Enabled?: boolean;
    tls11Enabled?: boolean;
}

// @public
export interface GatewayHostnameConfigurationCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface GatewayHostnameConfigurationCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type GatewayHostnameConfigurationCreateOrUpdateResponse = GatewayHostnameConfigurationCreateOrUpdateHeaders & GatewayHostnameConfigurationContract;

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

// @public
export interface GatewayHostnameConfigurationGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type GatewayHostnameConfigurationGetEntityTagResponse = GatewayHostnameConfigurationGetEntityTagHeaders;

// @public
export interface GatewayHostnameConfigurationGetHeaders {
    eTag?: string;
}

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

// @public
export type GatewayHostnameConfigurationGetResponse = GatewayHostnameConfigurationGetHeaders & GatewayHostnameConfigurationContract;

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

// @public
export type GatewayHostnameConfigurationListByServiceNextResponse = GatewayHostnameConfigurationCollection;

// @public
export interface GatewayHostnameConfigurationListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type GatewayHostnameConfigurationListByServiceResponse = GatewayHostnameConfigurationCollection;

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

// @public
export interface GatewayKeyRegenerationRequestContract {
    keyType: KeyType_2;
}

// @public
export interface GatewayKeysContract {
    primary?: string;
    secondary?: string;
}

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

// @public
export type GatewayListByServiceNextResponse = GatewayCollection;

// @public
export interface GatewayListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type GatewayListByServiceResponse = GatewayCollection;

// @public
export interface GatewayListDebugCredentialsContract {
    apiId: string;
    credentialsExpireAfter?: string;
    purposes: GatewayListDebugCredentialsContractPurpose[];
}

// @public
export type GatewayListDebugCredentialsContractPurpose = string;

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

// @public
export type GatewayListDebugCredentialsResponse = GatewayDebugCredentialsContract;

// @public
export interface GatewayListKeysHeaders {
    eTag?: string;
}

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

// @public
export type GatewayListKeysResponse = GatewayListKeysHeaders & GatewayKeysContract;

// @public
export interface GatewayListTraceContract {
    traceId?: string;
}

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

// @public
export type GatewayListTraceResponse = {
    [propertyName: string]: any;
};

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

// @public
export interface GatewayResourceSkuResult {
    readonly capacity?: GatewaySkuCapacity;
    readonly resourceType?: string;
    readonly sku?: GatewaySku;
}

// @public
export interface GatewayResourceSkuResults {
    nextLink?: string;
    value: GatewayResourceSkuResult[];
}

// @public
export interface GatewaySku {
    name?: ApiGatewaySkuType;
}

// @public
export interface GatewaySkuCapacity {
    readonly default?: number;
    readonly maximum?: number;
    readonly minimum?: number;
    readonly scaleType?: GatewaySkuCapacityScaleType;
}

// @public
export type GatewaySkuCapacityScaleType = string;

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

// @public
export interface GatewayTokenRequestContract {
    expiry: Date;
    keyType: KeyType_2;
}

// @public
export interface GatewayUpdateHeaders {
    eTag?: string;
}

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

// @public
export type GatewayUpdateResponse = GatewayUpdateHeaders & GatewayContract;

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

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

// @public
export interface GlobalSchema {
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, schemaId: string, parameters: GlobalSchemaContract, options?: GlobalSchemaCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<GlobalSchemaCreateOrUpdateResponse>, GlobalSchemaCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, schemaId: string, parameters: GlobalSchemaContract, options?: GlobalSchemaCreateOrUpdateOptionalParams): Promise<GlobalSchemaCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, schemaId: string, ifMatch: string, options?: GlobalSchemaDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, schemaId: string, options?: GlobalSchemaGetOptionalParams): Promise<GlobalSchemaGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, schemaId: string, options?: GlobalSchemaGetEntityTagOptionalParams): Promise<GlobalSchemaGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: GlobalSchemaListByServiceOptionalParams): PagedAsyncIterableIterator<GlobalSchemaContract>;
}

// @public
export interface GlobalSchemaCollection {
    count?: number;
    readonly nextLink?: string;
    readonly value?: GlobalSchemaContract[];
}

// @public
export interface GlobalSchemaContract extends ProxyResource {
    description?: string;
    document?: Record<string, unknown>;
    readonly provisioningState?: string;
    schemaType?: SchemaType;
    value?: any;
}

// @public
export interface GlobalSchemaCreateOrUpdateHeaders {
    azureAsyncOperation?: string;
    eTag?: string;
    location?: string;
}

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

// @public
export type GlobalSchemaCreateOrUpdateResponse = GlobalSchemaCreateOrUpdateHeaders & GlobalSchemaContract;

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

// @public
export interface GlobalSchemaGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type GlobalSchemaGetEntityTagResponse = GlobalSchemaGetEntityTagHeaders;

// @public
export interface GlobalSchemaGetHeaders {
    eTag?: string;
}

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

// @public
export type GlobalSchemaGetResponse = GlobalSchemaGetHeaders & GlobalSchemaContract;

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

// @public
export type GlobalSchemaListByServiceNextResponse = GlobalSchemaCollection;

// @public
export interface GlobalSchemaListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type GlobalSchemaListByServiceResponse = GlobalSchemaCollection;

// @public
export type GrantType = string;

// @public
export interface GraphQLApiResolver {
    createOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, resolverId: string, parameters: ResolverContract, options?: GraphQLApiResolverCreateOrUpdateOptionalParams): Promise<GraphQLApiResolverCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, apiId: string, resolverId: string, ifMatch: string, options?: GraphQLApiResolverDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, apiId: string, resolverId: string, options?: GraphQLApiResolverGetOptionalParams): Promise<GraphQLApiResolverGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, resolverId: string, options?: GraphQLApiResolverGetEntityTagOptionalParams): Promise<GraphQLApiResolverGetEntityTagResponse>;
    listByApi(resourceGroupName: string, serviceName: string, apiId: string, options?: GraphQLApiResolverListByApiOptionalParams): PagedAsyncIterableIterator<ResolverContract>;
    update(resourceGroupName: string, serviceName: string, apiId: string, resolverId: string, ifMatch: string, parameters: ResolverUpdateContract, options?: GraphQLApiResolverUpdateOptionalParams): Promise<GraphQLApiResolverUpdateResponse>;
}

// @public
export interface GraphQLApiResolverCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface GraphQLApiResolverCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type GraphQLApiResolverCreateOrUpdateResponse = GraphQLApiResolverCreateOrUpdateHeaders & ResolverContract;

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

// @public
export interface GraphQLApiResolverGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type GraphQLApiResolverGetEntityTagResponse = GraphQLApiResolverGetEntityTagHeaders;

// @public
export interface GraphQLApiResolverGetHeaders {
    eTag?: string;
}

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

// @public
export type GraphQLApiResolverGetResponse = GraphQLApiResolverGetHeaders & ResolverContract;

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

// @public
export type GraphQLApiResolverListByApiNextResponse = ResolverCollection;

// @public
export interface GraphQLApiResolverListByApiOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type GraphQLApiResolverListByApiResponse = ResolverCollection;

// @public
export interface GraphQLApiResolverPolicy {
    createOrUpdate(resourceGroupName: string, serviceName: string, apiId: string, resolverId: string, policyId: PolicyIdName, parameters: PolicyContract, options?: GraphQLApiResolverPolicyCreateOrUpdateOptionalParams): Promise<GraphQLApiResolverPolicyCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, apiId: string, resolverId: string, policyId: PolicyIdName, ifMatch: string, options?: GraphQLApiResolverPolicyDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, apiId: string, resolverId: string, policyId: PolicyIdName, options?: GraphQLApiResolverPolicyGetOptionalParams): Promise<GraphQLApiResolverPolicyGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, apiId: string, resolverId: string, policyId: PolicyIdName, options?: GraphQLApiResolverPolicyGetEntityTagOptionalParams): Promise<GraphQLApiResolverPolicyGetEntityTagResponse>;
    listByResolver(resourceGroupName: string, serviceName: string, apiId: string, resolverId: string, options?: GraphQLApiResolverPolicyListByResolverOptionalParams): PagedAsyncIterableIterator<PolicyContract>;
}

// @public
export interface GraphQLApiResolverPolicyCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface GraphQLApiResolverPolicyCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type GraphQLApiResolverPolicyCreateOrUpdateResponse = GraphQLApiResolverPolicyCreateOrUpdateHeaders & PolicyContract;

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

// @public
export interface GraphQLApiResolverPolicyGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type GraphQLApiResolverPolicyGetEntityTagResponse = GraphQLApiResolverPolicyGetEntityTagHeaders;

// @public
export interface GraphQLApiResolverPolicyGetHeaders {
    eTag?: string;
}

// @public
export interface GraphQLApiResolverPolicyGetOptionalParams extends coreClient.OperationOptions {
    format?: PolicyExportFormat;
}

// @public
export type GraphQLApiResolverPolicyGetResponse = GraphQLApiResolverPolicyGetHeaders & PolicyContract;

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

// @public
export type GraphQLApiResolverPolicyListByResolverNextResponse = PolicyCollection;

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

// @public
export type GraphQLApiResolverPolicyListByResolverResponse = PolicyCollection;

// @public
export interface GraphQLApiResolverUpdateHeaders {
    eTag?: string;
}

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

// @public
export type GraphQLApiResolverUpdateResponse = GraphQLApiResolverUpdateHeaders & ResolverContract;

// @public
export interface Group {
    createOrUpdate(resourceGroupName: string, serviceName: string, groupId: string, parameters: GroupCreateParameters, options?: GroupCreateOrUpdateOptionalParams): Promise<GroupCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, groupId: string, ifMatch: string, options?: GroupDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, groupId: string, options?: GroupGetOptionalParams): Promise<GroupGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, groupId: string, options?: GroupGetEntityTagOptionalParams): Promise<GroupGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: GroupListByServiceOptionalParams): PagedAsyncIterableIterator<GroupContract>;
    update(resourceGroupName: string, serviceName: string, groupId: string, ifMatch: string, parameters: GroupUpdateParameters, options?: GroupUpdateOptionalParams): Promise<GroupUpdateResponse>;
}

// @public
export interface GroupCollection {
    count?: number;
    nextLink?: string;
    value?: GroupContract[];
}

// @public
export interface GroupContract extends ProxyResource {
    readonly builtIn?: boolean;
    description?: string;
    displayName?: string;
    externalId?: string;
    typePropertiesType?: GroupType;
}

// @public
export interface GroupContractProperties {
    readonly builtIn?: boolean;
    description?: string;
    displayName: string;
    externalId?: string;
    type?: GroupType;
}

// @public
export interface GroupCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface GroupCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type GroupCreateOrUpdateResponse = GroupCreateOrUpdateHeaders & GroupContract;

// @public
export interface GroupCreateParameters {
    description?: string;
    displayName?: string;
    externalId?: string;
    type?: GroupType;
}

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

// @public
export interface GroupGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type GroupGetEntityTagResponse = GroupGetEntityTagHeaders;

// @public
export interface GroupGetHeaders {
    eTag?: string;
}

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

// @public
export type GroupGetResponse = GroupGetHeaders & GroupContract;

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

// @public
export type GroupListByServiceNextResponse = GroupCollection;

// @public
export interface GroupListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type GroupListByServiceResponse = GroupCollection;

// @public
export type GroupType = "custom" | "system" | "external";

// @public
export interface GroupUpdateHeaders {
    eTag?: string;
}

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

// @public
export interface GroupUpdateParameters {
    description?: string;
    displayName?: string;
    externalId?: string;
    type?: GroupType;
}

// @public
export type GroupUpdateResponse = GroupUpdateHeaders & GroupContract;

// @public
export interface GroupUser {
    checkEntityExists(resourceGroupName: string, serviceName: string, groupId: string, userId: string, options?: GroupUserCheckEntityExistsOptionalParams): Promise<GroupUserCheckEntityExistsResponse>;
    create(resourceGroupName: string, serviceName: string, groupId: string, userId: string, options?: GroupUserCreateOptionalParams): Promise<GroupUserCreateResponse>;
    delete(resourceGroupName: string, serviceName: string, groupId: string, userId: string, options?: GroupUserDeleteOptionalParams): Promise<void>;
    list(resourceGroupName: string, serviceName: string, groupId: string, options?: GroupUserListOptionalParams): PagedAsyncIterableIterator<UserContract>;
}

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

// @public
export type GroupUserCheckEntityExistsResponse = {
    body: boolean;
};

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

// @public
export type GroupUserCreateResponse = UserContract;

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

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

// @public
export type GroupUserListNextResponse = UserCollection;

// @public
export interface GroupUserListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type GroupUserListResponse = UserCollection;

// @public
export interface HostnameConfiguration {
    certificate?: CertificateInformation;
    certificatePassword?: string;
    certificateSource?: CertificateSource;
    certificateStatus?: CertificateStatus;
    defaultSslBinding?: boolean;
    encodedCertificate?: string;
    hostName: string;
    identityClientId?: string;
    keyVaultId?: string;
    negotiateClientCertificate?: boolean;
    type: HostnameType;
}

// @public
export type HostnameType = string;

// @public
export type HttpCorrelationProtocol = string;

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

// @public
export interface HttpMessageDiagnostic {
    body?: BodyDiagnosticSettings;
    dataMasking?: DataMasking;
    headers?: string[];
}

// @public
export interface IdentityProvider {
    createOrUpdate(resourceGroupName: string, serviceName: string, identityProviderName: IdentityProviderType, parameters: IdentityProviderCreateContract, options?: IdentityProviderCreateOrUpdateOptionalParams): Promise<IdentityProviderCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, identityProviderName: IdentityProviderType, ifMatch: string, options?: IdentityProviderDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, identityProviderName: IdentityProviderType, options?: IdentityProviderGetOptionalParams): Promise<IdentityProviderGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, identityProviderName: IdentityProviderType, options?: IdentityProviderGetEntityTagOptionalParams): Promise<IdentityProviderGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: IdentityProviderListByServiceOptionalParams): PagedAsyncIterableIterator<IdentityProviderContract>;
    listSecrets(resourceGroupName: string, serviceName: string, identityProviderName: IdentityProviderType, options?: IdentityProviderListSecretsOptionalParams): Promise<IdentityProviderListSecretsResponse>;
    update(resourceGroupName: string, serviceName: string, identityProviderName: IdentityProviderType, ifMatch: string, parameters: IdentityProviderUpdateParameters, options?: IdentityProviderUpdateOptionalParams): Promise<IdentityProviderUpdateResponse>;
}

// @public
export interface IdentityProviderBaseParameters {
    allowedTenants?: string[];
    authority?: string;
    clientLibrary?: string;
    passwordResetPolicyName?: string;
    profileEditingPolicyName?: string;
    signinPolicyName?: string;
    signinTenant?: string;
    signupPolicyName?: string;
    type?: IdentityProviderType;
}

// @public
export interface IdentityProviderContract extends ProxyResource {
    allowedTenants?: string[];
    authority?: string;
    clientId?: string;
    clientLibrary?: string;
    clientSecret?: string;
    passwordResetPolicyName?: string;
    profileEditingPolicyName?: string;
    signinPolicyName?: string;
    signinTenant?: string;
    signupPolicyName?: string;
    typePropertiesType?: IdentityProviderType;
}

// @public
export interface IdentityProviderContractProperties extends IdentityProviderBaseParameters {
    clientId: string;
    clientSecret?: string;
}

// @public
export interface IdentityProviderCreateContract extends ProxyResource {
    allowedTenants?: string[];
    authority?: string;
    clientId?: string;
    clientLibrary?: string;
    clientSecret?: string;
    passwordResetPolicyName?: string;
    profileEditingPolicyName?: string;
    signinPolicyName?: string;
    signinTenant?: string;
    signupPolicyName?: string;
    typePropertiesType?: IdentityProviderType;
}

// @public
export interface IdentityProviderCreateContractProperties extends IdentityProviderBaseParameters {
    clientId: string;
    clientSecret: string;
}

// @public
export interface IdentityProviderCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface IdentityProviderCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type IdentityProviderCreateOrUpdateResponse = IdentityProviderCreateOrUpdateHeaders & IdentityProviderContract;

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

// @public
export interface IdentityProviderGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type IdentityProviderGetEntityTagResponse = IdentityProviderGetEntityTagHeaders;

// @public
export interface IdentityProviderGetHeaders {
    eTag?: string;
}

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

// @public
export type IdentityProviderGetResponse = IdentityProviderGetHeaders & IdentityProviderContract;

// @public
export interface IdentityProviderList {
    count?: number;
    nextLink?: string;
    value?: IdentityProviderContract[];
}

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

// @public
export type IdentityProviderListByServiceNextResponse = IdentityProviderList;

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

// @public
export type IdentityProviderListByServiceResponse = IdentityProviderList;

// @public
export interface IdentityProviderListSecretsHeaders {
    eTag?: string;
}

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

// @public
export type IdentityProviderListSecretsResponse = IdentityProviderListSecretsHeaders & ClientSecretContract;

// @public
export type IdentityProviderType = string;

// @public
export interface IdentityProviderUpdateHeaders {
    eTag?: string;
}

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

// @public
export interface IdentityProviderUpdateParameters {
    allowedTenants?: string[];
    authority?: string;
    clientId?: string;
    clientLibrary?: string;
    clientSecret?: string;
    passwordResetPolicyName?: string;
    profileEditingPolicyName?: string;
    signinPolicyName?: string;
    signinTenant?: string;
    signupPolicyName?: string;
    type?: IdentityProviderType;
}

// @public
export interface IdentityProviderUpdateProperties extends IdentityProviderBaseParameters {
    clientId?: string;
    clientSecret?: string;
}

// @public
export type IdentityProviderUpdateResponse = IdentityProviderUpdateHeaders & IdentityProviderContract;

// @public
export interface Issue {
    get(resourceGroupName: string, serviceName: string, issueId: string, options?: IssueGetOptionalParams): Promise<IssueGetResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: IssueListByServiceOptionalParams): PagedAsyncIterableIterator<IssueContract>;
}

// @public
export interface IssueAttachmentCollection {
    count?: number;
    readonly nextLink?: string;
    readonly value?: IssueAttachmentContract[];
}

// @public
export interface IssueAttachmentContract extends ProxyResource {
    content?: string;
    contentFormat?: string;
    title?: string;
}

// @public
export interface IssueCollection {
    count?: number;
    readonly nextLink?: string;
    readonly value?: IssueContract[];
}

// @public
export interface IssueCommentCollection {
    count?: number;
    readonly nextLink?: string;
    readonly value?: IssueCommentContract[];
}

// @public
export interface IssueCommentContract extends ProxyResource {
    createdDate?: Date;
    text?: string;
    userId?: string;
}

// @public
export interface IssueContract extends ProxyResource {
    apiId?: string;
    createdDate?: Date;
    description?: string;
    state?: State;
    title?: string;
    userId?: string;
}

// @public
export interface IssueContractBaseProperties {
    apiId?: string;
    createdDate?: Date;
    state?: State;
}

// @public
export interface IssueContractProperties extends IssueContractBaseProperties {
    description: string;
    title: string;
    userId: string;
}

// @public
export interface IssueGetHeaders {
    eTag?: string;
}

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

// @public
export type IssueGetResponse = IssueGetHeaders & IssueContract;

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

// @public
export type IssueListByServiceNextResponse = IssueCollection;

// @public
export interface IssueListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type IssueListByServiceResponse = IssueCollection;

// @public
export type IssueType = string;

// @public
export interface IssueUpdateContract {
    apiId?: string;
    createdDate?: Date;
    description?: string;
    state?: State;
    title?: string;
    userId?: string;
}

// @public
export interface IssueUpdateContractProperties extends IssueContractBaseProperties {
    description?: string;
    title?: string;
    userId?: string;
}

// @public
type KeyType_2 = "primary" | "secondary";
export { KeyType_2 as KeyType }

// @public
export interface KeyVaultContractCreateProperties {
    identityClientId?: string;
    secretIdentifier?: string;
}

// @public
export interface KeyVaultContractProperties extends KeyVaultContractCreateProperties {
    lastStatus?: KeyVaultLastAccessStatusContractProperties;
}

// @public
export interface KeyVaultLastAccessStatusContractProperties {
    code?: string;
    message?: string;
    timeStampUtc?: Date;
}

// @public
export type KeyVaultRefreshState = string;

// @public
export enum KnownAccessIdName {
    Access = "access",
    GitAccess = "gitAccess"
}

// @public
export enum KnownAccessType {
    AccessKey = "AccessKey",
    SystemAssignedManagedIdentity = "SystemAssignedManagedIdentity",
    UserAssignedManagedIdentity = "UserAssignedManagedIdentity"
}

// @public
export enum KnownAlwaysLog {
    AllErrors = "allErrors"
}

// @public
export enum KnownApiGatewaySkuType {
    Standard = "Standard",
    WorkspaceGatewayPremium = "WorkspaceGatewayPremium",
    WorkspaceGatewayStandard = "WorkspaceGatewayStandard"
}

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

// @public
export enum KnownApiType {
    Graphql = "graphql",
    Grpc = "grpc",
    Http = "http",
    Odata = "odata",
    Soap = "soap",
    Websocket = "websocket"
}

// @public
export enum KnownApiVersionSetContractDetailsVersioningScheme {
    Header = "Header",
    Query = "Query",
    Segment = "Segment"
}

// @public
export enum KnownAppType {
    DeveloperPortal = "developerPortal",
    Portal = "portal"
}

// @public
export enum KnownAuthorizationType {
    OAuth2 = "OAuth2"
}

// @public
export enum KnownBackendProtocol {
    Http = "http",
    Soap = "soap"
}

// @public
export enum KnownBackendType {
    Pool = "Pool",
    Single = "Single"
}

// @public
export enum KnownBearerTokenSendingMethod {
    AuthorizationHeader = "authorizationHeader",
    Query = "query"
}

// @public
export enum KnownBearerTokenSendingMethods {
    AuthorizationHeader = "authorizationHeader",
    Query = "query"
}

// @public
export enum KnownCertificateConfigurationStoreName {
    CertificateAuthority = "CertificateAuthority",
    Root = "Root"
}

// @public
export enum KnownCertificateSource {
    BuiltIn = "BuiltIn",
    Custom = "Custom",
    KeyVault = "KeyVault",
    Managed = "Managed"
}

// @public
export enum KnownCertificateStatus {
    Completed = "Completed",
    Failed = "Failed",
    InProgress = "InProgress"
}

// @public
export enum KnownClientAuthenticationMethod {
    Basic = "Basic",
    Body = "Body"
}

// @public
export enum KnownConfigurationIdName {
    Configuration = "configuration"
}

// @public
export enum KnownConfirmation {
    Invite = "invite",
    Signup = "signup"
}

// @public
export enum KnownConnectionStatus {
    Connected = "Connected",
    Degraded = "Degraded",
    Disconnected = "Disconnected",
    Unknown = "Unknown"
}

// @public
export enum KnownConnectivityCheckProtocol {
    Http = "HTTP",
    Https = "HTTPS",
    TCP = "TCP"
}

// @public
export enum KnownConnectivityStatusType {
    Failure = "failure",
    Initializing = "initializing",
    Success = "success"
}

// @public
export enum KnownContentFormat {
    GraphqlLink = "graphql-link",
    Grpc = "grpc",
    GrpcLink = "grpc-link",
    Odata = "odata",
    OdataLink = "odata-link",
    Openapi = "openapi",
    OpenapiJson = "openapi+json",
    OpenapiJsonLink = "openapi+json-link",
    OpenapiLink = "openapi-link",
    SwaggerJson = "swagger-json",
    SwaggerLinkJson = "swagger-link-json",
    WadlLinkJson = "wadl-link-json",
    WadlXml = "wadl-xml",
    Wsdl = "wsdl",
    WsdlLink = "wsdl-link"
}

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

// @public
export enum KnownDataMaskingMode {
    Hide = "Hide",
    Mask = "Mask"
}

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

// @public
export enum KnownExportApi {
    True = "true"
}

// @public
export enum KnownExportFormat {
    Openapi = "openapi-link",
    OpenapiJson = "openapi+json-link",
    Swagger = "swagger-link",
    Wadl = "wadl-link",
    Wsdl = "wsdl-link"
}

// @public
export enum KnownExportResultFormat {
    OpenApi = "openapi-link",
    Swagger = "swagger-link-json",
    Wadl = "wadl-link-json",
    Wsdl = "wsdl-link+xml"
}

// @public
export enum KnownGatewayListDebugCredentialsContractPurpose {
    Tracing = "tracing"
}

// @public
export enum KnownGatewaySkuCapacityScaleType {
    Automatic = "Automatic",
    Manual = "Manual",
    None = "None"
}

// @public
export enum KnownGrantType {
    AuthorizationCode = "authorizationCode",
    ClientCredentials = "clientCredentials",
    Implicit = "implicit",
    ResourceOwnerPassword = "resourceOwnerPassword"
}

// @public
export enum KnownHostnameType {
    ConfigurationApi = "ConfigurationApi",
    DeveloperPortal = "DeveloperPortal",
    Management = "Management",
    Portal = "Portal",
    Proxy = "Proxy",
    Scm = "Scm"
}

// @public
export enum KnownHttpCorrelationProtocol {
    Legacy = "Legacy",
    None = "None",
    W3C = "W3C"
}

// @public
export enum KnownIdentityProviderType {
    Aad = "aad",
    AadB2C = "aadB2C",
    Facebook = "facebook",
    Google = "google",
    Microsoft = "microsoft",
    Twitter = "twitter"
}

// @public
export enum KnownIssueType {
    AgentStopped = "AgentStopped",
    DnsResolution = "DnsResolution",
    GuestFirewall = "GuestFirewall",
    NetworkSecurityRule = "NetworkSecurityRule",
    Platform = "Platform",
    PortThrottled = "PortThrottled",
    SocketBind = "SocketBind",
    Unknown = "Unknown",
    UserDefinedRoute = "UserDefinedRoute"
}

// @public
export enum KnownKeyVaultRefreshState {
    False = "false",
    True = "true"
}

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

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

// @public
export enum KnownLoggerType {
    ApplicationInsights = "applicationInsights",
    AzureEventHub = "azureEventHub",
    AzureMonitor = "azureMonitor"
}

// @public
export enum KnownMethod {
    GET = "GET",
    Post = "POST"
}

// @public
export enum KnownMigrateToStv2Mode {
    NewIP = "NewIP",
    PreserveIp = "PreserveIp"
}

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

// @public
export enum KnownNotificationName {
    AccountClosedPublisher = "AccountClosedPublisher",
    BCC = "BCC",
    NewApplicationNotificationMessage = "NewApplicationNotificationMessage",
    NewIssuePublisherNotificationMessage = "NewIssuePublisherNotificationMessage",
    PurchasePublisherNotificationMessage = "PurchasePublisherNotificationMessage",
    QuotaLimitApproachingPublisherNotificationMessage = "QuotaLimitApproachingPublisherNotificationMessage",
    RequestPublisherNotificationMessage = "RequestPublisherNotificationMessage"
}

// @public
export enum KnownOAuth2GrantType {
    AuthorizationCode = "AuthorizationCode",
    ClientCredentials = "ClientCredentials"
}

// @public
export enum KnownOperationNameFormat {
    Name = "Name",
    Url = "Url"
}

// @public
export enum KnownOrigin {
    Inbound = "Inbound",
    Local = "Local",
    Outbound = "Outbound"
}

// @public
export enum KnownPlatformVersion {
    Mtv1 = "mtv1",
    Stv1 = "stv1",
    Stv2 = "stv2",
    Stv21 = "stv2.1",
    Undetermined = "undetermined"
}

// @public
export enum KnownPolicyComplianceState {
    Compliant = "Compliant",
    NonCompliant = "NonCompliant",
    Pending = "Pending"
}

// @public
export enum KnownPolicyContentFormat {
    Rawxml = "rawxml",
    RawxmlLink = "rawxml-link",
    Xml = "xml",
    XmlLink = "xml-link"
}

// @public
export enum KnownPolicyExportFormat {
    Rawxml = "rawxml",
    Xml = "xml"
}

// @public
export enum KnownPolicyFragmentContentFormat {
    Rawxml = "rawxml",
    Xml = "xml"
}

// @public
export enum KnownPolicyIdName {
    Policy = "policy"
}

// @public
export enum KnownPolicyRestrictionRequireBase {
    False = "false",
    True = "true"
}

// @public
export enum KnownPortalRevisionStatus {
    Completed = "completed",
    Failed = "failed",
    Pending = "pending",
    Publishing = "publishing"
}

// @public
export enum KnownPortalSettingsCspMode {
    Disabled = "disabled",
    Enabled = "enabled",
    ReportOnly = "reportOnly"
}

// @public
export enum KnownPreferredIPVersion {
    IPv4 = "IPv4"
}

// @public
export enum KnownPrivateEndpointConnectionProvisioningState {
    Creating = "Creating",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded"
}

// @public
export enum KnownPrivateEndpointServiceConnectionStatus {
    Approved = "Approved",
    Pending = "Pending",
    Rejected = "Rejected"
}

// @public
export enum KnownProtocol {
    Http = "http",
    Https = "https",
    Ws = "ws",
    Wss = "wss"
}

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

// @public
export enum KnownResourceSkuCapacityScaleType {
    Automatic = "automatic",
    Manual = "manual",
    None = "none"
}

// @public
export enum KnownSamplingType {
    Fixed = "fixed"
}

// @public
export enum KnownSchemaType {
    Json = "json",
    Xml = "xml"
}

// @public
export enum KnownSettingsTypeName {
    Public = "public"
}

// @public
export enum KnownSeverity {
    Error = "Error",
    Warning = "Warning"
}

// @public
export enum KnownSkuType {
    Basic = "Basic",
    BasicV2 = "BasicV2",
    Consumption = "Consumption",
    Developer = "Developer",
    Isolated = "Isolated",
    Premium = "Premium",
    Standard = "Standard",
    StandardV2 = "StandardV2"
}

// @public
export enum KnownSoapApiType {
    GraphQL = "graphql",
    GRPC = "grpc",
    OData = "odata",
    SoapPassThrough = "soap",
    SoapToRest = "http",
    WebSocket = "websocket"
}

// @public
export enum KnownState {
    Closed = "closed",
    Open = "open",
    Proposed = "proposed",
    Removed = "removed",
    Resolved = "resolved"
}

// @public
export enum KnownTemplateName {
    AccountClosedDeveloper = "accountClosedDeveloper",
    ApplicationApprovedNotificationMessage = "applicationApprovedNotificationMessage",
    ConfirmSignUpIdentityDefault = "confirmSignUpIdentityDefault",
    EmailChangeIdentityDefault = "emailChangeIdentityDefault",
    InviteUserNotificationMessage = "inviteUserNotificationMessage",
    NewCommentNotificationMessage = "newCommentNotificationMessage",
    NewDeveloperNotificationMessage = "newDeveloperNotificationMessage",
    NewIssueNotificationMessage = "newIssueNotificationMessage",
    PasswordResetByAdminNotificationMessage = "passwordResetByAdminNotificationMessage",
    PasswordResetIdentityDefault = "passwordResetIdentityDefault",
    PurchaseDeveloperNotificationMessage = "purchaseDeveloperNotificationMessage",
    QuotaLimitApproachingDeveloperNotificationMessage = "quotaLimitApproachingDeveloperNotificationMessage",
    RejectDeveloperNotificationMessage = "rejectDeveloperNotificationMessage",
    RequestDeveloperNotificationMessage = "requestDeveloperNotificationMessage"
}

// @public
export enum KnownTranslateRequiredQueryParametersConduct {
    Query = "query",
    Template = "template"
}

// @public
export enum KnownUserState {
    Active = "active",
    Blocked = "blocked",
    Deleted = "deleted",
    Pending = "pending"
}

// @public
export enum KnownVerbosity {
    Error = "error",
    Information = "information",
    Verbose = "verbose"
}

// @public
export enum KnownVersioningScheme {
    Header = "Header",
    Query = "Query",
    Segment = "Segment"
}

// @public
export enum KnownVirtualNetworkType {
    External = "External",
    Internal = "Internal",
    None = "None"
}

// @public
export type LegacyApiState = string;

// @public
export type LegacyPortalStatus = string;

// @public
export interface Logger {
    createOrUpdate(resourceGroupName: string, serviceName: string, loggerId: string, parameters: LoggerContract, options?: LoggerCreateOrUpdateOptionalParams): Promise<LoggerCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, loggerId: string, ifMatch: string, options?: LoggerDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, loggerId: string, options?: LoggerGetOptionalParams): Promise<LoggerGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, loggerId: string, options?: LoggerGetEntityTagOptionalParams): Promise<LoggerGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: LoggerListByServiceOptionalParams): PagedAsyncIterableIterator<LoggerContract>;
    update(resourceGroupName: string, serviceName: string, loggerId: string, ifMatch: string, parameters: LoggerUpdateContract, options?: LoggerUpdateOptionalParams): Promise<LoggerUpdateResponse>;
}

// @public
export interface LoggerCollection {
    count?: number;
    nextLink?: string;
    value?: LoggerContract[];
}

// @public
export interface LoggerContract extends ProxyResource {
    credentials?: {
        [propertyName: string]: string;
    };
    description?: string;
    isBuffered?: boolean;
    loggerType?: LoggerType;
    resourceId?: string;
}

// @public
export interface LoggerCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface LoggerCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type LoggerCreateOrUpdateResponse = LoggerCreateOrUpdateHeaders & LoggerContract;

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

// @public
export interface LoggerGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type LoggerGetEntityTagResponse = LoggerGetEntityTagHeaders;

// @public
export interface LoggerGetHeaders {
    eTag?: string;
}

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

// @public
export type LoggerGetResponse = LoggerGetHeaders & LoggerContract;

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

// @public
export type LoggerListByServiceNextResponse = LoggerCollection;

// @public
export interface LoggerListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type LoggerListByServiceResponse = LoggerCollection;

// @public
export type LoggerType = string;

// @public
export interface LoggerUpdateContract {
    credentials?: {
        [propertyName: string]: string;
    };
    description?: string;
    isBuffered?: boolean;
    loggerType?: LoggerType;
}

// @public
export interface LoggerUpdateHeaders {
    eTag?: string;
}

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

// @public
export type LoggerUpdateResponse = LoggerUpdateHeaders & LoggerContract;

// @public
export type Method = string;

// @public
export interface MigrateToStv2Contract {
    mode?: MigrateToStv2Mode;
}

// @public
export type MigrateToStv2Mode = string;

// @public
export type NameAvailabilityReason = "Valid" | "Invalid" | "AlreadyExists";

// @public
export interface NamedValue {
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, namedValueId: string, parameters: NamedValueCreateContract, options?: NamedValueCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NamedValueCreateOrUpdateResponse>, NamedValueCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, namedValueId: string, parameters: NamedValueCreateContract, options?: NamedValueCreateOrUpdateOptionalParams): Promise<NamedValueCreateOrUpdateResponse>;
    beginRefreshSecret(resourceGroupName: string, serviceName: string, namedValueId: string, options?: NamedValueRefreshSecretOptionalParams): Promise<SimplePollerLike<OperationState<NamedValueRefreshSecretResponse>, NamedValueRefreshSecretResponse>>;
    beginRefreshSecretAndWait(resourceGroupName: string, serviceName: string, namedValueId: string, options?: NamedValueRefreshSecretOptionalParams): Promise<NamedValueRefreshSecretResponse>;
    beginUpdate(resourceGroupName: string, serviceName: string, namedValueId: string, ifMatch: string, parameters: NamedValueUpdateParameters, options?: NamedValueUpdateOptionalParams): Promise<SimplePollerLike<OperationState<NamedValueUpdateResponse>, NamedValueUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, serviceName: string, namedValueId: string, ifMatch: string, parameters: NamedValueUpdateParameters, options?: NamedValueUpdateOptionalParams): Promise<NamedValueUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, namedValueId: string, ifMatch: string, options?: NamedValueDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, namedValueId: string, options?: NamedValueGetOptionalParams): Promise<NamedValueGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, namedValueId: string, options?: NamedValueGetEntityTagOptionalParams): Promise<NamedValueGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: NamedValueListByServiceOptionalParams): PagedAsyncIterableIterator<NamedValueContract>;
    listValue(resourceGroupName: string, serviceName: string, namedValueId: string, options?: NamedValueListValueOptionalParams): Promise<NamedValueListValueResponse>;
}

// @public
export interface NamedValueCollection {
    count?: number;
    nextLink?: string;
    value?: NamedValueContract[];
}

// @public
export interface NamedValueContract extends ProxyResource {
    displayName?: string;
    keyVault?: KeyVaultContractProperties;
    readonly provisioningState?: string;
    secret?: boolean;
    tags?: string[];
    value?: string;
}

// @public
export interface NamedValueContractProperties extends NamedValueEntityBaseParameters {
    displayName: string;
    keyVault?: KeyVaultContractProperties;
    readonly provisioningState?: string;
    value?: string;
}

// @public
export interface NamedValueCreateContract extends ProxyResource {
    displayName?: string;
    keyVault?: KeyVaultContractCreateProperties;
    secret?: boolean;
    tags?: string[];
    value?: string;
}

// @public
export interface NamedValueCreateContractProperties extends NamedValueEntityBaseParameters {
    displayName: string;
    keyVault?: KeyVaultContractCreateProperties;
    value?: string;
}

// @public
export interface NamedValueCreateOrUpdateHeaders {
    azureAsyncOperation?: string;
    eTag?: string;
    location?: string;
}

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

// @public
export type NamedValueCreateOrUpdateResponse = NamedValueCreateOrUpdateHeaders & NamedValueContract;

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

// @public
export interface NamedValueEntityBaseParameters {
    secret?: boolean;
    tags?: string[];
}

// @public
export interface NamedValueGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type NamedValueGetEntityTagResponse = NamedValueGetEntityTagHeaders;

// @public
export interface NamedValueGetHeaders {
    eTag?: string;
}

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

// @public
export type NamedValueGetResponse = NamedValueGetHeaders & NamedValueContract;

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

// @public
export type NamedValueListByServiceNextResponse = NamedValueCollection;

// @public
export interface NamedValueListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    isKeyVaultRefreshFailed?: boolean;
    skip?: number;
    top?: number;
}

// @public
export type NamedValueListByServiceResponse = NamedValueCollection;

// @public
export interface NamedValueListValueHeaders {
    eTag?: string;
}

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

// @public
export type NamedValueListValueResponse = NamedValueListValueHeaders & NamedValueSecretContract;

// @public
export interface NamedValueRefreshSecretHeaders {
    eTag?: string;
}

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

// @public
export type NamedValueRefreshSecretResponse = NamedValueRefreshSecretHeaders & NamedValueContract;

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

// @public
export interface NamedValueUpdateHeaders {
    eTag?: string;
}

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

// @public
export interface NamedValueUpdateParameterProperties extends NamedValueEntityBaseParameters {
    displayName?: string;
    keyVault?: KeyVaultContractCreateProperties;
    value?: string;
}

// @public
export interface NamedValueUpdateParameters {
    displayName?: string;
    keyVault?: KeyVaultContractCreateProperties;
    secret?: boolean;
    tags?: string[];
    value?: string;
}

// @public
export type NamedValueUpdateResponse = NamedValueUpdateHeaders & NamedValueContract;

// @public
export type NatGatewayState = string;

// @public
export interface NetworkStatus {
    listByLocation(resourceGroupName: string, serviceName: string, locationName: string, options?: NetworkStatusListByLocationOptionalParams): Promise<NetworkStatusListByLocationResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: NetworkStatusListByServiceOptionalParams): Promise<NetworkStatusListByServiceResponse>;
}

// @public
export interface NetworkStatusContract {
    connectivityStatus: ConnectivityStatusContract[];
    dnsServers: string[];
}

// @public
export interface NetworkStatusContractByLocation {
    location?: string;
    networkStatus?: NetworkStatusContract;
}

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

// @public
export type NetworkStatusListByLocationResponse = NetworkStatusContract;

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

// @public
export type NetworkStatusListByServiceResponse = NetworkStatusContractByLocation[];

// @public
interface Notification_2 {
    createOrUpdate(resourceGroupName: string, serviceName: string, notificationName: NotificationName, options?: NotificationCreateOrUpdateOptionalParams): Promise<NotificationCreateOrUpdateResponse>;
    get(resourceGroupName: string, serviceName: string, notificationName: NotificationName, options?: NotificationGetOptionalParams): Promise<NotificationGetResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: NotificationListByServiceOptionalParams): PagedAsyncIterableIterator<NotificationContract>;
}
export { Notification_2 as Notification }

// @public
export interface NotificationCollection {
    count?: number;
    nextLink?: string;
    value?: NotificationContract[];
}

// @public
export interface NotificationContract extends ProxyResource {
    description?: string;
    recipients?: RecipientsContractProperties;
    title?: string;
}

// @public
export interface NotificationCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type NotificationCreateOrUpdateResponse = NotificationContract;

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

// @public
export type NotificationGetResponse = NotificationContract;

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

// @public
export type NotificationListByServiceNextResponse = NotificationCollection;

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

// @public
export type NotificationListByServiceResponse = NotificationCollection;

// @public
export type NotificationName = string;

// @public
export interface NotificationRecipientEmail {
    checkEntityExists(resourceGroupName: string, serviceName: string, notificationName: NotificationName, email: string, options?: NotificationRecipientEmailCheckEntityExistsOptionalParams): Promise<NotificationRecipientEmailCheckEntityExistsResponse>;
    createOrUpdate(resourceGroupName: string, serviceName: string, notificationName: NotificationName, email: string, options?: NotificationRecipientEmailCreateOrUpdateOptionalParams): Promise<NotificationRecipientEmailCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, notificationName: NotificationName, email: string, options?: NotificationRecipientEmailDeleteOptionalParams): Promise<void>;
    listByNotification(resourceGroupName: string, serviceName: string, notificationName: NotificationName, options?: NotificationRecipientEmailListByNotificationOptionalParams): Promise<NotificationRecipientEmailListByNotificationResponse>;
}

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

// @public
export type NotificationRecipientEmailCheckEntityExistsResponse = {
    body: boolean;
};

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

// @public
export type NotificationRecipientEmailCreateOrUpdateResponse = RecipientEmailContract;

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

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

// @public
export type NotificationRecipientEmailListByNotificationResponse = RecipientEmailCollection;

// @public
export interface NotificationRecipientUser {
    checkEntityExists(resourceGroupName: string, serviceName: string, notificationName: NotificationName, userId: string, options?: NotificationRecipientUserCheckEntityExistsOptionalParams): Promise<NotificationRecipientUserCheckEntityExistsResponse>;
    createOrUpdate(resourceGroupName: string, serviceName: string, notificationName: NotificationName, userId: string, options?: NotificationRecipientUserCreateOrUpdateOptionalParams): Promise<NotificationRecipientUserCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, notificationName: NotificationName, userId: string, options?: NotificationRecipientUserDeleteOptionalParams): Promise<void>;
    listByNotification(resourceGroupName: string, serviceName: string, notificationName: NotificationName, options?: NotificationRecipientUserListByNotificationOptionalParams): Promise<NotificationRecipientUserListByNotificationResponse>;
}

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

// @public
export type NotificationRecipientUserCheckEntityExistsResponse = {
    body: boolean;
};

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

// @public
export type NotificationRecipientUserCreateOrUpdateResponse = RecipientUserContract;

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

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

// @public
export type NotificationRecipientUserListByNotificationResponse = RecipientUserCollection;

// @public
export interface OAuth2AuthenticationSettingsContract {
    authorizationServerId?: string;
    scope?: string;
}

// @public
export type OAuth2GrantType = string;

// @public
export interface OpenIdAuthenticationSettingsContract {
    bearerTokenSendingMethods?: BearerTokenSendingMethods[];
    openidProviderId?: string;
}

// @public
export interface OpenIdConnectProvider {
    createOrUpdate(resourceGroupName: string, serviceName: string, opid: string, parameters: OpenidConnectProviderContract, options?: OpenIdConnectProviderCreateOrUpdateOptionalParams): Promise<OpenIdConnectProviderCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, opid: string, ifMatch: string, options?: OpenIdConnectProviderDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, opid: string, options?: OpenIdConnectProviderGetOptionalParams): Promise<OpenIdConnectProviderGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, opid: string, options?: OpenIdConnectProviderGetEntityTagOptionalParams): Promise<OpenIdConnectProviderGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: OpenIdConnectProviderListByServiceOptionalParams): PagedAsyncIterableIterator<OpenidConnectProviderContract>;
    listSecrets(resourceGroupName: string, serviceName: string, opid: string, options?: OpenIdConnectProviderListSecretsOptionalParams): Promise<OpenIdConnectProviderListSecretsResponse>;
    update(resourceGroupName: string, serviceName: string, opid: string, ifMatch: string, parameters: OpenidConnectProviderUpdateContract, options?: OpenIdConnectProviderUpdateOptionalParams): Promise<OpenIdConnectProviderUpdateResponse>;
}

// @public
export interface OpenIdConnectProviderCollection {
    count?: number;
    nextLink?: string;
    value?: OpenidConnectProviderContract[];
}

// @public
export interface OpenidConnectProviderContract extends ProxyResource {
    clientId?: string;
    clientSecret?: string;
    description?: string;
    displayName?: string;
    metadataEndpoint?: string;
    useInApiDocumentation?: boolean;
    useInTestConsole?: boolean;
}

// @public
export interface OpenIdConnectProviderCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface OpenIdConnectProviderCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type OpenIdConnectProviderCreateOrUpdateResponse = OpenIdConnectProviderCreateOrUpdateHeaders & OpenidConnectProviderContract;

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

// @public
export interface OpenIdConnectProviderGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type OpenIdConnectProviderGetEntityTagResponse = OpenIdConnectProviderGetEntityTagHeaders;

// @public
export interface OpenIdConnectProviderGetHeaders {
    eTag?: string;
}

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

// @public
export type OpenIdConnectProviderGetResponse = OpenIdConnectProviderGetHeaders & OpenidConnectProviderContract;

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

// @public
export type OpenIdConnectProviderListByServiceNextResponse = OpenIdConnectProviderCollection;

// @public
export interface OpenIdConnectProviderListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type OpenIdConnectProviderListByServiceResponse = OpenIdConnectProviderCollection;

// @public
export interface OpenIdConnectProviderListSecretsHeaders {
    eTag?: string;
}

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

// @public
export type OpenIdConnectProviderListSecretsResponse = OpenIdConnectProviderListSecretsHeaders & ClientSecretContract;

// @public
export interface OpenidConnectProviderUpdateContract {
    clientId?: string;
    clientSecret?: string;
    description?: string;
    displayName?: string;
    metadataEndpoint?: string;
    useInApiDocumentation?: boolean;
    useInTestConsole?: boolean;
}

// @public
export interface OpenIdConnectProviderUpdateHeaders {
    eTag?: string;
}

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

// @public
export type OpenIdConnectProviderUpdateResponse = OpenIdConnectProviderUpdateHeaders & OpenidConnectProviderContract;

// @public
export interface Operation {
    display?: OperationDisplay;
    name?: string;
    origin?: string;
    properties?: Record<string, unknown>;
}

// @public
export interface OperationCollection {
    count?: number;
    readonly nextLink?: string;
    readonly value?: OperationContract[];
}

// @public
export interface OperationContract extends ProxyResource {
    description?: string;
    displayName?: string;
    method?: string;
    policies?: string;
    request?: RequestContract;
    responses?: ResponseContract[];
    templateParameters?: ParameterContract[];
    urlTemplate?: string;
}

// @public
export interface OperationContractProperties extends OperationEntityBaseContract {
    displayName: string;
    method: string;
    urlTemplate: string;
}

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

// @public
export interface OperationEntityBaseContract {
    description?: string;
    policies?: string;
    request?: RequestContract;
    responses?: ResponseContract[];
    templateParameters?: ParameterContract[];
}

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

// @public
export type OperationListByTagsNextResponse = TagResourceCollection;

// @public
export interface OperationListByTagsOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    includeNotTaggedOperations?: boolean;
    skip?: number;
    top?: number;
}

// @public
export type OperationListByTagsResponse = TagResourceCollection;

// @public
export interface OperationListResult {
    nextLink?: string;
    value?: Operation[];
}

// @public
export type OperationNameFormat = string;

// @public
export interface OperationOperations {
    listByTags(resourceGroupName: string, serviceName: string, apiId: string, options?: OperationListByTagsOptionalParams): PagedAsyncIterableIterator<TagResourceContract>;
}

// @public
export interface OperationResultContract extends ProxyResource {
    readonly actionLog?: OperationResultLogItemContract[];
    error?: ErrorResponseBody;
    idPropertiesId?: string;
    resultInfo?: string;
    started?: Date;
    status?: AsyncOperationStatus;
    updated?: Date;
}

// @public
export interface OperationResultLogItemContract {
    action?: string;
    objectKey?: string;
    objectType?: string;
}

// @public
export interface OperationsResults {
    get(location: string, operationId: string, options?: OperationsResultsGetOptionalParams): Promise<OperationsResultsGetResponse>;
}

// @public
export interface OperationsResultsGetHeaders {
    location?: string;
}

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

// @public
export type OperationsResultsGetResponse = OperationsResultsGetHeaders;

// @public
export interface OperationStatus {
    get(location: string, operationId: string, options?: OperationStatusGetOptionalParams): Promise<OperationStatusGetResponse>;
}

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

// @public
export type OperationStatusGetResponse = OperationStatusResult;

// @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 interface OperationTagResourceContractProperties {
    readonly apiName?: string;
    readonly apiRevision?: string;
    readonly apiVersion?: string;
    readonly description?: string;
    id?: string;
    readonly method?: string;
    readonly name?: string;
    readonly urlTemplate?: string;
}

// @public
export interface OperationUpdateContract {
    description?: string;
    displayName?: string;
    method?: string;
    policies?: string;
    request?: RequestContract;
    responses?: ResponseContract[];
    templateParameters?: ParameterContract[];
    urlTemplate?: string;
}

// @public
export interface OperationUpdateContractProperties extends OperationEntityBaseContract {
    displayName?: string;
    method?: string;
    urlTemplate?: string;
}

// @public
export type Origin = string;

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

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

// @public
export interface OutboundNetworkDependenciesEndpoints {
    listByService(resourceGroupName: string, serviceName: string, options?: OutboundNetworkDependenciesEndpointsListByServiceOptionalParams): Promise<OutboundNetworkDependenciesEndpointsListByServiceResponse>;
}

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

// @public
export type OutboundNetworkDependenciesEndpointsListByServiceResponse = OutboundEnvironmentEndpointList;

// @public
export interface ParameterContract {
    defaultValue?: string;
    description?: string;
    examples?: {
        [propertyName: string]: ParameterExampleContract;
    };
    name: string;
    required?: boolean;
    schemaId?: string;
    type: string;
    typeName?: string;
    values?: string[];
}

// @public
export interface ParameterExampleContract {
    description?: string;
    externalValue?: string;
    summary?: string;
    value?: any;
}

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

// @public
export type PerformConnectivityCheckAsyncResponse = ConnectivityCheckResponse;

// @public
export interface PipelineDiagnosticSettings {
    request?: HttpMessageDiagnostic;
    response?: HttpMessageDiagnostic;
}

// @public
export type PlatformVersion = string;

// @public
export interface Policy {
    createOrUpdate(resourceGroupName: string, serviceName: string, policyId: PolicyIdName, parameters: PolicyContract, options?: PolicyCreateOrUpdateOptionalParams): Promise<PolicyCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, policyId: PolicyIdName, ifMatch: string, options?: PolicyDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, policyId: PolicyIdName, options?: PolicyGetOptionalParams): Promise<PolicyGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, policyId: PolicyIdName, options?: PolicyGetEntityTagOptionalParams): Promise<PolicyGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: PolicyListByServiceOptionalParams): PagedAsyncIterableIterator<PolicyContract>;
}

// @public
export interface PolicyCollection {
    count?: number;
    nextLink?: string;
    value?: PolicyContract[];
}

// @public
export type PolicyComplianceState = string;

// @public
export type PolicyContentFormat = string;

// @public
export interface PolicyContract extends ProxyResource {
    format?: PolicyContentFormat;
    value?: string;
}

// @public
export interface PolicyCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface PolicyCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type PolicyCreateOrUpdateResponse = PolicyCreateOrUpdateHeaders & PolicyContract;

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

// @public
export interface PolicyDescription {
    listByService(resourceGroupName: string, serviceName: string, options?: PolicyDescriptionListByServiceOptionalParams): Promise<PolicyDescriptionListByServiceResponse>;
}

// @public
export interface PolicyDescriptionCollection {
    count?: number;
    value?: PolicyDescriptionContract[];
}

// @public
export interface PolicyDescriptionContract extends ProxyResource {
    readonly description?: string;
    readonly scope?: number;
}

// @public
export interface PolicyDescriptionListByServiceOptionalParams extends coreClient.OperationOptions {
    scope?: PolicyScopeContract;
}

// @public
export type PolicyDescriptionListByServiceResponse = PolicyDescriptionCollection;

// @public
export type PolicyExportFormat = string;

// @public
export interface PolicyFragment {
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, id: string, parameters: PolicyFragmentContract, options?: PolicyFragmentCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<PolicyFragmentCreateOrUpdateResponse>, PolicyFragmentCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, id: string, parameters: PolicyFragmentContract, options?: PolicyFragmentCreateOrUpdateOptionalParams): Promise<PolicyFragmentCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, id: string, ifMatch: string, options?: PolicyFragmentDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, id: string, options?: PolicyFragmentGetOptionalParams): Promise<PolicyFragmentGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, id: string, options?: PolicyFragmentGetEntityTagOptionalParams): Promise<PolicyFragmentGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: PolicyFragmentListByServiceOptionalParams): PagedAsyncIterableIterator<PolicyFragmentContract>;
    listReferences(resourceGroupName: string, serviceName: string, id: string, options?: PolicyFragmentListReferencesOptionalParams): Promise<PolicyFragmentListReferencesResponse>;
}

// @public
export interface PolicyFragmentCollection {
    count?: number;
    nextLink?: string;
    value?: PolicyFragmentContract[];
}

// @public
export type PolicyFragmentContentFormat = string;

// @public
export interface PolicyFragmentContract extends ProxyResource {
    description?: string;
    format?: PolicyFragmentContentFormat;
    readonly provisioningState?: string;
    value?: string;
}

// @public
export interface PolicyFragmentCreateOrUpdateHeaders {
    azureAsyncOperation?: string;
    eTag?: string;
    location?: string;
}

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

// @public
export type PolicyFragmentCreateOrUpdateResponse = PolicyFragmentCreateOrUpdateHeaders & PolicyFragmentContract;

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

// @public
export interface PolicyFragmentGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type PolicyFragmentGetEntityTagResponse = PolicyFragmentGetEntityTagHeaders;

// @public
export interface PolicyFragmentGetHeaders {
    eTag?: string;
}

// @public
export interface PolicyFragmentGetOptionalParams extends coreClient.OperationOptions {
    format?: PolicyFragmentContentFormat;
}

// @public
export type PolicyFragmentGetResponse = PolicyFragmentGetHeaders & PolicyFragmentContract;

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

// @public
export type PolicyFragmentListByServiceNextResponse = PolicyFragmentCollection;

// @public
export interface PolicyFragmentListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    orderby?: string;
    skip?: number;
    top?: number;
}

// @public
export type PolicyFragmentListByServiceResponse = PolicyFragmentCollection;

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

// @public
export type PolicyFragmentListReferencesResponse = ResourceCollection;

// @public
export interface PolicyGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type PolicyGetEntityTagResponse = PolicyGetEntityTagHeaders;

// @public
export interface PolicyGetHeaders {
    eTag?: string;
}

// @public
export interface PolicyGetOptionalParams extends coreClient.OperationOptions {
    format?: PolicyExportFormat;
}

// @public
export type PolicyGetResponse = PolicyGetHeaders & PolicyContract;

// @public
export type PolicyIdName = string;

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

// @public
export type PolicyListByServiceNextResponse = PolicyCollection;

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

// @public
export type PolicyListByServiceResponse = PolicyCollection;

// @public
export interface PolicyRestriction {
    createOrUpdate(resourceGroupName: string, serviceName: string, policyRestrictionId: string, parameters: PolicyRestrictionContract, options?: PolicyRestrictionCreateOrUpdateOptionalParams): Promise<PolicyRestrictionCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, policyRestrictionId: string, options?: PolicyRestrictionDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, policyRestrictionId: string, options?: PolicyRestrictionGetOptionalParams): Promise<PolicyRestrictionGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, policyRestrictionId: string, options?: PolicyRestrictionGetEntityTagOptionalParams): Promise<PolicyRestrictionGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: PolicyRestrictionListByServiceOptionalParams): PagedAsyncIterableIterator<PolicyRestrictionContract>;
    update(resourceGroupName: string, serviceName: string, policyRestrictionId: string, ifMatch: string, parameters: PolicyRestrictionUpdateContract, options?: PolicyRestrictionUpdateOptionalParams): Promise<PolicyRestrictionUpdateResponse>;
}

// @public
export interface PolicyRestrictionCollection {
    nextLink?: string;
    // (undocumented)
    value?: PolicyRestrictionContract[];
}

// @public
export interface PolicyRestrictionContract extends ProxyResource {
    requireBase?: PolicyRestrictionRequireBase;
    scope?: string;
}

// @public
export interface PolicyRestrictionCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface PolicyRestrictionCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type PolicyRestrictionCreateOrUpdateResponse = PolicyRestrictionCreateOrUpdateHeaders & PolicyRestrictionContract;

// @public
export interface PolicyRestrictionDeleteOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export interface PolicyRestrictionGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type PolicyRestrictionGetEntityTagResponse = PolicyRestrictionGetEntityTagHeaders;

// @public
export interface PolicyRestrictionGetHeaders {
    eTag?: string;
}

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

// @public
export type PolicyRestrictionGetResponse = PolicyRestrictionGetHeaders & PolicyRestrictionContract;

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

// @public
export type PolicyRestrictionListByServiceNextResponse = PolicyRestrictionCollection;

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

// @public
export type PolicyRestrictionListByServiceResponse = PolicyRestrictionCollection;

// @public
export type PolicyRestrictionRequireBase = string;

// @public
export interface PolicyRestrictionUpdateContract {
    requireBase?: PolicyRestrictionRequireBase;
    scope?: string;
}

// @public
export interface PolicyRestrictionUpdateHeaders {
    eTag?: string;
}

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

// @public
export type PolicyRestrictionUpdateResponse = PolicyRestrictionUpdateHeaders & PolicyRestrictionContract;

// @public
export interface PolicyRestrictionValidations {
    beginByService(resourceGroupName: string, serviceName: string, options?: PolicyRestrictionValidationsByServiceOptionalParams): Promise<SimplePollerLike<OperationState<PolicyRestrictionValidationsByServiceResponse>, PolicyRestrictionValidationsByServiceResponse>>;
    beginByServiceAndWait(resourceGroupName: string, serviceName: string, options?: PolicyRestrictionValidationsByServiceOptionalParams): Promise<PolicyRestrictionValidationsByServiceResponse>;
}

// @public
export interface PolicyRestrictionValidationsByServiceHeaders {
    location?: string;
}

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

// @public
export type PolicyRestrictionValidationsByServiceResponse = OperationResultContract;

// @public
export type PolicyScopeContract = "Tenant" | "Product" | "Api" | "Operation" | "All";

// @public
export interface PolicyWithComplianceCollection {
    nextLink?: string;
    value?: PolicyWithComplianceContract[];
}

// @public
export interface PolicyWithComplianceContract extends ProxyResource {
    complianceState?: PolicyComplianceState;
    referencePolicyId?: string;
}

// @public
export interface PortalConfig {
    createOrUpdate(resourceGroupName: string, serviceName: string, portalConfigId: string, ifMatch: string, parameters: PortalConfigContract, options?: PortalConfigCreateOrUpdateOptionalParams): Promise<PortalConfigCreateOrUpdateResponse>;
    get(resourceGroupName: string, serviceName: string, portalConfigId: string, options?: PortalConfigGetOptionalParams): Promise<PortalConfigGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, portalConfigId: string, options?: PortalConfigGetEntityTagOptionalParams): Promise<PortalConfigGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: PortalConfigListByServiceOptionalParams): PagedAsyncIterableIterator<PortalConfigContract>;
    update(resourceGroupName: string, serviceName: string, portalConfigId: string, ifMatch: string, parameters: PortalConfigContract, options?: PortalConfigUpdateOptionalParams): Promise<PortalConfigUpdateResponse>;
}

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

// @public
export interface PortalConfigContract extends ProxyResource {
    cors?: PortalConfigCorsProperties;
    csp?: PortalConfigCspProperties;
    delegation?: PortalConfigDelegationProperties;
    enableBasicAuth?: boolean;
    // (undocumented)
    signin?: PortalConfigPropertiesSignin;
    // (undocumented)
    signup?: PortalConfigPropertiesSignup;
}

// @public
export interface PortalConfigCorsProperties {
    allowedOrigins?: string[];
}

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

// @public
export type PortalConfigCreateOrUpdateResponse = PortalConfigContract;

// @public
export interface PortalConfigCspProperties {
    allowedSources?: string[];
    mode?: PortalSettingsCspMode;
    reportUri?: string[];
}

// @public (undocumented)
export interface PortalConfigDelegationProperties {
    delegateRegistration?: boolean;
    delegateSubscription?: boolean;
    delegationUrl?: string;
    validationKey?: string;
}

// @public
export interface PortalConfigGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type PortalConfigGetEntityTagResponse = PortalConfigGetEntityTagHeaders;

// @public
export interface PortalConfigGetHeaders {
    eTag?: string;
}

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

// @public
export type PortalConfigGetResponse = PortalConfigGetHeaders & PortalConfigContract;

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

// @public
export type PortalConfigListByServiceNextResponse = PortalConfigCollection;

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

// @public
export type PortalConfigListByServiceResponse = PortalConfigCollection;

// @public (undocumented)
export interface PortalConfigPropertiesSignin {
    require?: boolean;
}

// @public (undocumented)
export interface PortalConfigPropertiesSignup {
    termsOfService?: PortalConfigTermsOfServiceProperties;
}

// @public
export interface PortalConfigTermsOfServiceProperties {
    requireConsent?: boolean;
    text?: string;
}

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

// @public
export type PortalConfigUpdateResponse = PortalConfigContract;

// @public
export interface PortalDelegationSettings extends ProxyResource {
    subscriptions?: SubscriptionsDelegationSettingsProperties;
    url?: string;
    userRegistration?: RegistrationDelegationSettingsProperties;
    validationKey?: string;
}

// @public
export interface PortalRevision {
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, portalRevisionId: string, parameters: PortalRevisionContract, options?: PortalRevisionCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<PortalRevisionCreateOrUpdateResponse>, PortalRevisionCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, portalRevisionId: string, parameters: PortalRevisionContract, options?: PortalRevisionCreateOrUpdateOptionalParams): Promise<PortalRevisionCreateOrUpdateResponse>;
    beginUpdate(resourceGroupName: string, serviceName: string, portalRevisionId: string, ifMatch: string, parameters: PortalRevisionContract, options?: PortalRevisionUpdateOptionalParams): Promise<SimplePollerLike<OperationState<PortalRevisionUpdateResponse>, PortalRevisionUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, serviceName: string, portalRevisionId: string, ifMatch: string, parameters: PortalRevisionContract, options?: PortalRevisionUpdateOptionalParams): Promise<PortalRevisionUpdateResponse>;
    get(resourceGroupName: string, serviceName: string, portalRevisionId: string, options?: PortalRevisionGetOptionalParams): Promise<PortalRevisionGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, portalRevisionId: string, options?: PortalRevisionGetEntityTagOptionalParams): Promise<PortalRevisionGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: PortalRevisionListByServiceOptionalParams): PagedAsyncIterableIterator<PortalRevisionContract>;
}

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

// @public
export interface PortalRevisionContract extends ProxyResource {
    readonly createdDateTime?: Date;
    description?: string;
    isCurrent?: boolean;
    readonly provisioningState?: string;
    readonly status?: PortalRevisionStatus;
    readonly statusDetails?: string;
    readonly updatedDateTime?: Date;
}

// @public
export interface PortalRevisionCreateOrUpdateHeaders {
    azureAsyncOperation?: string;
    eTag?: string;
    location?: string;
}

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

// @public
export type PortalRevisionCreateOrUpdateResponse = PortalRevisionCreateOrUpdateHeaders & PortalRevisionContract;

// @public
export interface PortalRevisionGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type PortalRevisionGetEntityTagResponse = PortalRevisionGetEntityTagHeaders;

// @public
export interface PortalRevisionGetHeaders {
    eTag?: string;
}

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

// @public
export type PortalRevisionGetResponse = PortalRevisionGetHeaders & PortalRevisionContract;

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

// @public
export type PortalRevisionListByServiceNextResponse = PortalRevisionCollection;

// @public
export interface PortalRevisionListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type PortalRevisionListByServiceResponse = PortalRevisionCollection;

// @public
export type PortalRevisionStatus = string;

// @public
export interface PortalRevisionUpdateHeaders {
    eTag?: string;
}

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

// @public
export type PortalRevisionUpdateResponse = PortalRevisionUpdateHeaders & PortalRevisionContract;

// @public
export interface PortalSettings {
    listByService(resourceGroupName: string, serviceName: string, options?: PortalSettingsListByServiceOptionalParams): Promise<PortalSettingsListByServiceResponse>;
}

// @public
export interface PortalSettingsCollection {
    count?: number;
    value?: PortalSettingsContract[];
}

// @public
export interface PortalSettingsContract extends ProxyResource {
    enabled?: boolean;
    subscriptions?: SubscriptionsDelegationSettingsProperties;
    termsOfService?: TermsOfServiceProperties;
    url?: string;
    userRegistration?: RegistrationDelegationSettingsProperties;
    validationKey?: string;
}

// @public
export type PortalSettingsCspMode = string;

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

// @public
export type PortalSettingsListByServiceResponse = PortalSettingsCollection;

// @public
export interface PortalSettingValidationKeyContract {
    validationKey?: string;
}

// @public
export interface PortalSigninSettings extends ProxyResource {
    enabled?: boolean;
}

// @public
export interface PortalSignupSettings extends ProxyResource {
    enabled?: boolean;
    termsOfService?: TermsOfServiceProperties;
}

// @public
export type PreferredIPVersion = string;

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

// @public
export interface PrivateEndpointConnection extends Resource {
    privateEndpoint?: PrivateEndpoint;
    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionState;
    readonly provisioningState?: PrivateEndpointConnectionProvisioningState;
}

// @public
export interface PrivateEndpointConnectionCreateOrUpdateHeaders {
    location?: string;
}

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

// @public
export type PrivateEndpointConnectionCreateOrUpdateResponse = PrivateEndpointConnection;

// @public
export interface PrivateEndpointConnectionDeleteHeaders {
    location?: string;
}

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

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

// @public
export type PrivateEndpointConnectionGetByNameResponse = PrivateEndpointConnection;

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

// @public
export type PrivateEndpointConnectionGetPrivateLinkResourceResponse = PrivateLinkResource;

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

// @public
export type PrivateEndpointConnectionListByServiceResponse = PrivateEndpointConnectionListResult;

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

// @public
export type PrivateEndpointConnectionListPrivateLinkResourcesResponse = PrivateLinkResourceListResult;

// @public
export interface PrivateEndpointConnectionListResult {
    value?: PrivateEndpointConnection[];
}

// @public
export interface PrivateEndpointConnectionOperations {
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, privateEndpointConnectionName: string, privateEndpointConnectionRequest: PrivateEndpointConnectionRequest, options?: PrivateEndpointConnectionCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<PrivateEndpointConnectionCreateOrUpdateResponse>, PrivateEndpointConnectionCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, privateEndpointConnectionName: string, privateEndpointConnectionRequest: PrivateEndpointConnectionRequest, options?: PrivateEndpointConnectionCreateOrUpdateOptionalParams): Promise<PrivateEndpointConnectionCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, serviceName: string, privateEndpointConnectionName: string, options?: PrivateEndpointConnectionDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, serviceName: string, privateEndpointConnectionName: string, options?: PrivateEndpointConnectionDeleteOptionalParams): Promise<void>;
    getByName(resourceGroupName: string, serviceName: string, privateEndpointConnectionName: string, options?: PrivateEndpointConnectionGetByNameOptionalParams): Promise<PrivateEndpointConnectionGetByNameResponse>;
    getPrivateLinkResource(resourceGroupName: string, serviceName: string, privateLinkSubResourceName: string, options?: PrivateEndpointConnectionGetPrivateLinkResourceOptionalParams): Promise<PrivateEndpointConnectionGetPrivateLinkResourceResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: PrivateEndpointConnectionListByServiceOptionalParams): PagedAsyncIterableIterator<PrivateEndpointConnection>;
    listPrivateLinkResources(resourceGroupName: string, serviceName: string, options?: PrivateEndpointConnectionListPrivateLinkResourcesOptionalParams): Promise<PrivateEndpointConnectionListPrivateLinkResourcesResponse>;
}

// @public
export type PrivateEndpointConnectionProvisioningState = string;

// @public
export interface PrivateEndpointConnectionRequest {
    id?: string;
    properties?: PrivateEndpointConnectionRequestProperties;
}

// @public
export interface PrivateEndpointConnectionRequestProperties {
    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionState;
}

// @public
export type PrivateEndpointServiceConnectionStatus = string;

// @public
export interface PrivateLinkResource extends Resource {
    readonly groupId?: string;
    readonly requiredMembers?: string[];
    requiredZoneNames?: string[];
}

// @public
export interface PrivateLinkResourceListResult {
    value?: PrivateLinkResource[];
}

// @public
export interface PrivateLinkServiceConnectionState {
    actionsRequired?: string;
    description?: string;
    status?: PrivateEndpointServiceConnectionStatus;
}

// @public
export interface Product {
    createOrUpdate(resourceGroupName: string, serviceName: string, productId: string, parameters: ProductContract, options?: ProductCreateOrUpdateOptionalParams): Promise<ProductCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, productId: string, ifMatch: string, options?: ProductDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, productId: string, options?: ProductGetOptionalParams): Promise<ProductGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, productId: string, options?: ProductGetEntityTagOptionalParams): Promise<ProductGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: ProductListByServiceOptionalParams): PagedAsyncIterableIterator<ProductContract>;
    listByTags(resourceGroupName: string, serviceName: string, options?: ProductListByTagsOptionalParams): PagedAsyncIterableIterator<TagResourceContract>;
    update(resourceGroupName: string, serviceName: string, productId: string, ifMatch: string, parameters: ProductUpdateParameters, options?: ProductUpdateOptionalParams): Promise<ProductUpdateResponse>;
}

// @public
export interface ProductApi {
    checkEntityExists(resourceGroupName: string, serviceName: string, productId: string, apiId: string, options?: ProductApiCheckEntityExistsOptionalParams): Promise<ProductApiCheckEntityExistsResponse>;
    createOrUpdate(resourceGroupName: string, serviceName: string, productId: string, apiId: string, options?: ProductApiCreateOrUpdateOptionalParams): Promise<ProductApiCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, productId: string, apiId: string, options?: ProductApiDeleteOptionalParams): Promise<void>;
    listByProduct(resourceGroupName: string, serviceName: string, productId: string, options?: ProductApiListByProductOptionalParams): PagedAsyncIterableIterator<ApiContract>;
}

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

// @public
export type ProductApiCheckEntityExistsResponse = {
    body: boolean;
};

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

// @public
export type ProductApiCreateOrUpdateResponse = ApiContract;

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

// @public
export interface ProductApiLink {
    createOrUpdate(resourceGroupName: string, serviceName: string, productId: string, apiLinkId: string, parameters: ProductApiLinkContract, options?: ProductApiLinkCreateOrUpdateOptionalParams): Promise<ProductApiLinkCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, productId: string, apiLinkId: string, options?: ProductApiLinkDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, productId: string, apiLinkId: string, options?: ProductApiLinkGetOptionalParams): Promise<ProductApiLinkGetResponse>;
    listByProduct(resourceGroupName: string, serviceName: string, productId: string, options?: ProductApiLinkListByProductOptionalParams): PagedAsyncIterableIterator<ProductApiLinkContract>;
}

// @public
export interface ProductApiLinkCollection {
    count?: number;
    nextLink?: string;
    value?: ProductApiLinkContract[];
}

// @public
export interface ProductApiLinkContract extends ProxyResource {
    apiId?: string;
}

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

// @public
export type ProductApiLinkCreateOrUpdateResponse = ProductApiLinkContract;

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

// @public
export interface ProductApiLinkGetHeaders {
    eTag?: string;
}

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

// @public
export type ProductApiLinkGetResponse = ProductApiLinkGetHeaders & ProductApiLinkContract;

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

// @public
export type ProductApiLinkListByProductNextResponse = ProductApiLinkCollection;

// @public
export interface ProductApiLinkListByProductOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ProductApiLinkListByProductResponse = ProductApiLinkCollection;

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

// @public
export type ProductApiListByProductNextResponse = ApiCollection;

// @public
export interface ProductApiListByProductOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ProductApiListByProductResponse = ApiCollection;

// @public
export interface ProductCollection {
    count?: number;
    nextLink?: string;
    value?: ProductContract[];
}

// @public
export interface ProductContract extends ProxyResource {
    approvalRequired?: boolean;
    description?: string;
    displayName?: string;
    state?: ProductState;
    subscriptionRequired?: boolean;
    subscriptionsLimit?: number;
    terms?: string;
}

// @public
export interface ProductContractProperties extends ProductEntityBaseParameters {
    displayName: string;
}

// @public
export interface ProductCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ProductCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ProductCreateOrUpdateResponse = ProductCreateOrUpdateHeaders & ProductContract;

// @public
export interface ProductDeleteOptionalParams extends coreClient.OperationOptions {
    deleteSubscriptions?: boolean;
}

// @public
export interface ProductEntityBaseParameters {
    approvalRequired?: boolean;
    description?: string;
    state?: ProductState;
    subscriptionRequired?: boolean;
    subscriptionsLimit?: number;
    terms?: string;
}

// @public
export interface ProductGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ProductGetEntityTagResponse = ProductGetEntityTagHeaders;

// @public
export interface ProductGetHeaders {
    eTag?: string;
}

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

// @public
export type ProductGetResponse = ProductGetHeaders & ProductContract;

// @public
export interface ProductGroup {
    checkEntityExists(resourceGroupName: string, serviceName: string, productId: string, groupId: string, options?: ProductGroupCheckEntityExistsOptionalParams): Promise<ProductGroupCheckEntityExistsResponse>;
    createOrUpdate(resourceGroupName: string, serviceName: string, productId: string, groupId: string, options?: ProductGroupCreateOrUpdateOptionalParams): Promise<ProductGroupCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, productId: string, groupId: string, options?: ProductGroupDeleteOptionalParams): Promise<void>;
    listByProduct(resourceGroupName: string, serviceName: string, productId: string, options?: ProductGroupListByProductOptionalParams): PagedAsyncIterableIterator<GroupContract>;
}

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

// @public
export type ProductGroupCheckEntityExistsResponse = {
    body: boolean;
};

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

// @public
export type ProductGroupCreateOrUpdateResponse = GroupContract;

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

// @public
export interface ProductGroupLink {
    createOrUpdate(resourceGroupName: string, serviceName: string, productId: string, groupLinkId: string, parameters: ProductGroupLinkContract, options?: ProductGroupLinkCreateOrUpdateOptionalParams): Promise<ProductGroupLinkCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, productId: string, groupLinkId: string, options?: ProductGroupLinkDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, productId: string, groupLinkId: string, options?: ProductGroupLinkGetOptionalParams): Promise<ProductGroupLinkGetResponse>;
    listByProduct(resourceGroupName: string, serviceName: string, productId: string, options?: ProductGroupLinkListByProductOptionalParams): PagedAsyncIterableIterator<ProductGroupLinkContract>;
}

// @public
export interface ProductGroupLinkCollection {
    count?: number;
    nextLink?: string;
    value?: ProductGroupLinkContract[];
}

// @public
export interface ProductGroupLinkContract extends ProxyResource {
    groupId?: string;
}

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

// @public
export type ProductGroupLinkCreateOrUpdateResponse = ProductGroupLinkContract;

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

// @public
export interface ProductGroupLinkGetHeaders {
    eTag?: string;
}

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

// @public
export type ProductGroupLinkGetResponse = ProductGroupLinkGetHeaders & ProductGroupLinkContract;

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

// @public
export type ProductGroupLinkListByProductNextResponse = ProductGroupLinkCollection;

// @public
export interface ProductGroupLinkListByProductOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ProductGroupLinkListByProductResponse = ProductGroupLinkCollection;

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

// @public
export type ProductGroupListByProductNextResponse = GroupCollection;

// @public
export interface ProductGroupListByProductOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ProductGroupListByProductResponse = GroupCollection;

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

// @public
export type ProductListByServiceNextResponse = ProductCollection;

// @public
export interface ProductListByServiceOptionalParams extends coreClient.OperationOptions {
    expandGroups?: boolean;
    filter?: string;
    skip?: number;
    tags?: string;
    top?: number;
}

// @public
export type ProductListByServiceResponse = ProductCollection;

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

// @public
export type ProductListByTagsNextResponse = TagResourceCollection;

// @public
export interface ProductListByTagsOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    includeNotTaggedProducts?: boolean;
    skip?: number;
    top?: number;
}

// @public
export type ProductListByTagsResponse = TagResourceCollection;

// @public
export interface ProductPolicy {
    createOrUpdate(resourceGroupName: string, serviceName: string, productId: string, policyId: PolicyIdName, parameters: PolicyContract, options?: ProductPolicyCreateOrUpdateOptionalParams): Promise<ProductPolicyCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, productId: string, policyId: PolicyIdName, ifMatch: string, options?: ProductPolicyDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, productId: string, policyId: PolicyIdName, options?: ProductPolicyGetOptionalParams): Promise<ProductPolicyGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, productId: string, policyId: PolicyIdName, options?: ProductPolicyGetEntityTagOptionalParams): Promise<ProductPolicyGetEntityTagResponse>;
    listByProduct(resourceGroupName: string, serviceName: string, productId: string, options?: ProductPolicyListByProductOptionalParams): PagedAsyncIterableIterator<PolicyContract>;
}

// @public
export interface ProductPolicyCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ProductPolicyCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ProductPolicyCreateOrUpdateResponse = ProductPolicyCreateOrUpdateHeaders & PolicyContract;

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

// @public
export interface ProductPolicyGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ProductPolicyGetEntityTagResponse = ProductPolicyGetEntityTagHeaders;

// @public
export interface ProductPolicyGetHeaders {
    eTag?: string;
}

// @public
export interface ProductPolicyGetOptionalParams extends coreClient.OperationOptions {
    format?: PolicyExportFormat;
}

// @public
export type ProductPolicyGetResponse = ProductPolicyGetHeaders & PolicyContract;

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

// @public
export type ProductPolicyListByProductNextResponse = PolicyCollection;

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

// @public
export type ProductPolicyListByProductResponse = PolicyCollection;

// @public
export type ProductState = "notPublished" | "published";

// @public
export interface ProductSubscriptions {
    list(resourceGroupName: string, serviceName: string, productId: string, options?: ProductSubscriptionsListOptionalParams): PagedAsyncIterableIterator<SubscriptionContract>;
}

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

// @public
export type ProductSubscriptionsListNextResponse = SubscriptionCollection;

// @public
export interface ProductSubscriptionsListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ProductSubscriptionsListResponse = SubscriptionCollection;

// @public
export interface ProductTagResourceContractProperties extends ProductEntityBaseParameters {
    id?: string;
    name: string;
}

// @public
export interface ProductUpdateHeaders {
    eTag?: string;
}

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

// @public
export interface ProductUpdateParameters {
    approvalRequired?: boolean;
    description?: string;
    displayName?: string;
    state?: ProductState;
    subscriptionRequired?: boolean;
    subscriptionsLimit?: number;
    terms?: string;
}

// @public
export interface ProductUpdateProperties extends ProductEntityBaseParameters {
    displayName?: string;
}

// @public
export type ProductUpdateResponse = ProductUpdateHeaders & ProductContract;

// @public
export interface ProductWiki {
    createOrUpdate(resourceGroupName: string, serviceName: string, productId: string, parameters: WikiContract, options?: ProductWikiCreateOrUpdateOptionalParams): Promise<ProductWikiCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, productId: string, ifMatch: string, options?: ProductWikiDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, productId: string, options?: ProductWikiGetOptionalParams): Promise<ProductWikiGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, productId: string, options?: ProductWikiGetEntityTagOptionalParams): Promise<ProductWikiGetEntityTagResponse>;
    update(resourceGroupName: string, serviceName: string, productId: string, ifMatch: string, parameters: WikiUpdateContract, options?: ProductWikiUpdateOptionalParams): Promise<ProductWikiUpdateResponse>;
}

// @public
export interface ProductWikiCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface ProductWikiCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type ProductWikiCreateOrUpdateResponse = ProductWikiCreateOrUpdateHeaders & WikiContract;

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

// @public
export interface ProductWikiGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type ProductWikiGetEntityTagResponse = ProductWikiGetEntityTagHeaders;

// @public
export interface ProductWikiGetHeaders {
    eTag?: string;
}

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

// @public
export type ProductWikiGetResponse = ProductWikiGetHeaders & WikiContract;

// @public
export interface ProductWikis {
    list(resourceGroupName: string, serviceName: string, productId: string, options?: ProductWikisListOptionalParams): PagedAsyncIterableIterator<WikiContract>;
}

// @public
export interface ProductWikisListHeaders {
    eTag?: string;
}

// @public
export interface ProductWikisListNextHeaders {
    eTag?: string;
}

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

// @public
export type ProductWikisListNextResponse = ProductWikisListNextHeaders & WikiCollection;

// @public
export interface ProductWikisListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type ProductWikisListResponse = ProductWikisListHeaders & WikiCollection;

// @public
export interface ProductWikiUpdateHeaders {
    eTag?: string;
}

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

// @public
export type ProductWikiUpdateResponse = ProductWikiUpdateHeaders & WikiContract;

// @public
export type Protocol = string;

// @public
export interface ProxyResource extends Resource {
}

// @public
export type PublicNetworkAccess = string;

// @public
export interface QuotaByCounterKeys {
    listByService(resourceGroupName: string, serviceName: string, quotaCounterKey: string, options?: QuotaByCounterKeysListByServiceOptionalParams): Promise<QuotaByCounterKeysListByServiceResponse>;
    update(resourceGroupName: string, serviceName: string, quotaCounterKey: string, parameters: QuotaCounterValueUpdateContract, options?: QuotaByCounterKeysUpdateOptionalParams): Promise<QuotaByCounterKeysUpdateResponse>;
}

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

// @public
export type QuotaByCounterKeysListByServiceResponse = QuotaCounterCollection;

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

// @public
export type QuotaByCounterKeysUpdateResponse = QuotaCounterCollection;

// @public
export interface QuotaByPeriodKeys {
    get(resourceGroupName: string, serviceName: string, quotaCounterKey: string, quotaPeriodKey: string, options?: QuotaByPeriodKeysGetOptionalParams): Promise<QuotaByPeriodKeysGetResponse>;
    update(resourceGroupName: string, serviceName: string, quotaCounterKey: string, quotaPeriodKey: string, parameters: QuotaCounterValueUpdateContract, options?: QuotaByPeriodKeysUpdateOptionalParams): Promise<QuotaByPeriodKeysUpdateResponse>;
}

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

// @public
export type QuotaByPeriodKeysGetResponse = QuotaCounterContract;

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

// @public
export type QuotaByPeriodKeysUpdateResponse = QuotaCounterContract;

// @public
export interface QuotaCounterCollection {
    count?: number;
    nextLink?: string;
    value?: QuotaCounterContract[];
}

// @public
export interface QuotaCounterContract {
    counterKey: string;
    periodEndTime: Date;
    periodKey: string;
    periodStartTime: Date;
    value?: QuotaCounterValueContractProperties;
}

// @public
export interface QuotaCounterValueContract {
    callsCount?: number;
    kbTransferred?: number;
}

// @public
export interface QuotaCounterValueContractProperties {
    callsCount?: number;
    kbTransferred?: number;
}

// @public
export interface QuotaCounterValueUpdateContract {
    callsCount?: number;
    kbTransferred?: number;
}

// @public
export interface RecipientEmailCollection {
    count?: number;
    nextLink?: string;
    value?: RecipientEmailContract[];
}

// @public
export interface RecipientEmailContract extends ProxyResource {
    email?: string;
}

// @public
export interface RecipientsContractProperties {
    emails?: string[];
    users?: string[];
}

// @public
export interface RecipientUserCollection {
    count?: number;
    nextLink?: string;
    value?: RecipientUserContract[];
}

// @public
export interface RecipientUserContract extends ProxyResource {
    userId?: string;
}

// @public
export interface Region {
    listByService(resourceGroupName: string, serviceName: string, options?: RegionListByServiceOptionalParams): PagedAsyncIterableIterator<RegionContract>;
}

// @public
export interface RegionContract {
    isDeleted?: boolean;
    isMasterRegion?: boolean;
    readonly name?: string;
}

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

// @public
export type RegionListByServiceNextResponse = RegionListResult;

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

// @public
export type RegionListByServiceResponse = RegionListResult;

// @public
export interface RegionListResult {
    count?: number;
    nextLink?: string;
    value?: RegionContract[];
}

// @public
export interface RegistrationDelegationSettingsProperties {
    enabled?: boolean;
}

// @public
export interface RemotePrivateEndpointConnectionWrapper {
    readonly groupIds?: string[];
    id?: string;
    name?: string;
    privateEndpoint?: ArmIdWrapper;
    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionState;
    readonly provisioningState?: string;
    type?: string;
}

// @public
export interface ReportCollection {
    count?: number;
    nextLink?: string;
    value?: ReportRecordContract[];
}

// @public
export interface ReportRecordContract {
    apiId?: string;
    apiRegion?: string;
    apiTimeAvg?: number;
    apiTimeMax?: number;
    apiTimeMin?: number;
    bandwidth?: number;
    cacheHitCount?: number;
    cacheMissCount?: number;
    callCountBlocked?: number;
    callCountFailed?: number;
    callCountOther?: number;
    callCountSuccess?: number;
    callCountTotal?: number;
    country?: string;
    interval?: string;
    name?: string;
    operationId?: string;
    readonly productId?: string;
    region?: string;
    serviceTimeAvg?: number;
    serviceTimeMax?: number;
    serviceTimeMin?: number;
    subscriptionId?: string;
    timestamp?: Date;
    readonly userId?: string;
    zip?: string;
}

// @public
export interface Reports {
    listByApi(resourceGroupName: string, serviceName: string, filter: string, options?: ReportsListByApiOptionalParams): PagedAsyncIterableIterator<ReportRecordContract>;
    listByGeo(resourceGroupName: string, serviceName: string, filter: string, options?: ReportsListByGeoOptionalParams): PagedAsyncIterableIterator<ReportRecordContract>;
    listByOperation(resourceGroupName: string, serviceName: string, filter: string, options?: ReportsListByOperationOptionalParams): PagedAsyncIterableIterator<ReportRecordContract>;
    listByProduct(resourceGroupName: string, serviceName: string, filter: string, options?: ReportsListByProductOptionalParams): PagedAsyncIterableIterator<ReportRecordContract>;
    listByRequest(resourceGroupName: string, serviceName: string, filter: string, options?: ReportsListByRequestOptionalParams): PagedAsyncIterableIterator<RequestReportRecordContract>;
    listBySubscription(resourceGroupName: string, serviceName: string, filter: string, options?: ReportsListBySubscriptionOptionalParams): PagedAsyncIterableIterator<ReportRecordContract>;
    listByTime(resourceGroupName: string, serviceName: string, filter: string, interval: string, options?: ReportsListByTimeOptionalParams): PagedAsyncIterableIterator<ReportRecordContract>;
    listByUser(resourceGroupName: string, serviceName: string, filter: string, options?: ReportsListByUserOptionalParams): PagedAsyncIterableIterator<ReportRecordContract>;
}

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

// @public
export type ReportsListByApiNextResponse = ReportCollection;

// @public
export interface ReportsListByApiOptionalParams extends coreClient.OperationOptions {
    orderby?: string;
    skip?: number;
    top?: number;
}

// @public
export type ReportsListByApiResponse = ReportCollection;

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

// @public
export type ReportsListByGeoNextResponse = ReportCollection;

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

// @public
export type ReportsListByGeoResponse = ReportCollection;

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

// @public
export type ReportsListByOperationNextResponse = ReportCollection;

// @public
export interface ReportsListByOperationOptionalParams extends coreClient.OperationOptions {
    orderby?: string;
    skip?: number;
    top?: number;
}

// @public
export type ReportsListByOperationResponse = ReportCollection;

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

// @public
export type ReportsListByProductNextResponse = ReportCollection;

// @public
export interface ReportsListByProductOptionalParams extends coreClient.OperationOptions {
    orderby?: string;
    skip?: number;
    top?: number;
}

// @public
export type ReportsListByProductResponse = ReportCollection;

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

// @public
export type ReportsListByRequestResponse = RequestReportCollection;

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

// @public
export type ReportsListBySubscriptionNextResponse = ReportCollection;

// @public
export interface ReportsListBySubscriptionOptionalParams extends coreClient.OperationOptions {
    orderby?: string;
    skip?: number;
    top?: number;
}

// @public
export type ReportsListBySubscriptionResponse = ReportCollection;

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

// @public
export type ReportsListByTimeNextResponse = ReportCollection;

// @public
export interface ReportsListByTimeOptionalParams extends coreClient.OperationOptions {
    orderby?: string;
    skip?: number;
    top?: number;
}

// @public
export type ReportsListByTimeResponse = ReportCollection;

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

// @public
export type ReportsListByUserNextResponse = ReportCollection;

// @public
export interface ReportsListByUserOptionalParams extends coreClient.OperationOptions {
    orderby?: string;
    skip?: number;
    top?: number;
}

// @public
export type ReportsListByUserResponse = ReportCollection;

// @public
export interface RepresentationContract {
    contentType: string;
    examples?: {
        [propertyName: string]: ParameterExampleContract;
    };
    formParameters?: ParameterContract[];
    schemaId?: string;
    typeName?: string;
}

// @public
export interface RequestContract {
    description?: string;
    headers?: ParameterContract[];
    queryParameters?: ParameterContract[];
    representations?: RepresentationContract[];
}

// @public
export interface RequestReportCollection {
    count?: number;
    value?: RequestReportRecordContract[];
}

// @public
export interface RequestReportRecordContract {
    apiId?: string;
    apiRegion?: string;
    apiTime?: number;
    backendResponseCode?: string;
    cache?: string;
    ipAddress?: string;
    method?: string;
    operationId?: string;
    readonly productId?: string;
    requestId?: string;
    requestSize?: number;
    responseCode?: number;
    responseSize?: number;
    serviceTime?: number;
    subscriptionId?: string;
    timestamp?: Date;
    url?: string;
    readonly userId?: string;
}

// @public
export interface ResolverCollection {
    count?: number;
    readonly nextLink?: string;
    readonly value?: ResolverContract[];
}

// @public
export interface ResolverContract extends ProxyResource {
    description?: string;
    displayName?: string;
    path?: string;
}

// @public
export interface ResolverResultContract extends ProxyResource {
    readonly actionLog?: ResolverResultLogItemContract[];
    error?: ErrorResponseBody;
    idPropertiesId?: string;
    resultInfo?: string;
    started?: Date;
    status?: AsyncResolverStatus;
    updated?: Date;
}

// @public
export interface ResolverResultLogItemContract {
    action?: string;
    objectKey?: string;
    objectType?: string;
}

// @public
export interface ResolverUpdateContract {
    description?: string;
    displayName?: string;
    path?: string;
}

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

// @public
export interface ResourceCollection {
    count?: number;
    nextLink?: string;
    value?: ResourceCollectionValueItem[];
}

// @public (undocumented)
export interface ResourceCollectionValueItem extends ProxyResource {
}

// @public
export interface ResourceLocationDataContract {
    city?: string;
    countryOrRegion?: string;
    district?: string;
    name: string;
}

// @public
export interface ResourceSku {
    name?: SkuType;
}

// @public
export interface ResourceSkuCapacity {
    readonly default?: number;
    readonly maximum?: number;
    readonly minimum?: number;
    readonly scaleType?: ResourceSkuCapacityScaleType;
}

// @public
export type ResourceSkuCapacityScaleType = string;

// @public
export interface ResourceSkuResult {
    readonly capacity?: ResourceSkuCapacity;
    readonly resourceType?: string;
    readonly sku?: ResourceSku;
}

// @public
export interface ResourceSkuResults {
    nextLink?: string;
    value: ResourceSkuResult[];
}

// @public
export interface ResponseContract {
    description?: string;
    headers?: ParameterContract[];
    representations?: RepresentationContract[];
    statusCode: number;
}

// @public
export interface SamplingSettings {
    percentage?: number;
    samplingType?: SamplingType;
}

// @public
export type SamplingType = string;

// @public
export interface SaveConfigurationParameter {
    branch?: string;
    force?: boolean;
}

// @public
export interface SchemaCollection {
    count?: number;
    readonly nextLink?: string;
    readonly value?: SchemaContract[];
}

// @public
export interface SchemaContract extends ProxyResource {
    components?: Record<string, unknown>;
    contentType?: string;
    definitions?: Record<string, unknown>;
    readonly provisioningState?: string;
    value?: string;
}

// @public
export type SchemaType = string;

// @public
export type SettingsTypeName = string;

// @public
export type Severity = string;

// @public
export interface SignInSettings {
    createOrUpdate(resourceGroupName: string, serviceName: string, parameters: PortalSigninSettings, options?: SignInSettingsCreateOrUpdateOptionalParams): Promise<SignInSettingsCreateOrUpdateResponse>;
    get(resourceGroupName: string, serviceName: string, options?: SignInSettingsGetOptionalParams): Promise<SignInSettingsGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, options?: SignInSettingsGetEntityTagOptionalParams): Promise<SignInSettingsGetEntityTagResponse>;
    update(resourceGroupName: string, serviceName: string, ifMatch: string, parameters: PortalSigninSettings, options?: SignInSettingsUpdateOptionalParams): Promise<void>;
}

// @public
export interface SignInSettingsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type SignInSettingsCreateOrUpdateResponse = PortalSigninSettings;

// @public
export interface SignInSettingsGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type SignInSettingsGetEntityTagResponse = SignInSettingsGetEntityTagHeaders;

// @public
export interface SignInSettingsGetHeaders {
    eTag?: string;
}

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

// @public
export type SignInSettingsGetResponse = SignInSettingsGetHeaders & PortalSigninSettings;

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

// @public
export interface SignUpSettings {
    createOrUpdate(resourceGroupName: string, serviceName: string, parameters: PortalSignupSettings, options?: SignUpSettingsCreateOrUpdateOptionalParams): Promise<SignUpSettingsCreateOrUpdateResponse>;
    get(resourceGroupName: string, serviceName: string, options?: SignUpSettingsGetOptionalParams): Promise<SignUpSettingsGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, options?: SignUpSettingsGetEntityTagOptionalParams): Promise<SignUpSettingsGetEntityTagResponse>;
    update(resourceGroupName: string, serviceName: string, ifMatch: string, parameters: PortalSignupSettings, options?: SignUpSettingsUpdateOptionalParams): Promise<void>;
}

// @public
export interface SignUpSettingsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type SignUpSettingsCreateOrUpdateResponse = PortalSignupSettings;

// @public
export interface SignUpSettingsGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type SignUpSettingsGetEntityTagResponse = SignUpSettingsGetEntityTagHeaders;

// @public
export interface SignUpSettingsGetHeaders {
    eTag?: string;
}

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

// @public
export type SignUpSettingsGetResponse = SignUpSettingsGetHeaders & PortalSignupSettings;

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

// @public
export type SkuType = string;

// @public
export type SoapApiType = string;

// @public
export type State = string;

// @public
export interface Subscription {
    createOrUpdate(resourceGroupName: string, serviceName: string, sid: string, parameters: SubscriptionCreateParameters, options?: SubscriptionCreateOrUpdateOptionalParams): Promise<SubscriptionCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, sid: string, ifMatch: string, options?: SubscriptionDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, sid: string, options?: SubscriptionGetOptionalParams): Promise<SubscriptionGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, sid: string, options?: SubscriptionGetEntityTagOptionalParams): Promise<SubscriptionGetEntityTagResponse>;
    list(resourceGroupName: string, serviceName: string, options?: SubscriptionListOptionalParams): PagedAsyncIterableIterator<SubscriptionContract>;
    listSecrets(resourceGroupName: string, serviceName: string, sid: string, options?: SubscriptionListSecretsOptionalParams): Promise<SubscriptionListSecretsResponse>;
    regeneratePrimaryKey(resourceGroupName: string, serviceName: string, sid: string, options?: SubscriptionRegeneratePrimaryKeyOptionalParams): Promise<void>;
    regenerateSecondaryKey(resourceGroupName: string, serviceName: string, sid: string, options?: SubscriptionRegenerateSecondaryKeyOptionalParams): Promise<void>;
    update(resourceGroupName: string, serviceName: string, sid: string, ifMatch: string, parameters: SubscriptionUpdateParameters, options?: SubscriptionUpdateOptionalParams): Promise<SubscriptionUpdateResponse>;
}

// @public
export interface SubscriptionCollection {
    count?: number;
    nextLink?: string;
    value?: SubscriptionContract[];
}

// @public
export interface SubscriptionContract extends ProxyResource {
    allowTracing?: boolean;
    readonly createdDate?: Date;
    displayName?: string;
    endDate?: Date;
    expirationDate?: Date;
    notificationDate?: Date;
    ownerId?: string;
    primaryKey?: string;
    scope?: string;
    secondaryKey?: string;
    startDate?: Date;
    state?: SubscriptionState;
    stateComment?: string;
}

// @public
export interface SubscriptionCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface SubscriptionCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    appType?: AppType;
    ifMatch?: string;
    notify?: boolean;
}

// @public
export type SubscriptionCreateOrUpdateResponse = SubscriptionCreateOrUpdateHeaders & SubscriptionContract;

// @public
export interface SubscriptionCreateParameters {
    allowTracing?: boolean;
    displayName?: string;
    ownerId?: string;
    primaryKey?: string;
    scope?: string;
    secondaryKey?: string;
    state?: SubscriptionState;
}

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

// @public
export interface SubscriptionGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type SubscriptionGetEntityTagResponse = SubscriptionGetEntityTagHeaders;

// @public
export interface SubscriptionGetHeaders {
    eTag?: string;
}

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

// @public
export type SubscriptionGetResponse = SubscriptionGetHeaders & SubscriptionContract;

// @public
export interface SubscriptionKeyParameterNamesContract {
    header?: string;
    query?: string;
}

// @public
export interface SubscriptionKeysContract {
    primaryKey?: string;
    secondaryKey?: string;
}

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

// @public
export type SubscriptionListNextResponse = SubscriptionCollection;

// @public
export interface SubscriptionListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type SubscriptionListResponse = SubscriptionCollection;

// @public
export interface SubscriptionListSecretsHeaders {
    eTag?: string;
}

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

// @public
export type SubscriptionListSecretsResponse = SubscriptionListSecretsHeaders & SubscriptionKeysContract;

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

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

// @public
export interface SubscriptionsDelegationSettingsProperties {
    enabled?: boolean;
}

// @public
export type SubscriptionState = "suspended" | "active" | "expired" | "submitted" | "rejected" | "cancelled";

// @public
export interface SubscriptionUpdateHeaders {
    eTag?: string;
}

// @public
export interface SubscriptionUpdateOptionalParams extends coreClient.OperationOptions {
    appType?: AppType;
    notify?: boolean;
}

// @public
export interface SubscriptionUpdateParameters {
    allowTracing?: boolean;
    displayName?: string;
    expirationDate?: Date;
    ownerId?: string;
    primaryKey?: string;
    scope?: string;
    secondaryKey?: string;
    state?: SubscriptionState;
    stateComment?: string;
}

// @public
export type SubscriptionUpdateResponse = SubscriptionUpdateHeaders & SubscriptionContract;

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

// @public
export interface Tag {
    assignToApi(resourceGroupName: string, serviceName: string, apiId: string, tagId: string, options?: TagAssignToApiOptionalParams): Promise<TagAssignToApiResponse>;
    assignToOperation(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, tagId: string, options?: TagAssignToOperationOptionalParams): Promise<TagAssignToOperationResponse>;
    assignToProduct(resourceGroupName: string, serviceName: string, productId: string, tagId: string, options?: TagAssignToProductOptionalParams): Promise<TagAssignToProductResponse>;
    createOrUpdate(resourceGroupName: string, serviceName: string, tagId: string, parameters: TagCreateUpdateParameters, options?: TagCreateOrUpdateOptionalParams): Promise<TagCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, tagId: string, ifMatch: string, options?: TagDeleteOptionalParams): Promise<void>;
    detachFromApi(resourceGroupName: string, serviceName: string, apiId: string, tagId: string, options?: TagDetachFromApiOptionalParams): Promise<void>;
    detachFromOperation(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, tagId: string, options?: TagDetachFromOperationOptionalParams): Promise<void>;
    detachFromProduct(resourceGroupName: string, serviceName: string, productId: string, tagId: string, options?: TagDetachFromProductOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, tagId: string, options?: TagGetOptionalParams): Promise<TagGetResponse>;
    getByApi(resourceGroupName: string, serviceName: string, apiId: string, tagId: string, options?: TagGetByApiOptionalParams): Promise<TagGetByApiResponse>;
    getByOperation(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, tagId: string, options?: TagGetByOperationOptionalParams): Promise<TagGetByOperationResponse>;
    getByProduct(resourceGroupName: string, serviceName: string, productId: string, tagId: string, options?: TagGetByProductOptionalParams): Promise<TagGetByProductResponse>;
    getEntityState(resourceGroupName: string, serviceName: string, tagId: string, options?: TagGetEntityStateOptionalParams): Promise<TagGetEntityStateResponse>;
    getEntityStateByApi(resourceGroupName: string, serviceName: string, apiId: string, tagId: string, options?: TagGetEntityStateByApiOptionalParams): Promise<TagGetEntityStateByApiResponse>;
    getEntityStateByOperation(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, tagId: string, options?: TagGetEntityStateByOperationOptionalParams): Promise<TagGetEntityStateByOperationResponse>;
    getEntityStateByProduct(resourceGroupName: string, serviceName: string, productId: string, tagId: string, options?: TagGetEntityStateByProductOptionalParams): Promise<TagGetEntityStateByProductResponse>;
    listByApi(resourceGroupName: string, serviceName: string, apiId: string, options?: TagListByApiOptionalParams): PagedAsyncIterableIterator<TagContract>;
    listByOperation(resourceGroupName: string, serviceName: string, apiId: string, operationId: string, options?: TagListByOperationOptionalParams): PagedAsyncIterableIterator<TagContract>;
    listByProduct(resourceGroupName: string, serviceName: string, productId: string, options?: TagListByProductOptionalParams): PagedAsyncIterableIterator<TagContract>;
    listByService(resourceGroupName: string, serviceName: string, options?: TagListByServiceOptionalParams): PagedAsyncIterableIterator<TagContract>;
    update(resourceGroupName: string, serviceName: string, tagId: string, ifMatch: string, parameters: TagCreateUpdateParameters, options?: TagUpdateOptionalParams): Promise<TagUpdateResponse>;
}

// @public
export interface TagApiLink {
    createOrUpdate(resourceGroupName: string, serviceName: string, tagId: string, apiLinkId: string, parameters: TagApiLinkContract, options?: TagApiLinkCreateOrUpdateOptionalParams): Promise<TagApiLinkCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, tagId: string, apiLinkId: string, options?: TagApiLinkDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, tagId: string, apiLinkId: string, options?: TagApiLinkGetOptionalParams): Promise<TagApiLinkGetResponse>;
    listByProduct(resourceGroupName: string, serviceName: string, tagId: string, options?: TagApiLinkListByProductOptionalParams): PagedAsyncIterableIterator<TagApiLinkContract>;
}

// @public
export interface TagApiLinkCollection {
    count?: number;
    nextLink?: string;
    value?: TagApiLinkContract[];
}

// @public
export interface TagApiLinkContract extends ProxyResource {
    apiId?: string;
}

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

// @public
export type TagApiLinkCreateOrUpdateResponse = TagApiLinkContract;

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

// @public
export interface TagApiLinkGetHeaders {
    eTag?: string;
}

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

// @public
export type TagApiLinkGetResponse = TagApiLinkGetHeaders & TagApiLinkContract;

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

// @public
export type TagApiLinkListByProductNextResponse = TagApiLinkCollection;

// @public
export interface TagApiLinkListByProductOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type TagApiLinkListByProductResponse = TagApiLinkCollection;

// @public
export interface TagAssignToApiHeaders {
    eTag?: string;
}

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

// @public
export type TagAssignToApiResponse = TagAssignToApiHeaders & TagContract;

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

// @public
export type TagAssignToOperationResponse = TagContract;

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

// @public
export type TagAssignToProductResponse = TagContract;

// @public
export interface TagCollection {
    count?: number;
    nextLink?: string;
    value?: TagContract[];
}

// @public
export interface TagContract extends ProxyResource {
    displayName?: string;
}

// @public
export interface TagCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface TagCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type TagCreateOrUpdateResponse = TagCreateOrUpdateHeaders & TagContract;

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

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

// @public
export interface TagDescriptionBaseProperties {
    description?: string;
    externalDocsDescription?: string;
    externalDocsUrl?: string;
}

// @public
export interface TagDescriptionCollection {
    count?: number;
    nextLink?: string;
    value?: TagDescriptionContract[];
}

// @public
export interface TagDescriptionContract extends ProxyResource {
    description?: string;
    displayName?: string;
    externalDocsDescription?: string;
    externalDocsUrl?: string;
    tagId?: string;
}

// @public
export interface TagDescriptionContractProperties extends TagDescriptionBaseProperties {
    displayName?: string;
    tagId?: string;
}

// @public
export interface TagDescriptionCreateParameters {
    description?: string;
    externalDocsDescription?: string;
    externalDocsUrl?: string;
}

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

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

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

// @public
export interface TagGetByApiHeaders {
    eTag?: string;
}

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

// @public
export type TagGetByApiResponse = TagGetByApiHeaders & TagContract;

// @public
export interface TagGetByOperationHeaders {
    eTag?: string;
}

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

// @public
export type TagGetByOperationResponse = TagGetByOperationHeaders & TagContract;

// @public
export interface TagGetByProductHeaders {
    eTag?: string;
}

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

// @public
export type TagGetByProductResponse = TagGetByProductHeaders & TagContract;

// @public
export interface TagGetEntityStateByApiHeaders {
    eTag?: string;
}

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

// @public
export type TagGetEntityStateByApiResponse = TagGetEntityStateByApiHeaders;

// @public
export interface TagGetEntityStateByOperationHeaders {
    eTag?: string;
}

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

// @public
export type TagGetEntityStateByOperationResponse = TagGetEntityStateByOperationHeaders;

// @public
export interface TagGetEntityStateByProductHeaders {
    eTag?: string;
}

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

// @public
export type TagGetEntityStateByProductResponse = TagGetEntityStateByProductHeaders;

// @public
export interface TagGetEntityStateHeaders {
    eTag?: string;
}

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

// @public
export type TagGetEntityStateResponse = TagGetEntityStateHeaders;

// @public
export interface TagGetHeaders {
    eTag?: string;
}

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

// @public
export type TagGetResponse = TagGetHeaders & TagContract;

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

// @public
export type TagListByApiNextResponse = TagCollection;

// @public
export interface TagListByApiOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type TagListByApiResponse = TagCollection;

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

// @public
export type TagListByOperationNextResponse = TagCollection;

// @public
export interface TagListByOperationOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type TagListByOperationResponse = TagCollection;

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

// @public
export type TagListByProductNextResponse = TagCollection;

// @public
export interface TagListByProductOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type TagListByProductResponse = TagCollection;

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

// @public
export type TagListByServiceNextResponse = TagCollection;

// @public
export interface TagListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    scope?: string;
    skip?: number;
    top?: number;
}

// @public
export type TagListByServiceResponse = TagCollection;

// @public
export interface TagOperationLink {
    createOrUpdate(resourceGroupName: string, serviceName: string, tagId: string, operationLinkId: string, parameters: TagOperationLinkContract, options?: TagOperationLinkCreateOrUpdateOptionalParams): Promise<TagOperationLinkCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, tagId: string, operationLinkId: string, options?: TagOperationLinkDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, tagId: string, operationLinkId: string, options?: TagOperationLinkGetOptionalParams): Promise<TagOperationLinkGetResponse>;
    listByProduct(resourceGroupName: string, serviceName: string, tagId: string, options?: TagOperationLinkListByProductOptionalParams): PagedAsyncIterableIterator<TagOperationLinkContract>;
}

// @public
export interface TagOperationLinkCollection {
    count?: number;
    nextLink?: string;
    value?: TagOperationLinkContract[];
}

// @public
export interface TagOperationLinkContract extends ProxyResource {
    operationId?: string;
}

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

// @public
export type TagOperationLinkCreateOrUpdateResponse = TagOperationLinkContract;

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

// @public
export interface TagOperationLinkGetHeaders {
    eTag?: string;
}

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

// @public
export type TagOperationLinkGetResponse = TagOperationLinkGetHeaders & TagOperationLinkContract;

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

// @public
export type TagOperationLinkListByProductNextResponse = TagOperationLinkCollection;

// @public
export interface TagOperationLinkListByProductOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type TagOperationLinkListByProductResponse = TagOperationLinkCollection;

// @public
export interface TagProductLink {
    createOrUpdate(resourceGroupName: string, serviceName: string, tagId: string, productLinkId: string, parameters: TagProductLinkContract, options?: TagProductLinkCreateOrUpdateOptionalParams): Promise<TagProductLinkCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, tagId: string, productLinkId: string, options?: TagProductLinkDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, tagId: string, productLinkId: string, options?: TagProductLinkGetOptionalParams): Promise<TagProductLinkGetResponse>;
    listByProduct(resourceGroupName: string, serviceName: string, tagId: string, options?: TagProductLinkListByProductOptionalParams): PagedAsyncIterableIterator<TagProductLinkContract>;
}

// @public
export interface TagProductLinkCollection {
    count?: number;
    nextLink?: string;
    value?: TagProductLinkContract[];
}

// @public
export interface TagProductLinkContract extends ProxyResource {
    productId?: string;
}

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

// @public
export type TagProductLinkCreateOrUpdateResponse = TagProductLinkContract;

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

// @public
export interface TagProductLinkGetHeaders {
    eTag?: string;
}

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

// @public
export type TagProductLinkGetResponse = TagProductLinkGetHeaders & TagProductLinkContract;

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

// @public
export type TagProductLinkListByProductNextResponse = TagProductLinkCollection;

// @public
export interface TagProductLinkListByProductOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type TagProductLinkListByProductResponse = TagProductLinkCollection;

// @public
export interface TagResource {
    listByService(resourceGroupName: string, serviceName: string, options?: TagResourceListByServiceOptionalParams): PagedAsyncIterableIterator<TagResourceContract>;
}

// @public
export interface TagResourceCollection {
    count?: number;
    nextLink?: string;
    value?: TagResourceContract[];
}

// @public
export interface TagResourceContract {
    api?: ApiTagResourceContractProperties;
    operation?: OperationTagResourceContractProperties;
    product?: ProductTagResourceContractProperties;
    tag: TagResourceContractProperties;
}

// @public
export interface TagResourceContractProperties {
    id?: string;
    name?: string;
}

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

// @public
export type TagResourceListByServiceNextResponse = TagResourceCollection;

// @public
export interface TagResourceListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type TagResourceListByServiceResponse = TagResourceCollection;

// @public
export interface TagUpdateHeaders {
    eTag?: string;
}

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

// @public
export type TagUpdateResponse = TagUpdateHeaders & TagContract;

// @public
export type TemplateName = string;

// @public
export interface TenantAccess {
    create(resourceGroupName: string, serviceName: string, accessName: AccessIdName, ifMatch: string, parameters: AccessInformationCreateParameters, options?: TenantAccessCreateOptionalParams): Promise<TenantAccessCreateResponse>;
    get(resourceGroupName: string, serviceName: string, accessName: AccessIdName, options?: TenantAccessGetOptionalParams): Promise<TenantAccessGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, accessName: AccessIdName, options?: TenantAccessGetEntityTagOptionalParams): Promise<TenantAccessGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: TenantAccessListByServiceOptionalParams): PagedAsyncIterableIterator<AccessInformationContract>;
    listSecrets(resourceGroupName: string, serviceName: string, accessName: AccessIdName, options?: TenantAccessListSecretsOptionalParams): Promise<TenantAccessListSecretsResponse>;
    regeneratePrimaryKey(resourceGroupName: string, serviceName: string, accessName: AccessIdName, options?: TenantAccessRegeneratePrimaryKeyOptionalParams): Promise<void>;
    regenerateSecondaryKey(resourceGroupName: string, serviceName: string, accessName: AccessIdName, options?: TenantAccessRegenerateSecondaryKeyOptionalParams): Promise<void>;
    update(resourceGroupName: string, serviceName: string, accessName: AccessIdName, ifMatch: string, parameters: AccessInformationUpdateParameters, options?: TenantAccessUpdateOptionalParams): Promise<TenantAccessUpdateResponse>;
}

// @public
export interface TenantAccessCreateHeaders {
    eTag?: string;
}

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

// @public
export type TenantAccessCreateResponse = TenantAccessCreateHeaders & AccessInformationContract;

// @public
export interface TenantAccessGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type TenantAccessGetEntityTagResponse = TenantAccessGetEntityTagHeaders;

// @public
export interface TenantAccessGetHeaders {
    eTag?: string;
}

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

// @public
export type TenantAccessGetResponse = TenantAccessGetHeaders & AccessInformationContract;

// @public
export interface TenantAccessGit {
    regeneratePrimaryKey(resourceGroupName: string, serviceName: string, accessName: AccessIdName, options?: TenantAccessGitRegeneratePrimaryKeyOptionalParams): Promise<void>;
    regenerateSecondaryKey(resourceGroupName: string, serviceName: string, accessName: AccessIdName, options?: TenantAccessGitRegenerateSecondaryKeyOptionalParams): Promise<void>;
}

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

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

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

// @public
export type TenantAccessListByServiceNextResponse = AccessInformationCollection;

// @public
export interface TenantAccessListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type TenantAccessListByServiceResponse = AccessInformationCollection;

// @public
export interface TenantAccessListSecretsHeaders {
    eTag?: string;
}

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

// @public
export type TenantAccessListSecretsResponse = TenantAccessListSecretsHeaders & AccessInformationSecretsContract;

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

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

// @public
export interface TenantAccessUpdateHeaders {
    eTag?: string;
}

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

// @public
export type TenantAccessUpdateResponse = TenantAccessUpdateHeaders & AccessInformationContract;

// @public
export interface TenantConfiguration {
    beginDeploy(resourceGroupName: string, serviceName: string, configurationName: ConfigurationIdName, parameters: DeployConfigurationParameters, options?: TenantConfigurationDeployOptionalParams): Promise<SimplePollerLike<OperationState<TenantConfigurationDeployResponse>, TenantConfigurationDeployResponse>>;
    beginDeployAndWait(resourceGroupName: string, serviceName: string, configurationName: ConfigurationIdName, parameters: DeployConfigurationParameters, options?: TenantConfigurationDeployOptionalParams): Promise<TenantConfigurationDeployResponse>;
    beginSave(resourceGroupName: string, serviceName: string, configurationName: ConfigurationIdName, parameters: SaveConfigurationParameter, options?: TenantConfigurationSaveOptionalParams): Promise<SimplePollerLike<OperationState<TenantConfigurationSaveResponse>, TenantConfigurationSaveResponse>>;
    beginSaveAndWait(resourceGroupName: string, serviceName: string, configurationName: ConfigurationIdName, parameters: SaveConfigurationParameter, options?: TenantConfigurationSaveOptionalParams): Promise<TenantConfigurationSaveResponse>;
    beginValidate(resourceGroupName: string, serviceName: string, configurationName: ConfigurationIdName, parameters: DeployConfigurationParameters, options?: TenantConfigurationValidateOptionalParams): Promise<SimplePollerLike<OperationState<TenantConfigurationValidateResponse>, TenantConfigurationValidateResponse>>;
    beginValidateAndWait(resourceGroupName: string, serviceName: string, configurationName: ConfigurationIdName, parameters: DeployConfigurationParameters, options?: TenantConfigurationValidateOptionalParams): Promise<TenantConfigurationValidateResponse>;
    getSyncState(resourceGroupName: string, serviceName: string, configurationName: ConfigurationIdName, options?: TenantConfigurationGetSyncStateOptionalParams): Promise<TenantConfigurationGetSyncStateResponse>;
}

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

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

// @public
export type TenantConfigurationDeployResponse = OperationResultContract;

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

// @public
export type TenantConfigurationGetSyncStateResponse = TenantConfigurationSyncStateContract;

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

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

// @public
export type TenantConfigurationSaveResponse = OperationResultContract;

// @public
export interface TenantConfigurationSyncStateContract extends ProxyResource {
    branch?: string;
    commitId?: string;
    configurationChangeDate?: Date;
    isExport?: boolean;
    isGitEnabled?: boolean;
    isSynced?: boolean;
    lastOperationId?: string;
    syncDate?: Date;
}

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

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

// @public
export type TenantConfigurationValidateResponse = OperationResultContract;

// @public
export interface TenantSettings {
    get(resourceGroupName: string, serviceName: string, settingsType: SettingsTypeName, options?: TenantSettingsGetOptionalParams): Promise<TenantSettingsGetResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: TenantSettingsListByServiceOptionalParams): PagedAsyncIterableIterator<TenantSettingsContract>;
}

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

// @public
export interface TenantSettingsContract extends ProxyResource {
    settings?: {
        [propertyName: string]: string;
    };
}

// @public
export interface TenantSettingsGetHeaders {
    eTag?: string;
}

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

// @public
export type TenantSettingsGetResponse = TenantSettingsGetHeaders & TenantSettingsContract;

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

// @public
export type TenantSettingsListByServiceNextResponse = TenantSettingsCollection;

// @public
export interface TenantSettingsListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type TenantSettingsListByServiceResponse = TenantSettingsCollection;

// @public
export interface TermsOfServiceProperties {
    consentRequired?: boolean;
    enabled?: boolean;
    text?: string;
}

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

// @public
export type TranslateRequiredQueryParametersConduct = string;

// @public
export interface User {
    beginDelete(resourceGroupName: string, serviceName: string, userId: string, ifMatch: string, options?: UserDeleteOptionalParams): Promise<SimplePollerLike<OperationState<UserDeleteResponse>, UserDeleteResponse>>;
    beginDeleteAndWait(resourceGroupName: string, serviceName: string, userId: string, ifMatch: string, options?: UserDeleteOptionalParams): Promise<UserDeleteResponse>;
    createOrUpdate(resourceGroupName: string, serviceName: string, userId: string, parameters: UserCreateParameters, options?: UserCreateOrUpdateOptionalParams): Promise<UserCreateOrUpdateResponse>;
    generateSsoUrl(resourceGroupName: string, serviceName: string, userId: string, options?: UserGenerateSsoUrlOptionalParams): Promise<UserGenerateSsoUrlResponse>;
    get(resourceGroupName: string, serviceName: string, userId: string, options?: UserGetOptionalParams): Promise<UserGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, userId: string, options?: UserGetEntityTagOptionalParams): Promise<UserGetEntityTagResponse>;
    getSharedAccessToken(resourceGroupName: string, serviceName: string, userId: string, parameters: UserTokenParameters, options?: UserGetSharedAccessTokenOptionalParams): Promise<UserGetSharedAccessTokenResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: UserListByServiceOptionalParams): PagedAsyncIterableIterator<UserContract>;
    update(resourceGroupName: string, serviceName: string, userId: string, ifMatch: string, parameters: UserUpdateParameters, options?: UserUpdateOptionalParams): Promise<UserUpdateResponse>;
}

// @public
export interface UserCollection {
    count?: number;
    nextLink?: string;
    value?: UserContract[];
}

// @public
export interface UserConfirmationPassword {
    send(resourceGroupName: string, serviceName: string, userId: string, options?: UserConfirmationPasswordSendOptionalParams): Promise<void>;
}

// @public
export interface UserConfirmationPasswordSendOptionalParams extends coreClient.OperationOptions {
    appType?: AppType;
}

// @public
export interface UserContract extends ProxyResource {
    email?: string;
    firstName?: string;
    readonly groups?: GroupContractProperties[];
    identities?: UserIdentityContract[];
    lastName?: string;
    note?: string;
    registrationDate?: Date;
    state?: UserState;
}

// @public
export interface UserContractProperties extends UserEntityBaseParameters {
    email?: string;
    firstName?: string;
    readonly groups?: GroupContractProperties[];
    lastName?: string;
    registrationDate?: Date;
}

// @public
export interface UserCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface UserCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
    notify?: boolean;
}

// @public
export type UserCreateOrUpdateResponse = UserCreateOrUpdateHeaders & UserContract;

// @public
export interface UserCreateParameterProperties extends UserEntityBaseParameters {
    appType?: AppType;
    confirmation?: Confirmation;
    email: string;
    firstName: string;
    lastName: string;
    password?: string;
}

// @public
export interface UserCreateParameters {
    appType?: AppType;
    confirmation?: Confirmation;
    email?: string;
    firstName?: string;
    identities?: UserIdentityContract[];
    lastName?: string;
    note?: string;
    password?: string;
    state?: UserState;
}

// @public
export interface UserDeleteHeaders {
    azureAsyncOperation?: string;
    location?: string;
}

// @public
export interface UserDeleteOptionalParams extends coreClient.OperationOptions {
    appType?: AppType;
    deleteSubscriptions?: boolean;
    notify?: boolean;
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type UserDeleteResponse = UserDeleteHeaders;

// @public
export interface UserEntityBaseParameters {
    identities?: UserIdentityContract[];
    note?: string;
    state?: UserState;
}

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

// @public
export type UserGenerateSsoUrlResponse = GenerateSsoUrlResult;

// @public
export interface UserGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type UserGetEntityTagResponse = UserGetEntityTagHeaders;

// @public
export interface UserGetHeaders {
    eTag?: string;
}

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

// @public
export type UserGetResponse = UserGetHeaders & UserContract;

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

// @public
export type UserGetSharedAccessTokenResponse = UserTokenResult;

// @public
export interface UserGroup {
    list(resourceGroupName: string, serviceName: string, userId: string, options?: UserGroupListOptionalParams): PagedAsyncIterableIterator<GroupContract>;
}

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

// @public
export type UserGroupListNextResponse = GroupCollection;

// @public
export interface UserGroupListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type UserGroupListResponse = GroupCollection;

// @public
export interface UserIdentities {
    list(resourceGroupName: string, serviceName: string, userId: string, options?: UserIdentitiesListOptionalParams): PagedAsyncIterableIterator<UserIdentityContract>;
}

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

// @public
export type UserIdentitiesListNextResponse = UserIdentityCollection;

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

// @public
export type UserIdentitiesListResponse = UserIdentityCollection;

// @public
export interface UserIdentityCollection {
    count?: number;
    nextLink?: string;
    value?: UserIdentityContract[];
}

// @public
export interface UserIdentityContract {
    id?: string;
    provider?: string;
}

// @public (undocumented)
export interface UserIdentityProperties {
    clientId?: string;
    principalId?: string;
}

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

// @public
export type UserListByServiceNextResponse = UserCollection;

// @public
export interface UserListByServiceOptionalParams extends coreClient.OperationOptions {
    expandGroups?: boolean;
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type UserListByServiceResponse = UserCollection;

// @public
export type UserState = string;

// @public
export interface UserSubscription {
    get(resourceGroupName: string, serviceName: string, userId: string, sid: string, options?: UserSubscriptionGetOptionalParams): Promise<UserSubscriptionGetResponse>;
    list(resourceGroupName: string, serviceName: string, userId: string, options?: UserSubscriptionListOptionalParams): PagedAsyncIterableIterator<SubscriptionContract>;
}

// @public
export interface UserSubscriptionGetHeaders {
    eTag?: string;
}

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

// @public
export type UserSubscriptionGetResponse = UserSubscriptionGetHeaders & SubscriptionContract;

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

// @public
export type UserSubscriptionListNextResponse = SubscriptionCollection;

// @public
export interface UserSubscriptionListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type UserSubscriptionListResponse = SubscriptionCollection;

// @public
export interface UserTokenParameters {
    expiry?: Date;
    keyType?: KeyType_2;
}

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

// @public
export interface UserUpdateHeaders {
    eTag?: string;
}

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

// @public
export interface UserUpdateParameters {
    email?: string;
    firstName?: string;
    identities?: UserIdentityContract[];
    lastName?: string;
    note?: string;
    password?: string;
    state?: UserState;
}

// @public
export interface UserUpdateParametersProperties extends UserEntityBaseParameters {
    email?: string;
    firstName?: string;
    lastName?: string;
    password?: string;
}

// @public
export type UserUpdateResponse = UserUpdateHeaders & UserContract;

// @public
export type Verbosity = string;

// @public
export type VersioningScheme = string;

// @public
export interface VirtualNetworkConfiguration {
    readonly subnetname?: string;
    subnetResourceId?: string;
    readonly vnetid?: string;
}

// @public
export type VirtualNetworkType = string;

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

// @public
export interface WikiContract extends ProxyResource {
    documents?: WikiDocumentationContract[];
}

// @public
export interface WikiDocumentationContract {
    documentationId?: string;
}

// @public
export interface WikiUpdateContract {
    documents?: WikiDocumentationContract[];
}

// @public
export interface Workspace {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, parameters: WorkspaceContract, options?: WorkspaceCreateOrUpdateOptionalParams): Promise<WorkspaceCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, ifMatch: string, options?: WorkspaceDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceGetOptionalParams): Promise<WorkspaceGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceGetEntityTagOptionalParams): Promise<WorkspaceGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, options?: WorkspaceListByServiceOptionalParams): PagedAsyncIterableIterator<WorkspaceContract>;
    update(resourceGroupName: string, serviceName: string, workspaceId: string, ifMatch: string, parameters: WorkspaceContract, options?: WorkspaceUpdateOptionalParams): Promise<WorkspaceUpdateResponse>;
}

// @public
export interface WorkspaceApi {
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, parameters: ApiCreateOrUpdateParameter, options?: WorkspaceApiCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<WorkspaceApiCreateOrUpdateResponse>, WorkspaceApiCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, parameters: ApiCreateOrUpdateParameter, options?: WorkspaceApiCreateOrUpdateOptionalParams): Promise<WorkspaceApiCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, ifMatch: string, options?: WorkspaceApiDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, options?: WorkspaceApiGetOptionalParams): Promise<WorkspaceApiGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, options?: WorkspaceApiGetEntityTagOptionalParams): Promise<WorkspaceApiGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceApiListByServiceOptionalParams): PagedAsyncIterableIterator<ApiContract>;
    update(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, ifMatch: string, parameters: ApiUpdateContract, options?: WorkspaceApiUpdateOptionalParams): Promise<WorkspaceApiUpdateResponse>;
}

// @public
export interface WorkspaceApiCreateOrUpdateHeaders {
    azureAsyncOperation?: string;
    eTag?: string;
    location?: string;
}

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

// @public
export type WorkspaceApiCreateOrUpdateResponse = WorkspaceApiCreateOrUpdateHeaders & ApiContract;

// @public
export interface WorkspaceApiDeleteOptionalParams extends coreClient.OperationOptions {
    deleteRevisions?: boolean;
}

// @public
export interface WorkspaceApiDiagnostic {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, diagnosticId: string, parameters: DiagnosticContract, options?: WorkspaceApiDiagnosticCreateOrUpdateOptionalParams): Promise<WorkspaceApiDiagnosticCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, diagnosticId: string, ifMatch: string, options?: WorkspaceApiDiagnosticDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, diagnosticId: string, options?: WorkspaceApiDiagnosticGetOptionalParams): Promise<WorkspaceApiDiagnosticGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, diagnosticId: string, options?: WorkspaceApiDiagnosticGetEntityTagOptionalParams): Promise<WorkspaceApiDiagnosticGetEntityTagResponse>;
    listByWorkspace(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, options?: WorkspaceApiDiagnosticListByWorkspaceOptionalParams): PagedAsyncIterableIterator<DiagnosticContract>;
    update(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, diagnosticId: string, ifMatch: string, parameters: DiagnosticUpdateContract, options?: WorkspaceApiDiagnosticUpdateOptionalParams): Promise<WorkspaceApiDiagnosticUpdateResponse>;
}

// @public
export interface WorkspaceApiDiagnosticCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceApiDiagnosticCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceApiDiagnosticCreateOrUpdateResponse = WorkspaceApiDiagnosticCreateOrUpdateHeaders & DiagnosticContract;

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

// @public
export interface WorkspaceApiDiagnosticGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiDiagnosticGetEntityTagResponse = WorkspaceApiDiagnosticGetEntityTagHeaders;

// @public
export interface WorkspaceApiDiagnosticGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiDiagnosticGetResponse = WorkspaceApiDiagnosticGetHeaders & DiagnosticContract;

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

// @public
export type WorkspaceApiDiagnosticListByWorkspaceNextResponse = DiagnosticCollection;

// @public
export interface WorkspaceApiDiagnosticListByWorkspaceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceApiDiagnosticListByWorkspaceResponse = DiagnosticCollection;

// @public
export interface WorkspaceApiDiagnosticUpdateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiDiagnosticUpdateResponse = WorkspaceApiDiagnosticUpdateHeaders & DiagnosticContract;

// @public
export interface WorkspaceApiExport {
    get(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, format: ExportFormat, exportParam: ExportApi, options?: WorkspaceApiExportGetOptionalParams): Promise<WorkspaceApiExportGetResponse>;
}

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

// @public
export type WorkspaceApiExportGetResponse = ApiExportResult;

// @public
export interface WorkspaceApiGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiGetEntityTagResponse = WorkspaceApiGetEntityTagHeaders;

// @public
export interface WorkspaceApiGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiGetResponse = WorkspaceApiGetHeaders & ApiContract;

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

// @public
export type WorkspaceApiListByServiceNextResponse = ApiCollection;

// @public
export interface WorkspaceApiListByServiceOptionalParams extends coreClient.OperationOptions {
    expandApiVersionSet?: boolean;
    filter?: string;
    skip?: number;
    tags?: string;
    top?: number;
}

// @public
export type WorkspaceApiListByServiceResponse = ApiCollection;

// @public
export interface WorkspaceApiOperation {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, operationId: string, parameters: OperationContract, options?: WorkspaceApiOperationCreateOrUpdateOptionalParams): Promise<WorkspaceApiOperationCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, operationId: string, ifMatch: string, options?: WorkspaceApiOperationDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, operationId: string, options?: WorkspaceApiOperationGetOptionalParams): Promise<WorkspaceApiOperationGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, operationId: string, options?: WorkspaceApiOperationGetEntityTagOptionalParams): Promise<WorkspaceApiOperationGetEntityTagResponse>;
    listByApi(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, options?: WorkspaceApiOperationListByApiOptionalParams): PagedAsyncIterableIterator<OperationContract>;
    update(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, operationId: string, ifMatch: string, parameters: OperationUpdateContract, options?: WorkspaceApiOperationUpdateOptionalParams): Promise<WorkspaceApiOperationUpdateResponse>;
}

// @public
export interface WorkspaceApiOperationCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceApiOperationCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceApiOperationCreateOrUpdateResponse = WorkspaceApiOperationCreateOrUpdateHeaders & OperationContract;

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

// @public
export interface WorkspaceApiOperationGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiOperationGetEntityTagResponse = WorkspaceApiOperationGetEntityTagHeaders;

// @public
export interface WorkspaceApiOperationGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiOperationGetResponse = WorkspaceApiOperationGetHeaders & OperationContract;

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

// @public
export type WorkspaceApiOperationListByApiNextResponse = OperationCollection;

// @public
export interface WorkspaceApiOperationListByApiOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    tags?: string;
    top?: number;
}

// @public
export type WorkspaceApiOperationListByApiResponse = OperationCollection;

// @public
export interface WorkspaceApiOperationPolicy {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, operationId: string, policyId: PolicyIdName, parameters: PolicyContract, options?: WorkspaceApiOperationPolicyCreateOrUpdateOptionalParams): Promise<WorkspaceApiOperationPolicyCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, operationId: string, policyId: PolicyIdName, ifMatch: string, options?: WorkspaceApiOperationPolicyDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, operationId: string, policyId: PolicyIdName, options?: WorkspaceApiOperationPolicyGetOptionalParams): Promise<WorkspaceApiOperationPolicyGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, operationId: string, policyId: PolicyIdName, options?: WorkspaceApiOperationPolicyGetEntityTagOptionalParams): Promise<WorkspaceApiOperationPolicyGetEntityTagResponse>;
    listByOperation(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, operationId: string, options?: WorkspaceApiOperationPolicyListByOperationOptionalParams): PagedAsyncIterableIterator<PolicyContract>;
}

// @public
export interface WorkspaceApiOperationPolicyCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceApiOperationPolicyCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceApiOperationPolicyCreateOrUpdateResponse = WorkspaceApiOperationPolicyCreateOrUpdateHeaders & PolicyContract;

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

// @public
export interface WorkspaceApiOperationPolicyGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiOperationPolicyGetEntityTagResponse = WorkspaceApiOperationPolicyGetEntityTagHeaders;

// @public
export interface WorkspaceApiOperationPolicyGetHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceApiOperationPolicyGetOptionalParams extends coreClient.OperationOptions {
    format?: PolicyExportFormat;
}

// @public
export type WorkspaceApiOperationPolicyGetResponse = WorkspaceApiOperationPolicyGetHeaders & PolicyContract;

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

// @public
export type WorkspaceApiOperationPolicyListByOperationNextResponse = PolicyCollection;

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

// @public
export type WorkspaceApiOperationPolicyListByOperationResponse = PolicyCollection;

// @public
export interface WorkspaceApiOperationUpdateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiOperationUpdateResponse = WorkspaceApiOperationUpdateHeaders & OperationContract;

// @public
export interface WorkspaceApiPolicy {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, policyId: PolicyIdName, parameters: PolicyContract, options?: WorkspaceApiPolicyCreateOrUpdateOptionalParams): Promise<WorkspaceApiPolicyCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, policyId: PolicyIdName, ifMatch: string, options?: WorkspaceApiPolicyDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, policyId: PolicyIdName, options?: WorkspaceApiPolicyGetOptionalParams): Promise<WorkspaceApiPolicyGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, policyId: PolicyIdName, options?: WorkspaceApiPolicyGetEntityTagOptionalParams): Promise<WorkspaceApiPolicyGetEntityTagResponse>;
    listByApi(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, options?: WorkspaceApiPolicyListByApiOptionalParams): PagedAsyncIterableIterator<PolicyContract>;
}

// @public
export interface WorkspaceApiPolicyCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceApiPolicyCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceApiPolicyCreateOrUpdateResponse = WorkspaceApiPolicyCreateOrUpdateHeaders & PolicyContract;

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

// @public
export interface WorkspaceApiPolicyGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiPolicyGetEntityTagResponse = WorkspaceApiPolicyGetEntityTagHeaders;

// @public
export interface WorkspaceApiPolicyGetHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceApiPolicyGetOptionalParams extends coreClient.OperationOptions {
    format?: PolicyExportFormat;
}

// @public
export type WorkspaceApiPolicyGetResponse = WorkspaceApiPolicyGetHeaders & PolicyContract;

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

// @public
export type WorkspaceApiPolicyListByApiNextResponse = PolicyCollection;

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

// @public
export type WorkspaceApiPolicyListByApiResponse = PolicyCollection;

// @public
export interface WorkspaceApiRelease {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, releaseId: string, parameters: ApiReleaseContract, options?: WorkspaceApiReleaseCreateOrUpdateOptionalParams): Promise<WorkspaceApiReleaseCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, releaseId: string, ifMatch: string, options?: WorkspaceApiReleaseDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, releaseId: string, options?: WorkspaceApiReleaseGetOptionalParams): Promise<WorkspaceApiReleaseGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, releaseId: string, options?: WorkspaceApiReleaseGetEntityTagOptionalParams): Promise<WorkspaceApiReleaseGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, options?: WorkspaceApiReleaseListByServiceOptionalParams): PagedAsyncIterableIterator<ApiReleaseContract>;
    update(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, releaseId: string, ifMatch: string, parameters: ApiReleaseContract, options?: WorkspaceApiReleaseUpdateOptionalParams): Promise<WorkspaceApiReleaseUpdateResponse>;
}

// @public
export interface WorkspaceApiReleaseCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceApiReleaseCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceApiReleaseCreateOrUpdateResponse = WorkspaceApiReleaseCreateOrUpdateHeaders & ApiReleaseContract;

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

// @public
export interface WorkspaceApiReleaseGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiReleaseGetEntityTagResponse = WorkspaceApiReleaseGetEntityTagHeaders;

// @public
export interface WorkspaceApiReleaseGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiReleaseGetResponse = WorkspaceApiReleaseGetHeaders & ApiReleaseContract;

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

// @public
export type WorkspaceApiReleaseListByServiceNextResponse = ApiReleaseCollection;

// @public
export interface WorkspaceApiReleaseListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceApiReleaseListByServiceResponse = ApiReleaseCollection;

// @public
export interface WorkspaceApiReleaseUpdateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiReleaseUpdateResponse = WorkspaceApiReleaseUpdateHeaders & ApiReleaseContract;

// @public
export interface WorkspaceApiRevision {
    listByService(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, options?: WorkspaceApiRevisionListByServiceOptionalParams): PagedAsyncIterableIterator<ApiRevisionContract>;
}

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

// @public
export type WorkspaceApiRevisionListByServiceNextResponse = ApiRevisionCollection;

// @public
export interface WorkspaceApiRevisionListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceApiRevisionListByServiceResponse = ApiRevisionCollection;

// @public
export interface WorkspaceApiSchema {
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, schemaId: string, parameters: SchemaContract, options?: WorkspaceApiSchemaCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<WorkspaceApiSchemaCreateOrUpdateResponse>, WorkspaceApiSchemaCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, schemaId: string, parameters: SchemaContract, options?: WorkspaceApiSchemaCreateOrUpdateOptionalParams): Promise<WorkspaceApiSchemaCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, schemaId: string, ifMatch: string, options?: WorkspaceApiSchemaDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, schemaId: string, options?: WorkspaceApiSchemaGetOptionalParams): Promise<WorkspaceApiSchemaGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, schemaId: string, options?: WorkspaceApiSchemaGetEntityTagOptionalParams): Promise<WorkspaceApiSchemaGetEntityTagResponse>;
    listByApi(resourceGroupName: string, serviceName: string, workspaceId: string, apiId: string, options?: WorkspaceApiSchemaListByApiOptionalParams): PagedAsyncIterableIterator<SchemaContract>;
}

// @public
export interface WorkspaceApiSchemaCreateOrUpdateHeaders {
    azureAsyncOperation?: string;
    eTag?: string;
    location?: string;
}

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

// @public
export type WorkspaceApiSchemaCreateOrUpdateResponse = WorkspaceApiSchemaCreateOrUpdateHeaders & SchemaContract;

// @public
export interface WorkspaceApiSchemaDeleteOptionalParams extends coreClient.OperationOptions {
    force?: boolean;
}

// @public
export interface WorkspaceApiSchemaGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiSchemaGetEntityTagResponse = WorkspaceApiSchemaGetEntityTagHeaders;

// @public
export interface WorkspaceApiSchemaGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiSchemaGetResponse = WorkspaceApiSchemaGetHeaders & SchemaContract;

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

// @public
export type WorkspaceApiSchemaListByApiNextResponse = SchemaCollection;

// @public
export interface WorkspaceApiSchemaListByApiOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceApiSchemaListByApiResponse = SchemaCollection;

// @public
export interface WorkspaceApiUpdateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiUpdateResponse = WorkspaceApiUpdateHeaders & ApiContract;

// @public
export interface WorkspaceApiVersionSet {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, versionSetId: string, parameters: ApiVersionSetContract, options?: WorkspaceApiVersionSetCreateOrUpdateOptionalParams): Promise<WorkspaceApiVersionSetCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, versionSetId: string, ifMatch: string, options?: WorkspaceApiVersionSetDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, versionSetId: string, options?: WorkspaceApiVersionSetGetOptionalParams): Promise<WorkspaceApiVersionSetGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, versionSetId: string, options?: WorkspaceApiVersionSetGetEntityTagOptionalParams): Promise<WorkspaceApiVersionSetGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceApiVersionSetListByServiceOptionalParams): PagedAsyncIterableIterator<ApiVersionSetContract>;
    update(resourceGroupName: string, serviceName: string, workspaceId: string, versionSetId: string, ifMatch: string, parameters: ApiVersionSetUpdateParameters, options?: WorkspaceApiVersionSetUpdateOptionalParams): Promise<WorkspaceApiVersionSetUpdateResponse>;
}

// @public
export interface WorkspaceApiVersionSetCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceApiVersionSetCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceApiVersionSetCreateOrUpdateResponse = WorkspaceApiVersionSetCreateOrUpdateHeaders & ApiVersionSetContract;

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

// @public
export interface WorkspaceApiVersionSetGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiVersionSetGetEntityTagResponse = WorkspaceApiVersionSetGetEntityTagHeaders;

// @public
export interface WorkspaceApiVersionSetGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiVersionSetGetResponse = WorkspaceApiVersionSetGetHeaders & ApiVersionSetContract;

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

// @public
export type WorkspaceApiVersionSetListByServiceNextResponse = ApiVersionSetCollection;

// @public
export interface WorkspaceApiVersionSetListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceApiVersionSetListByServiceResponse = ApiVersionSetCollection;

// @public
export interface WorkspaceApiVersionSetUpdateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceApiVersionSetUpdateResponse = WorkspaceApiVersionSetUpdateHeaders & ApiVersionSetContract;

// @public
export interface WorkspaceBackend {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, backendId: string, parameters: BackendContract, options?: WorkspaceBackendCreateOrUpdateOptionalParams): Promise<WorkspaceBackendCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, backendId: string, ifMatch: string, options?: WorkspaceBackendDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, backendId: string, options?: WorkspaceBackendGetOptionalParams): Promise<WorkspaceBackendGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, backendId: string, options?: WorkspaceBackendGetEntityTagOptionalParams): Promise<WorkspaceBackendGetEntityTagResponse>;
    listByWorkspace(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceBackendListByWorkspaceOptionalParams): PagedAsyncIterableIterator<BackendContract>;
    update(resourceGroupName: string, serviceName: string, workspaceId: string, backendId: string, ifMatch: string, parameters: BackendUpdateParameters, options?: WorkspaceBackendUpdateOptionalParams): Promise<WorkspaceBackendUpdateResponse>;
}

// @public
export interface WorkspaceBackendCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceBackendCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceBackendCreateOrUpdateResponse = WorkspaceBackendCreateOrUpdateHeaders & BackendContract;

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

// @public
export interface WorkspaceBackendGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceBackendGetEntityTagResponse = WorkspaceBackendGetEntityTagHeaders;

// @public
export interface WorkspaceBackendGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceBackendGetResponse = WorkspaceBackendGetHeaders & BackendContract;

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

// @public
export type WorkspaceBackendListByWorkspaceNextResponse = BackendCollection;

// @public
export interface WorkspaceBackendListByWorkspaceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceBackendListByWorkspaceResponse = BackendCollection;

// @public
export interface WorkspaceBackendUpdateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceBackendUpdateResponse = WorkspaceBackendUpdateHeaders & BackendContract;

// @public
export interface WorkspaceCertificate {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, certificateId: string, parameters: CertificateCreateOrUpdateParameters, options?: WorkspaceCertificateCreateOrUpdateOptionalParams): Promise<WorkspaceCertificateCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, certificateId: string, ifMatch: string, options?: WorkspaceCertificateDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, certificateId: string, options?: WorkspaceCertificateGetOptionalParams): Promise<WorkspaceCertificateGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, certificateId: string, options?: WorkspaceCertificateGetEntityTagOptionalParams): Promise<WorkspaceCertificateGetEntityTagResponse>;
    listByWorkspace(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceCertificateListByWorkspaceOptionalParams): PagedAsyncIterableIterator<CertificateContract>;
    refreshSecret(resourceGroupName: string, serviceName: string, workspaceId: string, certificateId: string, options?: WorkspaceCertificateRefreshSecretOptionalParams): Promise<WorkspaceCertificateRefreshSecretResponse>;
}

// @public
export interface WorkspaceCertificateCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceCertificateCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceCertificateCreateOrUpdateResponse = WorkspaceCertificateCreateOrUpdateHeaders & CertificateContract;

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

// @public
export interface WorkspaceCertificateGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceCertificateGetEntityTagResponse = WorkspaceCertificateGetEntityTagHeaders;

// @public
export interface WorkspaceCertificateGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceCertificateGetResponse = WorkspaceCertificateGetHeaders & CertificateContract;

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

// @public
export type WorkspaceCertificateListByWorkspaceNextResponse = CertificateCollection;

// @public
export interface WorkspaceCertificateListByWorkspaceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    isKeyVaultRefreshFailed?: boolean;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceCertificateListByWorkspaceResponse = CertificateCollection;

// @public
export interface WorkspaceCertificateRefreshSecretHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceCertificateRefreshSecretResponse = WorkspaceCertificateRefreshSecretHeaders & CertificateContract;

// @public
export interface WorkspaceCollection {
    count?: number;
    nextLink?: string;
    value?: WorkspaceContract[];
}

// @public
export interface WorkspaceContract extends ProxyResource {
    description?: string;
    displayName?: string;
}

// @public
export interface WorkspaceCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceCreateOrUpdateResponse = WorkspaceCreateOrUpdateHeaders & WorkspaceContract;

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

// @public
export interface WorkspaceDiagnostic {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, diagnosticId: string, parameters: DiagnosticContract, options?: WorkspaceDiagnosticCreateOrUpdateOptionalParams): Promise<WorkspaceDiagnosticCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, diagnosticId: string, ifMatch: string, options?: WorkspaceDiagnosticDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, diagnosticId: string, options?: WorkspaceDiagnosticGetOptionalParams): Promise<WorkspaceDiagnosticGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, diagnosticId: string, options?: WorkspaceDiagnosticGetEntityTagOptionalParams): Promise<WorkspaceDiagnosticGetEntityTagResponse>;
    listByWorkspace(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceDiagnosticListByWorkspaceOptionalParams): PagedAsyncIterableIterator<DiagnosticContract>;
    update(resourceGroupName: string, serviceName: string, workspaceId: string, diagnosticId: string, ifMatch: string, parameters: DiagnosticUpdateContract, options?: WorkspaceDiagnosticUpdateOptionalParams): Promise<WorkspaceDiagnosticUpdateResponse>;
}

// @public
export interface WorkspaceDiagnosticCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceDiagnosticCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceDiagnosticCreateOrUpdateResponse = WorkspaceDiagnosticCreateOrUpdateHeaders & DiagnosticContract;

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

// @public
export interface WorkspaceDiagnosticGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceDiagnosticGetEntityTagResponse = WorkspaceDiagnosticGetEntityTagHeaders;

// @public
export interface WorkspaceDiagnosticGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceDiagnosticGetResponse = WorkspaceDiagnosticGetHeaders & DiagnosticContract;

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

// @public
export type WorkspaceDiagnosticListByWorkspaceNextResponse = DiagnosticCollection;

// @public
export interface WorkspaceDiagnosticListByWorkspaceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceDiagnosticListByWorkspaceResponse = DiagnosticCollection;

// @public
export interface WorkspaceDiagnosticUpdateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceDiagnosticUpdateResponse = WorkspaceDiagnosticUpdateHeaders & DiagnosticContract;

// @public
export interface WorkspaceGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceGetEntityTagResponse = WorkspaceGetEntityTagHeaders;

// @public
export interface WorkspaceGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceGetResponse = WorkspaceGetHeaders & WorkspaceContract;

// @public
export interface WorkspaceGlobalSchema {
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, schemaId: string, parameters: GlobalSchemaContract, options?: WorkspaceGlobalSchemaCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<WorkspaceGlobalSchemaCreateOrUpdateResponse>, WorkspaceGlobalSchemaCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, workspaceId: string, schemaId: string, parameters: GlobalSchemaContract, options?: WorkspaceGlobalSchemaCreateOrUpdateOptionalParams): Promise<WorkspaceGlobalSchemaCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, schemaId: string, ifMatch: string, options?: WorkspaceGlobalSchemaDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, schemaId: string, options?: WorkspaceGlobalSchemaGetOptionalParams): Promise<WorkspaceGlobalSchemaGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, schemaId: string, options?: WorkspaceGlobalSchemaGetEntityTagOptionalParams): Promise<WorkspaceGlobalSchemaGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceGlobalSchemaListByServiceOptionalParams): PagedAsyncIterableIterator<GlobalSchemaContract>;
}

// @public
export interface WorkspaceGlobalSchemaCreateOrUpdateHeaders {
    azureAsyncOperation?: string;
    eTag?: string;
    location?: string;
}

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

// @public
export type WorkspaceGlobalSchemaCreateOrUpdateResponse = WorkspaceGlobalSchemaCreateOrUpdateHeaders & GlobalSchemaContract;

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

// @public
export interface WorkspaceGlobalSchemaGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceGlobalSchemaGetEntityTagResponse = WorkspaceGlobalSchemaGetEntityTagHeaders;

// @public
export interface WorkspaceGlobalSchemaGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceGlobalSchemaGetResponse = WorkspaceGlobalSchemaGetHeaders & GlobalSchemaContract;

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

// @public
export type WorkspaceGlobalSchemaListByServiceNextResponse = GlobalSchemaCollection;

// @public
export interface WorkspaceGlobalSchemaListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceGlobalSchemaListByServiceResponse = GlobalSchemaCollection;

// @public
export interface WorkspaceGroup {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, groupId: string, parameters: GroupCreateParameters, options?: WorkspaceGroupCreateOrUpdateOptionalParams): Promise<WorkspaceGroupCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, groupId: string, ifMatch: string, options?: WorkspaceGroupDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, groupId: string, options?: WorkspaceGroupGetOptionalParams): Promise<WorkspaceGroupGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, groupId: string, options?: WorkspaceGroupGetEntityTagOptionalParams): Promise<WorkspaceGroupGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceGroupListByServiceOptionalParams): PagedAsyncIterableIterator<GroupContract>;
    update(resourceGroupName: string, serviceName: string, workspaceId: string, groupId: string, ifMatch: string, parameters: GroupUpdateParameters, options?: WorkspaceGroupUpdateOptionalParams): Promise<WorkspaceGroupUpdateResponse>;
}

// @public
export interface WorkspaceGroupCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceGroupCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceGroupCreateOrUpdateResponse = WorkspaceGroupCreateOrUpdateHeaders & GroupContract;

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

// @public
export interface WorkspaceGroupGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceGroupGetEntityTagResponse = WorkspaceGroupGetEntityTagHeaders;

// @public
export interface WorkspaceGroupGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceGroupGetResponse = WorkspaceGroupGetHeaders & GroupContract;

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

// @public
export type WorkspaceGroupListByServiceNextResponse = GroupCollection;

// @public
export interface WorkspaceGroupListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceGroupListByServiceResponse = GroupCollection;

// @public
export interface WorkspaceGroupUpdateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceGroupUpdateResponse = WorkspaceGroupUpdateHeaders & GroupContract;

// @public
export interface WorkspaceGroupUser {
    checkEntityExists(resourceGroupName: string, serviceName: string, workspaceId: string, groupId: string, userId: string, options?: WorkspaceGroupUserCheckEntityExistsOptionalParams): Promise<WorkspaceGroupUserCheckEntityExistsResponse>;
    create(resourceGroupName: string, serviceName: string, workspaceId: string, groupId: string, userId: string, options?: WorkspaceGroupUserCreateOptionalParams): Promise<WorkspaceGroupUserCreateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, groupId: string, userId: string, options?: WorkspaceGroupUserDeleteOptionalParams): Promise<void>;
    list(resourceGroupName: string, serviceName: string, workspaceId: string, groupId: string, options?: WorkspaceGroupUserListOptionalParams): PagedAsyncIterableIterator<UserContract>;
}

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

// @public
export type WorkspaceGroupUserCheckEntityExistsResponse = {
    body: boolean;
};

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

// @public
export type WorkspaceGroupUserCreateResponse = UserContract;

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

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

// @public
export type WorkspaceGroupUserListNextResponse = UserCollection;

// @public
export interface WorkspaceGroupUserListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceGroupUserListResponse = UserCollection;

// @public (undocumented)
export interface WorkspaceLinksBaseProperties {
    gateways?: WorkspaceLinksGateway[];
    workspaceId?: string;
}

// @public (undocumented)
export interface WorkspaceLinksGateway {
    id?: string;
}

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

// @public
export type WorkspaceListByServiceNextResponse = WorkspaceCollection;

// @public
export interface WorkspaceListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceListByServiceResponse = WorkspaceCollection;

// @public
export interface WorkspaceLogger {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, loggerId: string, parameters: LoggerContract, options?: WorkspaceLoggerCreateOrUpdateOptionalParams): Promise<WorkspaceLoggerCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, loggerId: string, ifMatch: string, options?: WorkspaceLoggerDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, loggerId: string, options?: WorkspaceLoggerGetOptionalParams): Promise<WorkspaceLoggerGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, loggerId: string, options?: WorkspaceLoggerGetEntityTagOptionalParams): Promise<WorkspaceLoggerGetEntityTagResponse>;
    listByWorkspace(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceLoggerListByWorkspaceOptionalParams): PagedAsyncIterableIterator<LoggerContract>;
    update(resourceGroupName: string, serviceName: string, workspaceId: string, loggerId: string, ifMatch: string, parameters: LoggerUpdateContract, options?: WorkspaceLoggerUpdateOptionalParams): Promise<WorkspaceLoggerUpdateResponse>;
}

// @public
export interface WorkspaceLoggerCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceLoggerCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceLoggerCreateOrUpdateResponse = WorkspaceLoggerCreateOrUpdateHeaders & LoggerContract;

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

// @public
export interface WorkspaceLoggerGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceLoggerGetEntityTagResponse = WorkspaceLoggerGetEntityTagHeaders;

// @public
export interface WorkspaceLoggerGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceLoggerGetResponse = WorkspaceLoggerGetHeaders & LoggerContract;

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

// @public
export type WorkspaceLoggerListByWorkspaceNextResponse = LoggerCollection;

// @public
export interface WorkspaceLoggerListByWorkspaceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceLoggerListByWorkspaceResponse = LoggerCollection;

// @public
export interface WorkspaceLoggerUpdateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceLoggerUpdateResponse = WorkspaceLoggerUpdateHeaders & LoggerContract;

// @public
export interface WorkspaceNamedValue {
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, namedValueId: string, parameters: NamedValueCreateContract, options?: WorkspaceNamedValueCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<WorkspaceNamedValueCreateOrUpdateResponse>, WorkspaceNamedValueCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, workspaceId: string, namedValueId: string, parameters: NamedValueCreateContract, options?: WorkspaceNamedValueCreateOrUpdateOptionalParams): Promise<WorkspaceNamedValueCreateOrUpdateResponse>;
    beginRefreshSecret(resourceGroupName: string, serviceName: string, workspaceId: string, namedValueId: string, options?: WorkspaceNamedValueRefreshSecretOptionalParams): Promise<SimplePollerLike<OperationState<WorkspaceNamedValueRefreshSecretResponse>, WorkspaceNamedValueRefreshSecretResponse>>;
    beginRefreshSecretAndWait(resourceGroupName: string, serviceName: string, workspaceId: string, namedValueId: string, options?: WorkspaceNamedValueRefreshSecretOptionalParams): Promise<WorkspaceNamedValueRefreshSecretResponse>;
    beginUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, namedValueId: string, ifMatch: string, parameters: NamedValueUpdateParameters, options?: WorkspaceNamedValueUpdateOptionalParams): Promise<SimplePollerLike<OperationState<WorkspaceNamedValueUpdateResponse>, WorkspaceNamedValueUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, serviceName: string, workspaceId: string, namedValueId: string, ifMatch: string, parameters: NamedValueUpdateParameters, options?: WorkspaceNamedValueUpdateOptionalParams): Promise<WorkspaceNamedValueUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, namedValueId: string, ifMatch: string, options?: WorkspaceNamedValueDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, namedValueId: string, options?: WorkspaceNamedValueGetOptionalParams): Promise<WorkspaceNamedValueGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, namedValueId: string, options?: WorkspaceNamedValueGetEntityTagOptionalParams): Promise<WorkspaceNamedValueGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceNamedValueListByServiceOptionalParams): PagedAsyncIterableIterator<NamedValueContract>;
    listValue(resourceGroupName: string, serviceName: string, workspaceId: string, namedValueId: string, options?: WorkspaceNamedValueListValueOptionalParams): Promise<WorkspaceNamedValueListValueResponse>;
}

// @public
export interface WorkspaceNamedValueCreateOrUpdateHeaders {
    azureAsyncOperation?: string;
    eTag?: string;
    location?: string;
}

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

// @public
export type WorkspaceNamedValueCreateOrUpdateResponse = WorkspaceNamedValueCreateOrUpdateHeaders & NamedValueContract;

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

// @public
export interface WorkspaceNamedValueGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceNamedValueGetEntityTagResponse = WorkspaceNamedValueGetEntityTagHeaders;

// @public
export interface WorkspaceNamedValueGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceNamedValueGetResponse = WorkspaceNamedValueGetHeaders & NamedValueContract;

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

// @public
export type WorkspaceNamedValueListByServiceNextResponse = NamedValueCollection;

// @public
export interface WorkspaceNamedValueListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    isKeyVaultRefreshFailed?: KeyVaultRefreshState;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceNamedValueListByServiceResponse = NamedValueCollection;

// @public
export interface WorkspaceNamedValueListValueHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceNamedValueListValueResponse = WorkspaceNamedValueListValueHeaders & NamedValueSecretContract;

// @public
export interface WorkspaceNamedValueRefreshSecretHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceNamedValueRefreshSecretResponse = WorkspaceNamedValueRefreshSecretHeaders & NamedValueContract;

// @public
export interface WorkspaceNamedValueUpdateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceNamedValueUpdateResponse = WorkspaceNamedValueUpdateHeaders & NamedValueContract;

// @public
export interface WorkspaceNotification {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, notificationName: NotificationName, options?: WorkspaceNotificationCreateOrUpdateOptionalParams): Promise<WorkspaceNotificationCreateOrUpdateResponse>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, notificationName: NotificationName, options?: WorkspaceNotificationGetOptionalParams): Promise<WorkspaceNotificationGetResponse>;
    listByService(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceNotificationListByServiceOptionalParams): PagedAsyncIterableIterator<NotificationContract>;
}

// @public
export interface WorkspaceNotificationCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceNotificationCreateOrUpdateResponse = NotificationContract;

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

// @public
export type WorkspaceNotificationGetResponse = NotificationContract;

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

// @public
export type WorkspaceNotificationListByServiceNextResponse = NotificationCollection;

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

// @public
export type WorkspaceNotificationListByServiceResponse = NotificationCollection;

// @public
export interface WorkspaceNotificationRecipientEmail {
    checkEntityExists(resourceGroupName: string, serviceName: string, workspaceId: string, notificationName: NotificationName, email: string, options?: WorkspaceNotificationRecipientEmailCheckEntityExistsOptionalParams): Promise<WorkspaceNotificationRecipientEmailCheckEntityExistsResponse>;
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, notificationName: NotificationName, email: string, options?: WorkspaceNotificationRecipientEmailCreateOrUpdateOptionalParams): Promise<WorkspaceNotificationRecipientEmailCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, notificationName: NotificationName, email: string, options?: WorkspaceNotificationRecipientEmailDeleteOptionalParams): Promise<void>;
    listByNotification(resourceGroupName: string, serviceName: string, workspaceId: string, notificationName: NotificationName, options?: WorkspaceNotificationRecipientEmailListByNotificationOptionalParams): Promise<WorkspaceNotificationRecipientEmailListByNotificationResponse>;
}

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

// @public
export type WorkspaceNotificationRecipientEmailCheckEntityExistsResponse = {
    body: boolean;
};

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

// @public
export type WorkspaceNotificationRecipientEmailCreateOrUpdateResponse = RecipientEmailContract;

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

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

// @public
export type WorkspaceNotificationRecipientEmailListByNotificationResponse = RecipientEmailCollection;

// @public
export interface WorkspaceNotificationRecipientUser {
    checkEntityExists(resourceGroupName: string, serviceName: string, workspaceId: string, notificationName: NotificationName, userId: string, options?: WorkspaceNotificationRecipientUserCheckEntityExistsOptionalParams): Promise<WorkspaceNotificationRecipientUserCheckEntityExistsResponse>;
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, notificationName: NotificationName, userId: string, options?: WorkspaceNotificationRecipientUserCreateOrUpdateOptionalParams): Promise<WorkspaceNotificationRecipientUserCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, notificationName: NotificationName, userId: string, options?: WorkspaceNotificationRecipientUserDeleteOptionalParams): Promise<void>;
    listByNotification(resourceGroupName: string, serviceName: string, workspaceId: string, notificationName: NotificationName, options?: WorkspaceNotificationRecipientUserListByNotificationOptionalParams): Promise<WorkspaceNotificationRecipientUserListByNotificationResponse>;
}

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

// @public
export type WorkspaceNotificationRecipientUserCheckEntityExistsResponse = {
    body: boolean;
};

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

// @public
export type WorkspaceNotificationRecipientUserCreateOrUpdateResponse = RecipientUserContract;

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

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

// @public
export type WorkspaceNotificationRecipientUserListByNotificationResponse = RecipientUserCollection;

// @public
export interface WorkspacePolicy {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, policyId: PolicyIdName, parameters: PolicyContract, options?: WorkspacePolicyCreateOrUpdateOptionalParams): Promise<WorkspacePolicyCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, policyId: PolicyIdName, ifMatch: string, options?: WorkspacePolicyDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, policyId: PolicyIdName, options?: WorkspacePolicyGetOptionalParams): Promise<WorkspacePolicyGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, policyId: PolicyIdName, options?: WorkspacePolicyGetEntityTagOptionalParams): Promise<WorkspacePolicyGetEntityTagResponse>;
    listByApi(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspacePolicyListByApiOptionalParams): PagedAsyncIterableIterator<PolicyContract>;
}

// @public
export interface WorkspacePolicyCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspacePolicyCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspacePolicyCreateOrUpdateResponse = WorkspacePolicyCreateOrUpdateHeaders & PolicyContract;

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

// @public
export interface WorkspacePolicyFragment {
    beginCreateOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, id: string, parameters: PolicyFragmentContract, options?: WorkspacePolicyFragmentCreateOrUpdateOptionalParams): Promise<SimplePollerLike<OperationState<WorkspacePolicyFragmentCreateOrUpdateResponse>, WorkspacePolicyFragmentCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, serviceName: string, workspaceId: string, id: string, parameters: PolicyFragmentContract, options?: WorkspacePolicyFragmentCreateOrUpdateOptionalParams): Promise<WorkspacePolicyFragmentCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, id: string, ifMatch: string, options?: WorkspacePolicyFragmentDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, id: string, options?: WorkspacePolicyFragmentGetOptionalParams): Promise<WorkspacePolicyFragmentGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, id: string, options?: WorkspacePolicyFragmentGetEntityTagOptionalParams): Promise<WorkspacePolicyFragmentGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspacePolicyFragmentListByServiceOptionalParams): PagedAsyncIterableIterator<PolicyFragmentContract>;
    listReferences(resourceGroupName: string, serviceName: string, workspaceId: string, id: string, options?: WorkspacePolicyFragmentListReferencesOptionalParams): Promise<WorkspacePolicyFragmentListReferencesResponse>;
}

// @public
export interface WorkspacePolicyFragmentCreateOrUpdateHeaders {
    azureAsyncOperation?: string;
    eTag?: string;
    location?: string;
}

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

// @public
export type WorkspacePolicyFragmentCreateOrUpdateResponse = WorkspacePolicyFragmentCreateOrUpdateHeaders & PolicyFragmentContract;

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

// @public
export interface WorkspacePolicyFragmentGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspacePolicyFragmentGetEntityTagResponse = WorkspacePolicyFragmentGetEntityTagHeaders;

// @public
export interface WorkspacePolicyFragmentGetHeaders {
    eTag?: string;
}

// @public
export interface WorkspacePolicyFragmentGetOptionalParams extends coreClient.OperationOptions {
    format?: PolicyFragmentContentFormat;
}

// @public
export type WorkspacePolicyFragmentGetResponse = WorkspacePolicyFragmentGetHeaders & PolicyFragmentContract;

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

// @public
export type WorkspacePolicyFragmentListByServiceNextResponse = PolicyFragmentCollection;

// @public
export interface WorkspacePolicyFragmentListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    orderby?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspacePolicyFragmentListByServiceResponse = PolicyFragmentCollection;

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

// @public
export type WorkspacePolicyFragmentListReferencesResponse = ResourceCollection;

// @public
export interface WorkspacePolicyGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspacePolicyGetEntityTagResponse = WorkspacePolicyGetEntityTagHeaders;

// @public
export interface WorkspacePolicyGetHeaders {
    eTag?: string;
}

// @public
export interface WorkspacePolicyGetOptionalParams extends coreClient.OperationOptions {
    format?: PolicyExportFormat;
}

// @public
export type WorkspacePolicyGetResponse = WorkspacePolicyGetHeaders & PolicyContract;

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

// @public
export type WorkspacePolicyListByApiNextResponse = PolicyCollection;

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

// @public
export type WorkspacePolicyListByApiResponse = PolicyCollection;

// @public
export interface WorkspaceProduct {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, parameters: ProductContract, options?: WorkspaceProductCreateOrUpdateOptionalParams): Promise<WorkspaceProductCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, ifMatch: string, options?: WorkspaceProductDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, options?: WorkspaceProductGetOptionalParams): Promise<WorkspaceProductGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, options?: WorkspaceProductGetEntityTagOptionalParams): Promise<WorkspaceProductGetEntityTagResponse>;
    listByService(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceProductListByServiceOptionalParams): PagedAsyncIterableIterator<ProductContract>;
    update(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, ifMatch: string, parameters: ProductUpdateParameters, options?: WorkspaceProductUpdateOptionalParams): Promise<WorkspaceProductUpdateResponse>;
}

// @public
export interface WorkspaceProductApiLink {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, apiLinkId: string, parameters: ProductApiLinkContract, options?: WorkspaceProductApiLinkCreateOrUpdateOptionalParams): Promise<WorkspaceProductApiLinkCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, apiLinkId: string, options?: WorkspaceProductApiLinkDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, apiLinkId: string, options?: WorkspaceProductApiLinkGetOptionalParams): Promise<WorkspaceProductApiLinkGetResponse>;
    listByProduct(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, options?: WorkspaceProductApiLinkListByProductOptionalParams): PagedAsyncIterableIterator<ProductApiLinkContract>;
}

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

// @public
export type WorkspaceProductApiLinkCreateOrUpdateResponse = ProductApiLinkContract;

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

// @public
export interface WorkspaceProductApiLinkGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceProductApiLinkGetResponse = WorkspaceProductApiLinkGetHeaders & ProductApiLinkContract;

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

// @public
export type WorkspaceProductApiLinkListByProductNextResponse = ProductApiLinkCollection;

// @public
export interface WorkspaceProductApiLinkListByProductOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceProductApiLinkListByProductResponse = ProductApiLinkCollection;

// @public
export interface WorkspaceProductCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceProductCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceProductCreateOrUpdateResponse = WorkspaceProductCreateOrUpdateHeaders & ProductContract;

// @public
export interface WorkspaceProductDeleteOptionalParams extends coreClient.OperationOptions {
    deleteSubscriptions?: boolean;
}

// @public
export interface WorkspaceProductGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceProductGetEntityTagResponse = WorkspaceProductGetEntityTagHeaders;

// @public
export interface WorkspaceProductGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceProductGetResponse = WorkspaceProductGetHeaders & ProductContract;

// @public
export interface WorkspaceProductGroupLink {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, groupLinkId: string, parameters: ProductGroupLinkContract, options?: WorkspaceProductGroupLinkCreateOrUpdateOptionalParams): Promise<WorkspaceProductGroupLinkCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, groupLinkId: string, options?: WorkspaceProductGroupLinkDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, groupLinkId: string, options?: WorkspaceProductGroupLinkGetOptionalParams): Promise<WorkspaceProductGroupLinkGetResponse>;
    listByProduct(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, options?: WorkspaceProductGroupLinkListByProductOptionalParams): PagedAsyncIterableIterator<ProductGroupLinkContract>;
}

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

// @public
export type WorkspaceProductGroupLinkCreateOrUpdateResponse = ProductGroupLinkContract;

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

// @public
export interface WorkspaceProductGroupLinkGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceProductGroupLinkGetResponse = WorkspaceProductGroupLinkGetHeaders & ProductGroupLinkContract;

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

// @public
export type WorkspaceProductGroupLinkListByProductNextResponse = ProductGroupLinkCollection;

// @public
export interface WorkspaceProductGroupLinkListByProductOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceProductGroupLinkListByProductResponse = ProductGroupLinkCollection;

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

// @public
export type WorkspaceProductListByServiceNextResponse = ProductCollection;

// @public
export interface WorkspaceProductListByServiceOptionalParams extends coreClient.OperationOptions {
    expandGroups?: boolean;
    filter?: string;
    skip?: number;
    tags?: string;
    top?: number;
}

// @public
export type WorkspaceProductListByServiceResponse = ProductCollection;

// @public
export interface WorkspaceProductPolicy {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, policyId: PolicyIdName, parameters: PolicyContract, options?: WorkspaceProductPolicyCreateOrUpdateOptionalParams): Promise<WorkspaceProductPolicyCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, policyId: PolicyIdName, ifMatch: string, options?: WorkspaceProductPolicyDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, policyId: PolicyIdName, options?: WorkspaceProductPolicyGetOptionalParams): Promise<WorkspaceProductPolicyGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, policyId: PolicyIdName, options?: WorkspaceProductPolicyGetEntityTagOptionalParams): Promise<WorkspaceProductPolicyGetEntityTagResponse>;
    listByProduct(resourceGroupName: string, serviceName: string, workspaceId: string, productId: string, options?: WorkspaceProductPolicyListByProductOptionalParams): Promise<WorkspaceProductPolicyListByProductResponse>;
}

// @public
export interface WorkspaceProductPolicyCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceProductPolicyCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceProductPolicyCreateOrUpdateResponse = WorkspaceProductPolicyCreateOrUpdateHeaders & PolicyContract;

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

// @public
export interface WorkspaceProductPolicyGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceProductPolicyGetEntityTagResponse = WorkspaceProductPolicyGetEntityTagHeaders;

// @public
export interface WorkspaceProductPolicyGetHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceProductPolicyGetOptionalParams extends coreClient.OperationOptions {
    format?: PolicyExportFormat;
}

// @public
export type WorkspaceProductPolicyGetResponse = WorkspaceProductPolicyGetHeaders & PolicyContract;

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

// @public
export type WorkspaceProductPolicyListByProductResponse = PolicyCollection;

// @public
export interface WorkspaceProductUpdateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceProductUpdateResponse = WorkspaceProductUpdateHeaders & ProductContract;

// @public
export interface WorkspaceSubscription {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, sid: string, parameters: SubscriptionCreateParameters, options?: WorkspaceSubscriptionCreateOrUpdateOptionalParams): Promise<WorkspaceSubscriptionCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, sid: string, ifMatch: string, options?: WorkspaceSubscriptionDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, sid: string, options?: WorkspaceSubscriptionGetOptionalParams): Promise<WorkspaceSubscriptionGetResponse>;
    getEntityTag(resourceGroupName: string, serviceName: string, workspaceId: string, sid: string, options?: WorkspaceSubscriptionGetEntityTagOptionalParams): Promise<WorkspaceSubscriptionGetEntityTagResponse>;
    list(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceSubscriptionListOptionalParams): PagedAsyncIterableIterator<SubscriptionContract>;
    listSecrets(resourceGroupName: string, serviceName: string, workspaceId: string, sid: string, options?: WorkspaceSubscriptionListSecretsOptionalParams): Promise<WorkspaceSubscriptionListSecretsResponse>;
    regeneratePrimaryKey(resourceGroupName: string, serviceName: string, workspaceId: string, sid: string, options?: WorkspaceSubscriptionRegeneratePrimaryKeyOptionalParams): Promise<void>;
    regenerateSecondaryKey(resourceGroupName: string, serviceName: string, workspaceId: string, sid: string, options?: WorkspaceSubscriptionRegenerateSecondaryKeyOptionalParams): Promise<void>;
    update(resourceGroupName: string, serviceName: string, workspaceId: string, sid: string, ifMatch: string, parameters: SubscriptionUpdateParameters, options?: WorkspaceSubscriptionUpdateOptionalParams): Promise<WorkspaceSubscriptionUpdateResponse>;
}

// @public
export interface WorkspaceSubscriptionCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceSubscriptionCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    appType?: AppType;
    ifMatch?: string;
    notify?: boolean;
}

// @public
export type WorkspaceSubscriptionCreateOrUpdateResponse = WorkspaceSubscriptionCreateOrUpdateHeaders & SubscriptionContract;

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

// @public
export interface WorkspaceSubscriptionGetEntityTagHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceSubscriptionGetEntityTagResponse = WorkspaceSubscriptionGetEntityTagHeaders;

// @public
export interface WorkspaceSubscriptionGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceSubscriptionGetResponse = WorkspaceSubscriptionGetHeaders & SubscriptionContract;

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

// @public
export type WorkspaceSubscriptionListNextResponse = SubscriptionCollection;

// @public
export interface WorkspaceSubscriptionListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceSubscriptionListResponse = SubscriptionCollection;

// @public
export interface WorkspaceSubscriptionListSecretsHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceSubscriptionListSecretsResponse = WorkspaceSubscriptionListSecretsHeaders & SubscriptionKeysContract;

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

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

// @public
export interface WorkspaceSubscriptionUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceSubscriptionUpdateOptionalParams extends coreClient.OperationOptions {
    appType?: AppType;
    notify?: boolean;
}

// @public
export type WorkspaceSubscriptionUpdateResponse = WorkspaceSubscriptionUpdateHeaders & SubscriptionContract;

// @public
export interface WorkspaceTag {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, parameters: TagCreateUpdateParameters, options?: WorkspaceTagCreateOrUpdateOptionalParams): Promise<WorkspaceTagCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, ifMatch: string, options?: WorkspaceTagDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, options?: WorkspaceTagGetOptionalParams): Promise<WorkspaceTagGetResponse>;
    getEntityState(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, options?: WorkspaceTagGetEntityStateOptionalParams): Promise<WorkspaceTagGetEntityStateResponse>;
    listByService(resourceGroupName: string, serviceName: string, workspaceId: string, options?: WorkspaceTagListByServiceOptionalParams): PagedAsyncIterableIterator<TagContract>;
    update(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, ifMatch: string, parameters: TagCreateUpdateParameters, options?: WorkspaceTagUpdateOptionalParams): Promise<WorkspaceTagUpdateResponse>;
}

// @public
export interface WorkspaceTagApiLink {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, apiLinkId: string, parameters: TagApiLinkContract, options?: WorkspaceTagApiLinkCreateOrUpdateOptionalParams): Promise<WorkspaceTagApiLinkCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, apiLinkId: string, options?: WorkspaceTagApiLinkDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, apiLinkId: string, options?: WorkspaceTagApiLinkGetOptionalParams): Promise<WorkspaceTagApiLinkGetResponse>;
    listByProduct(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, options?: WorkspaceTagApiLinkListByProductOptionalParams): PagedAsyncIterableIterator<TagApiLinkContract>;
}

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

// @public
export type WorkspaceTagApiLinkCreateOrUpdateResponse = TagApiLinkContract;

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

// @public
export interface WorkspaceTagApiLinkGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceTagApiLinkGetResponse = WorkspaceTagApiLinkGetHeaders & TagApiLinkContract;

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

// @public
export type WorkspaceTagApiLinkListByProductNextResponse = TagApiLinkCollection;

// @public
export interface WorkspaceTagApiLinkListByProductOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceTagApiLinkListByProductResponse = TagApiLinkCollection;

// @public
export interface WorkspaceTagCreateOrUpdateHeaders {
    eTag?: string;
}

// @public
export interface WorkspaceTagCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    ifMatch?: string;
}

// @public
export type WorkspaceTagCreateOrUpdateResponse = WorkspaceTagCreateOrUpdateHeaders & TagContract;

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

// @public
export interface WorkspaceTagGetEntityStateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceTagGetEntityStateResponse = WorkspaceTagGetEntityStateHeaders;

// @public
export interface WorkspaceTagGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceTagGetResponse = WorkspaceTagGetHeaders & TagContract;

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

// @public
export type WorkspaceTagListByServiceNextResponse = TagCollection;

// @public
export interface WorkspaceTagListByServiceOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    scope?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceTagListByServiceResponse = TagCollection;

// @public
export interface WorkspaceTagOperationLink {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, operationLinkId: string, parameters: TagOperationLinkContract, options?: WorkspaceTagOperationLinkCreateOrUpdateOptionalParams): Promise<WorkspaceTagOperationLinkCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, operationLinkId: string, options?: WorkspaceTagOperationLinkDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, operationLinkId: string, options?: WorkspaceTagOperationLinkGetOptionalParams): Promise<WorkspaceTagOperationLinkGetResponse>;
    listByProduct(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, options?: WorkspaceTagOperationLinkListByProductOptionalParams): PagedAsyncIterableIterator<TagOperationLinkContract>;
}

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

// @public
export type WorkspaceTagOperationLinkCreateOrUpdateResponse = TagOperationLinkContract;

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

// @public
export interface WorkspaceTagOperationLinkGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceTagOperationLinkGetResponse = WorkspaceTagOperationLinkGetHeaders & TagOperationLinkContract;

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

// @public
export type WorkspaceTagOperationLinkListByProductNextResponse = TagOperationLinkCollection;

// @public
export interface WorkspaceTagOperationLinkListByProductOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceTagOperationLinkListByProductResponse = TagOperationLinkCollection;

// @public
export interface WorkspaceTagProductLink {
    createOrUpdate(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, productLinkId: string, parameters: TagProductLinkContract, options?: WorkspaceTagProductLinkCreateOrUpdateOptionalParams): Promise<WorkspaceTagProductLinkCreateOrUpdateResponse>;
    delete(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, productLinkId: string, options?: WorkspaceTagProductLinkDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, productLinkId: string, options?: WorkspaceTagProductLinkGetOptionalParams): Promise<WorkspaceTagProductLinkGetResponse>;
    listByProduct(resourceGroupName: string, serviceName: string, workspaceId: string, tagId: string, options?: WorkspaceTagProductLinkListByProductOptionalParams): PagedAsyncIterableIterator<TagProductLinkContract>;
}

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

// @public
export type WorkspaceTagProductLinkCreateOrUpdateResponse = TagProductLinkContract;

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

// @public
export interface WorkspaceTagProductLinkGetHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceTagProductLinkGetResponse = WorkspaceTagProductLinkGetHeaders & TagProductLinkContract;

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

// @public
export type WorkspaceTagProductLinkListByProductNextResponse = TagProductLinkCollection;

// @public
export interface WorkspaceTagProductLinkListByProductOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    skip?: number;
    top?: number;
}

// @public
export type WorkspaceTagProductLinkListByProductResponse = TagProductLinkCollection;

// @public
export interface WorkspaceTagUpdateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceTagUpdateResponse = WorkspaceTagUpdateHeaders & TagContract;

// @public
export interface WorkspaceUpdateHeaders {
    eTag?: string;
}

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

// @public
export type WorkspaceUpdateResponse = WorkspaceUpdateHeaders & WorkspaceContract;

// @public
export interface X509CertificateName {
    issuerCertificateThumbprint?: string;
    name?: string;
}

// (No @packageDocumentation comment for this package)

```
