apimanagement

package
v61.5.0+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 14, 2022 License: MIT Imports: 2 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	DefaultBaseURI = original.DefaultBaseURI
)

Variables

This section is empty.

Functions

func UserAgent 

func UserAgent() string

func Version 

func Version() string

Types

type APIClient 

type APIClient = original.APIClient

func NewAPIClient 

func NewAPIClient(subscriptionID string) APIClient

func NewAPIClientWithBaseURI 

func NewAPIClientWithBaseURI(baseURI string, subscriptionID string) APIClient

type APICollection 

type APICollection = original.APICollection

type APICollectionIterator 

type APICollectionIterator = original.APICollectionIterator

func NewAPICollectionIterator 

func NewAPICollectionIterator(page APICollectionPage) APICollectionIterator

type APICollectionPage 

type APICollectionPage = original.APICollectionPage

func NewAPICollectionPage 

func NewAPICollectionPage(cur APICollection, getNextPage func(context.Context, APICollection) (APICollection, error)) APICollectionPage

type APIContactInformation 

type APIContactInformation = original.APIContactInformation

type APIContract 

type APIContract = original.APIContract

type APIContractProperties 

type APIContractProperties = original.APIContractProperties

type APIContractUpdateProperties 

type APIContractUpdateProperties = original.APIContractUpdateProperties

type APICreateOrUpdateFuture 

type APICreateOrUpdateFuture = original.APICreateOrUpdateFuture

type APICreateOrUpdateParameter 

type APICreateOrUpdateParameter = original.APICreateOrUpdateParameter

type APICreateOrUpdateProperties 

type APICreateOrUpdateProperties = original.APICreateOrUpdateProperties

type APICreateOrUpdatePropertiesWsdlSelector 

type APICreateOrUpdatePropertiesWsdlSelector = original.APICreateOrUpdatePropertiesWsdlSelector

type APIDiagnosticClient 

type APIDiagnosticClient = original.APIDiagnosticClient

func NewAPIDiagnosticClient 

func NewAPIDiagnosticClient(subscriptionID string) APIDiagnosticClient

func NewAPIDiagnosticClientWithBaseURI 

func NewAPIDiagnosticClientWithBaseURI(baseURI string, subscriptionID string) APIDiagnosticClient

type APIEntityBaseContract 

type APIEntityBaseContract = original.APIEntityBaseContract

type APIExportClient 

type APIExportClient = original.APIExportClient

func NewAPIExportClient 

func NewAPIExportClient(subscriptionID string) APIExportClient

func NewAPIExportClientWithBaseURI 

func NewAPIExportClientWithBaseURI(baseURI string, subscriptionID string) APIExportClient

type APIExportResult 

type APIExportResult = original.APIExportResult

type APIExportResultValue 

type APIExportResultValue = original.APIExportResultValue

type APIIssueAttachmentClient 

type APIIssueAttachmentClient = original.APIIssueAttachmentClient

func NewAPIIssueAttachmentClient 

func NewAPIIssueAttachmentClient(subscriptionID string) APIIssueAttachmentClient

func NewAPIIssueAttachmentClientWithBaseURI 

func NewAPIIssueAttachmentClientWithBaseURI(baseURI string, subscriptionID string) APIIssueAttachmentClient

type APIIssueClient 

type APIIssueClient = original.APIIssueClient

func NewAPIIssueClient 

func NewAPIIssueClient(subscriptionID string) APIIssueClient

func NewAPIIssueClientWithBaseURI 

func NewAPIIssueClientWithBaseURI(baseURI string, subscriptionID string) APIIssueClient

type APIIssueCommentClient 

type APIIssueCommentClient = original.APIIssueCommentClient

func NewAPIIssueCommentClient 

func NewAPIIssueCommentClient(subscriptionID string) APIIssueCommentClient

func NewAPIIssueCommentClientWithBaseURI 

func NewAPIIssueCommentClientWithBaseURI(baseURI string, subscriptionID string) APIIssueCommentClient

type APILicenseInformation 

type APILicenseInformation = original.APILicenseInformation

type APIOperationClient 

type APIOperationClient = original.APIOperationClient

func NewAPIOperationClient 

func NewAPIOperationClient(subscriptionID string) APIOperationClient

func NewAPIOperationClientWithBaseURI 

func NewAPIOperationClientWithBaseURI(baseURI string, subscriptionID string) APIOperationClient

type APIOperationPolicyClient 

type APIOperationPolicyClient = original.APIOperationPolicyClient

func NewAPIOperationPolicyClient 

func NewAPIOperationPolicyClient(subscriptionID string) APIOperationPolicyClient

func NewAPIOperationPolicyClientWithBaseURI 

func NewAPIOperationPolicyClientWithBaseURI(baseURI string, subscriptionID string) APIOperationPolicyClient

type APIPolicyClient 

type APIPolicyClient = original.APIPolicyClient

func NewAPIPolicyClient 

func NewAPIPolicyClient(subscriptionID string) APIPolicyClient

func NewAPIPolicyClientWithBaseURI 

func NewAPIPolicyClientWithBaseURI(baseURI string, subscriptionID string) APIPolicyClient

type APIProductClient 

type APIProductClient = original.APIProductClient

func NewAPIProductClient 

func NewAPIProductClient(subscriptionID string) APIProductClient

func NewAPIProductClientWithBaseURI 

func NewAPIProductClientWithBaseURI(baseURI string, subscriptionID string) APIProductClient

type APIReleaseClient 

type APIReleaseClient = original.APIReleaseClient

func NewAPIReleaseClient 

func NewAPIReleaseClient(subscriptionID string) APIReleaseClient

func NewAPIReleaseClientWithBaseURI 

func NewAPIReleaseClientWithBaseURI(baseURI string, subscriptionID string) APIReleaseClient

type APIReleaseCollection 

type APIReleaseCollection = original.APIReleaseCollection

type APIReleaseCollectionIterator 

type APIReleaseCollectionIterator = original.APIReleaseCollectionIterator

func NewAPIReleaseCollectionIterator 

func NewAPIReleaseCollectionIterator(page APIReleaseCollectionPage) APIReleaseCollectionIterator

type APIReleaseCollectionPage 

type APIReleaseCollectionPage = original.APIReleaseCollectionPage

func NewAPIReleaseCollectionPage 

func NewAPIReleaseCollectionPage(cur APIReleaseCollection, getNextPage func(context.Context, APIReleaseCollection) (APIReleaseCollection, error)) APIReleaseCollectionPage

type APIReleaseContract 

type APIReleaseContract = original.APIReleaseContract

type APIReleaseContractProperties 

type APIReleaseContractProperties = original.APIReleaseContractProperties

type APIRevisionClient 

type APIRevisionClient = original.APIRevisionClient

func NewAPIRevisionClient 

func NewAPIRevisionClient(subscriptionID string) APIRevisionClient

func NewAPIRevisionClientWithBaseURI 

func NewAPIRevisionClientWithBaseURI(baseURI string, subscriptionID string) APIRevisionClient

type APIRevisionCollection 

type APIRevisionCollection = original.APIRevisionCollection

type APIRevisionCollectionIterator 

type APIRevisionCollectionIterator = original.APIRevisionCollectionIterator

func NewAPIRevisionCollectionIterator 

func NewAPIRevisionCollectionIterator(page APIRevisionCollectionPage) APIRevisionCollectionIterator

type APIRevisionCollectionPage 

type APIRevisionCollectionPage = original.APIRevisionCollectionPage

func NewAPIRevisionCollectionPage 

func NewAPIRevisionCollectionPage(cur APIRevisionCollection, getNextPage func(context.Context, APIRevisionCollection) (APIRevisionCollection, error)) APIRevisionCollectionPage

type APIRevisionContract 

type APIRevisionContract = original.APIRevisionContract

type APIRevisionInfoContract 

type APIRevisionInfoContract = original.APIRevisionInfoContract

type APISchemaClient 

type APISchemaClient = original.APISchemaClient

func NewAPISchemaClient 

func NewAPISchemaClient(subscriptionID string) APISchemaClient

func NewAPISchemaClientWithBaseURI 

func NewAPISchemaClientWithBaseURI(baseURI string, subscriptionID string) APISchemaClient

type APISchemaCreateOrUpdateFuture 

type APISchemaCreateOrUpdateFuture = original.APISchemaCreateOrUpdateFuture

type APITagDescriptionClient 

type APITagDescriptionClient = original.APITagDescriptionClient

func NewAPITagDescriptionClient 

func NewAPITagDescriptionClient(subscriptionID string) APITagDescriptionClient

func NewAPITagDescriptionClientWithBaseURI 

func NewAPITagDescriptionClientWithBaseURI(baseURI string, subscriptionID string) APITagDescriptionClient

type APITagResourceContractProperties 

type APITagResourceContractProperties = original.APITagResourceContractProperties

type APIType 

type APIType = original.APIType
const (
	APITypeGraphql   APIType = original.APITypeGraphql
	APITypeHTTP      APIType = original.APITypeHTTP
	APITypeSoap      APIType = original.APITypeSoap
	APITypeWebsocket APIType = original.APITypeWebsocket
)

func PossibleAPITypeValues 

func PossibleAPITypeValues() []APIType

type APIUpdateContract 

type APIUpdateContract = original.APIUpdateContract

type APIVersionConstraint 

type APIVersionConstraint = original.APIVersionConstraint

type APIVersionSetClient 

type APIVersionSetClient = original.APIVersionSetClient

func NewAPIVersionSetClient 

func NewAPIVersionSetClient(subscriptionID string) APIVersionSetClient

func NewAPIVersionSetClientWithBaseURI 

func NewAPIVersionSetClientWithBaseURI(baseURI string, subscriptionID string) APIVersionSetClient

type APIVersionSetCollection 

type APIVersionSetCollection = original.APIVersionSetCollection

type APIVersionSetCollectionIterator 

type APIVersionSetCollectionIterator = original.APIVersionSetCollectionIterator

func NewAPIVersionSetCollectionIterator 

func NewAPIVersionSetCollectionIterator(page APIVersionSetCollectionPage) APIVersionSetCollectionIterator

type APIVersionSetCollectionPage 

type APIVersionSetCollectionPage = original.APIVersionSetCollectionPage

func NewAPIVersionSetCollectionPage 

func NewAPIVersionSetCollectionPage(cur APIVersionSetCollection, getNextPage func(context.Context, APIVersionSetCollection) (APIVersionSetCollection, error)) APIVersionSetCollectionPage

type APIVersionSetContract 

type APIVersionSetContract = original.APIVersionSetContract

type APIVersionSetContractDetails 

type APIVersionSetContractDetails = original.APIVersionSetContractDetails

type APIVersionSetContractProperties 

type APIVersionSetContractProperties = original.APIVersionSetContractProperties

type APIVersionSetEntityBase 

type APIVersionSetEntityBase = original.APIVersionSetEntityBase

type APIVersionSetUpdateParameters 

type APIVersionSetUpdateParameters = original.APIVersionSetUpdateParameters

type APIVersionSetUpdateParametersProperties 

type APIVersionSetUpdateParametersProperties = original.APIVersionSetUpdateParametersProperties

type AccessIDName 

type AccessIDName = original.AccessIDName
const (
	AccessIDNameAccess    AccessIDName = original.AccessIDNameAccess
	AccessIDNameGitAccess AccessIDName = original.AccessIDNameGitAccess
)

func PossibleAccessIDNameValues 

func PossibleAccessIDNameValues() []AccessIDName

type AccessInformationCollection 

type AccessInformationCollection = original.AccessInformationCollection

type AccessInformationCollectionIterator 

type AccessInformationCollectionIterator = original.AccessInformationCollectionIterator

func NewAccessInformationCollectionIterator 

func NewAccessInformationCollectionIterator(page AccessInformationCollectionPage) AccessInformationCollectionIterator

type AccessInformationCollectionPage 

type AccessInformationCollectionPage = original.AccessInformationCollectionPage

func NewAccessInformationCollectionPage 

func NewAccessInformationCollectionPage(cur AccessInformationCollection, getNextPage func(context.Context, AccessInformationCollection) (AccessInformationCollection, error)) AccessInformationCollectionPage

type AccessInformationContract 

type AccessInformationContract = original.AccessInformationContract

type AccessInformationContractProperties 

type AccessInformationContractProperties = original.AccessInformationContractProperties

type AccessInformationCreateParameterProperties 

type AccessInformationCreateParameterProperties = original.AccessInformationCreateParameterProperties

type AccessInformationCreateParameters 

type AccessInformationCreateParameters = original.AccessInformationCreateParameters

type AccessInformationSecretsContract 

type AccessInformationSecretsContract = original.AccessInformationSecretsContract

type AccessInformationUpdateParameterProperties 

type AccessInformationUpdateParameterProperties = original.AccessInformationUpdateParameterProperties

type AccessInformationUpdateParameters 

type AccessInformationUpdateParameters = original.AccessInformationUpdateParameters

type AccessType 

type AccessType = original.AccessType
const (
	AccessTypeAccessKey                     AccessType = original.AccessTypeAccessKey
	AccessTypeSystemAssignedManagedIdentity AccessType = original.AccessTypeSystemAssignedManagedIdentity
	AccessTypeUserAssignedManagedIdentity   AccessType = original.AccessTypeUserAssignedManagedIdentity
)

func PossibleAccessTypeValues 

func PossibleAccessTypeValues() []AccessType

type AdditionalLocation 

type AdditionalLocation = original.AdditionalLocation

type AlwaysLog 

type AlwaysLog = original.AlwaysLog
const (
	AlwaysLogAllErrors AlwaysLog = original.AlwaysLogAllErrors
)

func PossibleAlwaysLogValues 

func PossibleAlwaysLogValues() []AlwaysLog

type ApimIdentityType 

type ApimIdentityType = original.ApimIdentityType
const (
	ApimIdentityTypeNone                       ApimIdentityType = original.ApimIdentityTypeNone
	ApimIdentityTypeSystemAssigned             ApimIdentityType = original.ApimIdentityTypeSystemAssigned
	ApimIdentityTypeSystemAssignedUserAssigned ApimIdentityType = original.ApimIdentityTypeSystemAssignedUserAssigned
	ApimIdentityTypeUserAssigned               ApimIdentityType = original.ApimIdentityTypeUserAssigned
)

func PossibleApimIdentityTypeValues 

func PossibleApimIdentityTypeValues() []ApimIdentityType

type ApimResource 

type ApimResource = original.ApimResource

type AppType 

type AppType = original.AppType
const (
	AppTypeDeveloperPortal AppType = original.AppTypeDeveloperPortal
	AppTypePortal          AppType = original.AppTypePortal
)

func PossibleAppTypeValues 

func PossibleAppTypeValues() []AppType

type ArmIDWrapper 

type ArmIDWrapper = original.ArmIDWrapper

type AssociationContract 

type AssociationContract = original.AssociationContract

type AssociationContractProperties 

type AssociationContractProperties = original.AssociationContractProperties

type AsyncOperationStatus 

type AsyncOperationStatus = original.AsyncOperationStatus
const (
	AsyncOperationStatusFailed     AsyncOperationStatus = original.AsyncOperationStatusFailed
	AsyncOperationStatusInProgress AsyncOperationStatus = original.AsyncOperationStatusInProgress
	AsyncOperationStatusStarted    AsyncOperationStatus = original.AsyncOperationStatusStarted
	AsyncOperationStatusSucceeded  AsyncOperationStatus = original.AsyncOperationStatusSucceeded
)

func PossibleAsyncOperationStatusValues 

func PossibleAsyncOperationStatusValues() []AsyncOperationStatus

type AuthenticationSettingsContract 

type AuthenticationSettingsContract = original.AuthenticationSettingsContract

type AuthorizationMethod 

type AuthorizationMethod = original.AuthorizationMethod
const (
	AuthorizationMethodDELETE  AuthorizationMethod = original.AuthorizationMethodDELETE
	AuthorizationMethodGET     AuthorizationMethod = original.AuthorizationMethodGET
	AuthorizationMethodHEAD    AuthorizationMethod = original.AuthorizationMethodHEAD
	AuthorizationMethodOPTIONS AuthorizationMethod = original.AuthorizationMethodOPTIONS
	AuthorizationMethodPATCH   AuthorizationMethod = original.AuthorizationMethodPATCH
	AuthorizationMethodPOST    AuthorizationMethod = original.AuthorizationMethodPOST
	AuthorizationMethodPUT     AuthorizationMethod = original.AuthorizationMethodPUT
	AuthorizationMethodTRACE   AuthorizationMethod = original.AuthorizationMethodTRACE
)

func PossibleAuthorizationMethodValues 

func PossibleAuthorizationMethodValues() []AuthorizationMethod

type AuthorizationServerClient 

type AuthorizationServerClient = original.AuthorizationServerClient

func NewAuthorizationServerClient 

func NewAuthorizationServerClient(subscriptionID string) AuthorizationServerClient

func NewAuthorizationServerClientWithBaseURI 

func NewAuthorizationServerClientWithBaseURI(baseURI string, subscriptionID string) AuthorizationServerClient

type AuthorizationServerCollection 

type AuthorizationServerCollection = original.AuthorizationServerCollection

type AuthorizationServerCollectionIterator 

type AuthorizationServerCollectionIterator = original.AuthorizationServerCollectionIterator

func NewAuthorizationServerCollectionIterator 

func NewAuthorizationServerCollectionIterator(page AuthorizationServerCollectionPage) AuthorizationServerCollectionIterator

type AuthorizationServerCollectionPage 

type AuthorizationServerCollectionPage = original.AuthorizationServerCollectionPage

func NewAuthorizationServerCollectionPage 

func NewAuthorizationServerCollectionPage(cur AuthorizationServerCollection, getNextPage func(context.Context, AuthorizationServerCollection) (AuthorizationServerCollection, error)) AuthorizationServerCollectionPage

type AuthorizationServerContract 

type AuthorizationServerContract = original.AuthorizationServerContract

type AuthorizationServerContractBaseProperties 

type AuthorizationServerContractBaseProperties = original.AuthorizationServerContractBaseProperties

type AuthorizationServerContractProperties 

type AuthorizationServerContractProperties = original.AuthorizationServerContractProperties

type AuthorizationServerSecretsContract 

type AuthorizationServerSecretsContract = original.AuthorizationServerSecretsContract

type AuthorizationServerUpdateContract 

type AuthorizationServerUpdateContract = original.AuthorizationServerUpdateContract

type AuthorizationServerUpdateContractProperties 

type AuthorizationServerUpdateContractProperties = original.AuthorizationServerUpdateContractProperties

type AzureEntityResource 

type AzureEntityResource = original.AzureEntityResource

type BackendAuthorizationHeaderCredentials 

type BackendAuthorizationHeaderCredentials = original.BackendAuthorizationHeaderCredentials

type BackendBaseParameters 

type BackendBaseParameters = original.BackendBaseParameters

type BackendClient 

type BackendClient = original.BackendClient

func NewBackendClient 

func NewBackendClient(subscriptionID string) BackendClient

func NewBackendClientWithBaseURI 

func NewBackendClientWithBaseURI(baseURI string, subscriptionID string) BackendClient

type BackendCollection 

type BackendCollection = original.BackendCollection

type BackendCollectionIterator 

type BackendCollectionIterator = original.BackendCollectionIterator

func NewBackendCollectionIterator 

func NewBackendCollectionIterator(page BackendCollectionPage) BackendCollectionIterator

type BackendCollectionPage 

type BackendCollectionPage = original.BackendCollectionPage

func NewBackendCollectionPage 

func NewBackendCollectionPage(cur BackendCollection, getNextPage func(context.Context, BackendCollection) (BackendCollection, error)) BackendCollectionPage

type BackendContract 

type BackendContract = original.BackendContract

type BackendContractProperties 

type BackendContractProperties = original.BackendContractProperties

type BackendCredentialsContract 

type BackendCredentialsContract = original.BackendCredentialsContract

type BackendProperties 

type BackendProperties = original.BackendProperties

type BackendProtocol 

type BackendProtocol = original.BackendProtocol
const (
	BackendProtocolHTTP BackendProtocol = original.BackendProtocolHTTP
	BackendProtocolSoap BackendProtocol = original.BackendProtocolSoap
)

func PossibleBackendProtocolValues 

func PossibleBackendProtocolValues() []BackendProtocol

type BackendProxyContract 

type BackendProxyContract = original.BackendProxyContract

type BackendReconnectContract 

type BackendReconnectContract = original.BackendReconnectContract

type BackendReconnectProperties 

type BackendReconnectProperties = original.BackendReconnectProperties

type BackendServiceFabricClusterProperties 

type BackendServiceFabricClusterProperties = original.BackendServiceFabricClusterProperties

type BackendTLSProperties 

type BackendTLSProperties = original.BackendTLSProperties

type BackendUpdateParameterProperties 

type BackendUpdateParameterProperties = original.BackendUpdateParameterProperties

type BackendUpdateParameters 

type BackendUpdateParameters = original.BackendUpdateParameters

type BaseClient 

type BaseClient = original.BaseClient

func New 

func New(subscriptionID string) BaseClient

func NewWithBaseURI 

func NewWithBaseURI(baseURI string, subscriptionID string) BaseClient

type BearerTokenSendingMethod 

type BearerTokenSendingMethod = original.BearerTokenSendingMethod
const (
	BearerTokenSendingMethodAuthorizationHeader BearerTokenSendingMethod = original.BearerTokenSendingMethodAuthorizationHeader
	BearerTokenSendingMethodQuery               BearerTokenSendingMethod = original.BearerTokenSendingMethodQuery
)

func PossibleBearerTokenSendingMethodValues 

func PossibleBearerTokenSendingMethodValues() []BearerTokenSendingMethod

type BearerTokenSendingMethods 

type BearerTokenSendingMethods = original.BearerTokenSendingMethods
const (
	BearerTokenSendingMethodsAuthorizationHeader BearerTokenSendingMethods = original.BearerTokenSendingMethodsAuthorizationHeader
	BearerTokenSendingMethodsQuery               BearerTokenSendingMethods = original.BearerTokenSendingMethodsQuery
)

func PossibleBearerTokenSendingMethodsValues 

func PossibleBearerTokenSendingMethodsValues() []BearerTokenSendingMethods

type BodyDiagnosticSettings 

type BodyDiagnosticSettings = original.BodyDiagnosticSettings

type CacheClient 

type CacheClient = original.CacheClient

func NewCacheClient 

func NewCacheClient(subscriptionID string) CacheClient

func NewCacheClientWithBaseURI 

func NewCacheClientWithBaseURI(baseURI string, subscriptionID string) CacheClient

type CacheCollection 

type CacheCollection = original.CacheCollection

type CacheCollectionIterator 

type CacheCollectionIterator = original.CacheCollectionIterator

func NewCacheCollectionIterator 

func NewCacheCollectionIterator(page CacheCollectionPage) CacheCollectionIterator

type CacheCollectionPage 

type CacheCollectionPage = original.CacheCollectionPage

func NewCacheCollectionPage 

func NewCacheCollectionPage(cur CacheCollection, getNextPage func(context.Context, CacheCollection) (CacheCollection, error)) CacheCollectionPage

type CacheContract 

type CacheContract = original.CacheContract

type CacheContractProperties 

type CacheContractProperties = original.CacheContractProperties

type CacheUpdateParameters 

type CacheUpdateParameters = original.CacheUpdateParameters

type CacheUpdateProperties 

type CacheUpdateProperties = original.CacheUpdateProperties

type CertificateClient 

type CertificateClient = original.CertificateClient

func NewCertificateClient 

func NewCertificateClient(subscriptionID string) CertificateClient

func NewCertificateClientWithBaseURI 

func NewCertificateClientWithBaseURI(baseURI string, subscriptionID string) CertificateClient

type CertificateCollection 

type CertificateCollection = original.CertificateCollection

type CertificateCollectionIterator 

type CertificateCollectionIterator = original.CertificateCollectionIterator

func NewCertificateCollectionIterator 

func NewCertificateCollectionIterator(page CertificateCollectionPage) CertificateCollectionIterator

type CertificateCollectionPage 

type CertificateCollectionPage = original.CertificateCollectionPage

func NewCertificateCollectionPage 

func NewCertificateCollectionPage(cur CertificateCollection, getNextPage func(context.Context, CertificateCollection) (CertificateCollection, error)) CertificateCollectionPage

type CertificateConfiguration 

type CertificateConfiguration = original.CertificateConfiguration

type CertificateContract 

type CertificateContract = original.CertificateContract

type CertificateContractProperties 

type CertificateContractProperties = original.CertificateContractProperties

type CertificateCreateOrUpdateParameters 

type CertificateCreateOrUpdateParameters = original.CertificateCreateOrUpdateParameters

type CertificateCreateOrUpdateProperties 

type CertificateCreateOrUpdateProperties = original.CertificateCreateOrUpdateProperties

type CertificateInformation 

type CertificateInformation = original.CertificateInformation

type CertificateSource 

type CertificateSource = original.CertificateSource
const (
	CertificateSourceBuiltIn  CertificateSource = original.CertificateSourceBuiltIn
	CertificateSourceCustom   CertificateSource = original.CertificateSourceCustom
	CertificateSourceKeyVault CertificateSource = original.CertificateSourceKeyVault
	CertificateSourceManaged  CertificateSource = original.CertificateSourceManaged
)

func PossibleCertificateSourceValues 

func PossibleCertificateSourceValues() []CertificateSource

type CertificateStatus 

type CertificateStatus = original.CertificateStatus
const (
	CertificateStatusCompleted  CertificateStatus = original.CertificateStatusCompleted
	CertificateStatusFailed     CertificateStatus = original.CertificateStatusFailed
	CertificateStatusInProgress CertificateStatus = original.CertificateStatusInProgress
)

func PossibleCertificateStatusValues 

func PossibleCertificateStatusValues() []CertificateStatus

type ClientAuthenticationMethod 

type ClientAuthenticationMethod = original.ClientAuthenticationMethod
const (
	ClientAuthenticationMethodBasic ClientAuthenticationMethod = original.ClientAuthenticationMethodBasic
	ClientAuthenticationMethodBody  ClientAuthenticationMethod = original.ClientAuthenticationMethodBody
)

func PossibleClientAuthenticationMethodValues 

func PossibleClientAuthenticationMethodValues() []ClientAuthenticationMethod

type ClientSecretContract 

type ClientSecretContract = original.ClientSecretContract

type Confirmation 

type Confirmation = original.Confirmation
const (
	ConfirmationInvite Confirmation = original.ConfirmationInvite
	ConfirmationSignup Confirmation = original.ConfirmationSignup
)

func PossibleConfirmationValues 

func PossibleConfirmationValues() []Confirmation

type ConnectionStatus 

type ConnectionStatus = original.ConnectionStatus
const (
	ConnectionStatusConnected    ConnectionStatus = original.ConnectionStatusConnected
	ConnectionStatusDegraded     ConnectionStatus = original.ConnectionStatusDegraded
	ConnectionStatusDisconnected ConnectionStatus = original.ConnectionStatusDisconnected
	ConnectionStatusUnknown      ConnectionStatus = original.ConnectionStatusUnknown
)

func PossibleConnectionStatusValues 

func PossibleConnectionStatusValues() []ConnectionStatus

type ConnectivityCheckProtocol 

type ConnectivityCheckProtocol = original.ConnectivityCheckProtocol
const (
	ConnectivityCheckProtocolHTTP  ConnectivityCheckProtocol = original.ConnectivityCheckProtocolHTTP
	ConnectivityCheckProtocolHTTPS ConnectivityCheckProtocol = original.ConnectivityCheckProtocolHTTPS
	ConnectivityCheckProtocolTCP   ConnectivityCheckProtocol = original.ConnectivityCheckProtocolTCP
)

func PossibleConnectivityCheckProtocolValues 

func PossibleConnectivityCheckProtocolValues() []ConnectivityCheckProtocol

type ConnectivityCheckRequest 

type ConnectivityCheckRequest = original.ConnectivityCheckRequest

type ConnectivityCheckRequestDestination 

type ConnectivityCheckRequestDestination = original.ConnectivityCheckRequestDestination

type ConnectivityCheckRequestProtocolConfiguration 

type ConnectivityCheckRequestProtocolConfiguration = original.ConnectivityCheckRequestProtocolConfiguration

type ConnectivityCheckRequestProtocolConfigurationHTTPConfiguration 

type ConnectivityCheckRequestProtocolConfigurationHTTPConfiguration = original.ConnectivityCheckRequestProtocolConfigurationHTTPConfiguration

type ConnectivityCheckRequestSource 

type ConnectivityCheckRequestSource = original.ConnectivityCheckRequestSource

type ConnectivityCheckResponse 

type ConnectivityCheckResponse = original.ConnectivityCheckResponse

type ConnectivityHop 

type ConnectivityHop = original.ConnectivityHop

type ConnectivityIssue 

type ConnectivityIssue = original.ConnectivityIssue

type ConnectivityStatusContract 

type ConnectivityStatusContract = original.ConnectivityStatusContract

type ConnectivityStatusType 

type ConnectivityStatusType = original.ConnectivityStatusType
const (
	ConnectivityStatusTypeFailure      ConnectivityStatusType = original.ConnectivityStatusTypeFailure
	ConnectivityStatusTypeInitializing ConnectivityStatusType = original.ConnectivityStatusTypeInitializing
	ConnectivityStatusTypeSuccess      ConnectivityStatusType = original.ConnectivityStatusTypeSuccess
)

func PossibleConnectivityStatusTypeValues 

func PossibleConnectivityStatusTypeValues() []ConnectivityStatusType

type ContentFormat 

type ContentFormat = original.ContentFormat
const (
	ContentFormatGraphqlLink     ContentFormat = original.ContentFormatGraphqlLink
	ContentFormatOpenapi         ContentFormat = original.ContentFormatOpenapi
	ContentFormatOpenapijson     ContentFormat = original.ContentFormatOpenapijson
	ContentFormatOpenapijsonLink ContentFormat = original.ContentFormatOpenapijsonLink
	ContentFormatOpenapiLink     ContentFormat = original.ContentFormatOpenapiLink
	ContentFormatSwaggerJSON     ContentFormat = original.ContentFormatSwaggerJSON
	ContentFormatSwaggerLinkJSON ContentFormat = original.ContentFormatSwaggerLinkJSON
	ContentFormatWadlLinkJSON    ContentFormat = original.ContentFormatWadlLinkJSON
	ContentFormatWadlXML         ContentFormat = original.ContentFormatWadlXML
	ContentFormatWsdl            ContentFormat = original.ContentFormatWsdl
	ContentFormatWsdlLink        ContentFormat = original.ContentFormatWsdlLink
)

func PossibleContentFormatValues 

func PossibleContentFormatValues() []ContentFormat

type ContentItemClient 

type ContentItemClient = original.ContentItemClient

func NewContentItemClient 

func NewContentItemClient(subscriptionID string) ContentItemClient

func NewContentItemClientWithBaseURI 

func NewContentItemClientWithBaseURI(baseURI string, subscriptionID string) ContentItemClient

type ContentItemCollection 

type ContentItemCollection = original.ContentItemCollection

type ContentItemCollectionIterator 

type ContentItemCollectionIterator = original.ContentItemCollectionIterator

func NewContentItemCollectionIterator 

func NewContentItemCollectionIterator(page ContentItemCollectionPage) ContentItemCollectionIterator

type ContentItemCollectionPage 

type ContentItemCollectionPage = original.ContentItemCollectionPage

func NewContentItemCollectionPage 

func NewContentItemCollectionPage(cur ContentItemCollection, getNextPage func(context.Context, ContentItemCollection) (ContentItemCollection, error)) ContentItemCollectionPage

type ContentItemContract 

type ContentItemContract = original.ContentItemContract

type ContentTypeClient 

type ContentTypeClient = original.ContentTypeClient

func NewContentTypeClient 

func NewContentTypeClient(subscriptionID string) ContentTypeClient

func NewContentTypeClientWithBaseURI 

func NewContentTypeClientWithBaseURI(baseURI string, subscriptionID string) ContentTypeClient

type ContentTypeCollection 

type ContentTypeCollection = original.ContentTypeCollection

type ContentTypeCollectionIterator 

type ContentTypeCollectionIterator = original.ContentTypeCollectionIterator

func NewContentTypeCollectionIterator 

func NewContentTypeCollectionIterator(page ContentTypeCollectionPage) ContentTypeCollectionIterator

type ContentTypeCollectionPage 

type ContentTypeCollectionPage = original.ContentTypeCollectionPage

func NewContentTypeCollectionPage 

func NewContentTypeCollectionPage(cur ContentTypeCollection, getNextPage func(context.Context, ContentTypeCollection) (ContentTypeCollection, error)) ContentTypeCollectionPage

type ContentTypeContract 

type ContentTypeContract = original.ContentTypeContract

type ContentTypeContractProperties 

type ContentTypeContractProperties = original.ContentTypeContractProperties

type CreatedByType 

type CreatedByType = original.CreatedByType
const (
	CreatedByTypeApplication     CreatedByType = original.CreatedByTypeApplication
	CreatedByTypeKey             CreatedByType = original.CreatedByTypeKey
	CreatedByTypeManagedIdentity CreatedByType = original.CreatedByTypeManagedIdentity
	CreatedByTypeUser            CreatedByType = original.CreatedByTypeUser
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

type DataMasking 

type DataMasking = original.DataMasking

type DataMaskingEntity 

type DataMaskingEntity = original.DataMaskingEntity

type DataMaskingMode 

type DataMaskingMode = original.DataMaskingMode
const (
	DataMaskingModeHide DataMaskingMode = original.DataMaskingModeHide
	DataMaskingModeMask DataMaskingMode = original.DataMaskingModeMask
)

func PossibleDataMaskingModeValues 

func PossibleDataMaskingModeValues() []DataMaskingMode

type DelegationSettingsClient 

type DelegationSettingsClient = original.DelegationSettingsClient

func NewDelegationSettingsClient 

func NewDelegationSettingsClient(subscriptionID string) DelegationSettingsClient

func NewDelegationSettingsClientWithBaseURI 

func NewDelegationSettingsClientWithBaseURI(baseURI string, subscriptionID string) DelegationSettingsClient

type DeletedServiceContract 

type DeletedServiceContract = original.DeletedServiceContract

type DeletedServiceContractProperties 

type DeletedServiceContractProperties = original.DeletedServiceContractProperties

type DeletedServicesClient 

type DeletedServicesClient = original.DeletedServicesClient

func NewDeletedServicesClient 

func NewDeletedServicesClient(subscriptionID string) DeletedServicesClient

func NewDeletedServicesClientWithBaseURI 

func NewDeletedServicesClientWithBaseURI(baseURI string, subscriptionID string) DeletedServicesClient

type DeletedServicesCollection 

type DeletedServicesCollection = original.DeletedServicesCollection

type DeletedServicesCollectionIterator 

type DeletedServicesCollectionIterator = original.DeletedServicesCollectionIterator

func NewDeletedServicesCollectionIterator 

func NewDeletedServicesCollectionIterator(page DeletedServicesCollectionPage) DeletedServicesCollectionIterator

type DeletedServicesCollectionPage 

type DeletedServicesCollectionPage = original.DeletedServicesCollectionPage

func NewDeletedServicesCollectionPage 

func NewDeletedServicesCollectionPage(cur DeletedServicesCollection, getNextPage func(context.Context, DeletedServicesCollection) (DeletedServicesCollection, error)) DeletedServicesCollectionPage

type DeletedServicesPurgeFuture 

type DeletedServicesPurgeFuture = original.DeletedServicesPurgeFuture

type DeployConfigurationParameterProperties 

type DeployConfigurationParameterProperties = original.DeployConfigurationParameterProperties

type DeployConfigurationParameters 

type DeployConfigurationParameters = original.DeployConfigurationParameters

type DiagnosticClient 

type DiagnosticClient = original.DiagnosticClient

func NewDiagnosticClient 

func NewDiagnosticClient(subscriptionID string) DiagnosticClient

func NewDiagnosticClientWithBaseURI 

func NewDiagnosticClientWithBaseURI(baseURI string, subscriptionID string) DiagnosticClient

type DiagnosticCollection 

type DiagnosticCollection = original.DiagnosticCollection

type DiagnosticCollectionIterator 

type DiagnosticCollectionIterator = original.DiagnosticCollectionIterator

func NewDiagnosticCollectionIterator 

func NewDiagnosticCollectionIterator(page DiagnosticCollectionPage) DiagnosticCollectionIterator

type DiagnosticCollectionPage 

type DiagnosticCollectionPage = original.DiagnosticCollectionPage

func NewDiagnosticCollectionPage 

func NewDiagnosticCollectionPage(cur DiagnosticCollection, getNextPage func(context.Context, DiagnosticCollection) (DiagnosticCollection, error)) DiagnosticCollectionPage

type DiagnosticContract 

type DiagnosticContract = original.DiagnosticContract

type DiagnosticContractProperties 

type DiagnosticContractProperties = original.DiagnosticContractProperties

type EmailTemplateClient 

type EmailTemplateClient = original.EmailTemplateClient

func NewEmailTemplateClient 

func NewEmailTemplateClient(subscriptionID string) EmailTemplateClient

func NewEmailTemplateClientWithBaseURI 

func NewEmailTemplateClientWithBaseURI(baseURI string, subscriptionID string) EmailTemplateClient

type EmailTemplateCollection 

type EmailTemplateCollection = original.EmailTemplateCollection

type EmailTemplateCollectionIterator 

type EmailTemplateCollectionIterator = original.EmailTemplateCollectionIterator

func NewEmailTemplateCollectionIterator 

func NewEmailTemplateCollectionIterator(page EmailTemplateCollectionPage) EmailTemplateCollectionIterator

type EmailTemplateCollectionPage 

type EmailTemplateCollectionPage = original.EmailTemplateCollectionPage

func NewEmailTemplateCollectionPage 

func NewEmailTemplateCollectionPage(cur EmailTemplateCollection, getNextPage func(context.Context, EmailTemplateCollection) (EmailTemplateCollection, error)) EmailTemplateCollectionPage

type EmailTemplateContract 

type EmailTemplateContract = original.EmailTemplateContract

type EmailTemplateContractProperties 

type EmailTemplateContractProperties = original.EmailTemplateContractProperties

type EmailTemplateParametersContractProperties 

type EmailTemplateParametersContractProperties = original.EmailTemplateParametersContractProperties

type EmailTemplateUpdateParameterProperties 

type EmailTemplateUpdateParameterProperties = original.EmailTemplateUpdateParameterProperties

type EmailTemplateUpdateParameters 

type EmailTemplateUpdateParameters = original.EmailTemplateUpdateParameters

type EndpointDependency 

type EndpointDependency = original.EndpointDependency

type EndpointDetail 

type EndpointDetail = original.EndpointDetail

type ErrorFieldContract 

type ErrorFieldContract = original.ErrorFieldContract

type ErrorResponse 

type ErrorResponse = original.ErrorResponse

type ErrorResponseBody 

type ErrorResponseBody = original.ErrorResponseBody

type ExportFormat 

type ExportFormat = original.ExportFormat
const (
	ExportFormatOpenapi     ExportFormat = original.ExportFormatOpenapi
	ExportFormatOpenapiJSON ExportFormat = original.ExportFormatOpenapiJSON
	ExportFormatSwagger     ExportFormat = original.ExportFormatSwagger
	ExportFormatWadl        ExportFormat = original.ExportFormatWadl
	ExportFormatWsdl        ExportFormat = original.ExportFormatWsdl
)

func PossibleExportFormatValues 

func PossibleExportFormatValues() []ExportFormat

type ExportResultFormat 

type ExportResultFormat = original.ExportResultFormat
const (
	ExportResultFormatOpenAPI ExportResultFormat = original.ExportResultFormatOpenAPI
	ExportResultFormatSwagger ExportResultFormat = original.ExportResultFormatSwagger
	ExportResultFormatWadl    ExportResultFormat = original.ExportResultFormatWadl
	ExportResultFormatWsdl    ExportResultFormat = original.ExportResultFormatWsdl
)

func PossibleExportResultFormatValues 

func PossibleExportResultFormatValues() []ExportResultFormat

type GatewayAPIClient 

type GatewayAPIClient = original.GatewayAPIClient

func NewGatewayAPIClient 

func NewGatewayAPIClient(subscriptionID string) GatewayAPIClient

func NewGatewayAPIClientWithBaseURI 

func NewGatewayAPIClientWithBaseURI(baseURI string, subscriptionID string) GatewayAPIClient

type GatewayCertificateAuthorityClient 

type GatewayCertificateAuthorityClient = original.GatewayCertificateAuthorityClient

func NewGatewayCertificateAuthorityClient 

func NewGatewayCertificateAuthorityClient(subscriptionID string) GatewayCertificateAuthorityClient

func NewGatewayCertificateAuthorityClientWithBaseURI 

func NewGatewayCertificateAuthorityClientWithBaseURI(baseURI string, subscriptionID string) GatewayCertificateAuthorityClient

type GatewayCertificateAuthorityCollection 

type GatewayCertificateAuthorityCollection = original.GatewayCertificateAuthorityCollection

type GatewayCertificateAuthorityCollectionIterator 

type GatewayCertificateAuthorityCollectionIterator = original.GatewayCertificateAuthorityCollectionIterator

func NewGatewayCertificateAuthorityCollectionIterator 

func NewGatewayCertificateAuthorityCollectionIterator(page GatewayCertificateAuthorityCollectionPage) GatewayCertificateAuthorityCollectionIterator

type GatewayCertificateAuthorityCollectionPage 

type GatewayCertificateAuthorityCollectionPage = original.GatewayCertificateAuthorityCollectionPage

func NewGatewayCertificateAuthorityCollectionPage 

func NewGatewayCertificateAuthorityCollectionPage(cur GatewayCertificateAuthorityCollection, getNextPage func(context.Context, GatewayCertificateAuthorityCollection) (GatewayCertificateAuthorityCollection, error)) GatewayCertificateAuthorityCollectionPage

type GatewayCertificateAuthorityContract 

type GatewayCertificateAuthorityContract = original.GatewayCertificateAuthorityContract

type GatewayCertificateAuthorityContractProperties 

type GatewayCertificateAuthorityContractProperties = original.GatewayCertificateAuthorityContractProperties

type GatewayClient 

type GatewayClient = original.GatewayClient

func NewGatewayClient 

func NewGatewayClient(subscriptionID string) GatewayClient

func NewGatewayClientWithBaseURI 

func NewGatewayClientWithBaseURI(baseURI string, subscriptionID string) GatewayClient

type GatewayCollection 

type GatewayCollection = original.GatewayCollection

type GatewayCollectionIterator 

type GatewayCollectionIterator = original.GatewayCollectionIterator

func NewGatewayCollectionIterator 

func NewGatewayCollectionIterator(page GatewayCollectionPage) GatewayCollectionIterator

type GatewayCollectionPage 

type GatewayCollectionPage = original.GatewayCollectionPage

func NewGatewayCollectionPage 

func NewGatewayCollectionPage(cur GatewayCollection, getNextPage func(context.Context, GatewayCollection) (GatewayCollection, error)) GatewayCollectionPage

type GatewayContract 

type GatewayContract = original.GatewayContract

type GatewayContractProperties 

type GatewayContractProperties = original.GatewayContractProperties

type GatewayHostnameConfigurationClient 

type GatewayHostnameConfigurationClient = original.GatewayHostnameConfigurationClient

func NewGatewayHostnameConfigurationClient 

func NewGatewayHostnameConfigurationClient(subscriptionID string) GatewayHostnameConfigurationClient

func NewGatewayHostnameConfigurationClientWithBaseURI 

func NewGatewayHostnameConfigurationClientWithBaseURI(baseURI string, subscriptionID string) GatewayHostnameConfigurationClient

type GatewayHostnameConfigurationCollection 

type GatewayHostnameConfigurationCollection = original.GatewayHostnameConfigurationCollection

type GatewayHostnameConfigurationCollectionIterator 

type GatewayHostnameConfigurationCollectionIterator = original.GatewayHostnameConfigurationCollectionIterator

func NewGatewayHostnameConfigurationCollectionIterator 

func NewGatewayHostnameConfigurationCollectionIterator(page GatewayHostnameConfigurationCollectionPage) GatewayHostnameConfigurationCollectionIterator

type GatewayHostnameConfigurationCollectionPage 

type GatewayHostnameConfigurationCollectionPage = original.GatewayHostnameConfigurationCollectionPage

func NewGatewayHostnameConfigurationCollectionPage 

func NewGatewayHostnameConfigurationCollectionPage(cur GatewayHostnameConfigurationCollection, getNextPage func(context.Context, GatewayHostnameConfigurationCollection) (GatewayHostnameConfigurationCollection, error)) GatewayHostnameConfigurationCollectionPage

type GatewayHostnameConfigurationContract 

type GatewayHostnameConfigurationContract = original.GatewayHostnameConfigurationContract

type GatewayHostnameConfigurationContractProperties 

type GatewayHostnameConfigurationContractProperties = original.GatewayHostnameConfigurationContractProperties

type GatewayKeyRegenerationRequestContract 

type GatewayKeyRegenerationRequestContract = original.GatewayKeyRegenerationRequestContract

type GatewayKeysContract 

type GatewayKeysContract = original.GatewayKeysContract

type GatewayTokenContract 

type GatewayTokenContract = original.GatewayTokenContract

type GatewayTokenRequestContract 

type GatewayTokenRequestContract = original.GatewayTokenRequestContract

type GenerateSsoURLResult 

type GenerateSsoURLResult = original.GenerateSsoURLResult

type GrantType 

type GrantType = original.GrantType
const (
	GrantTypeAuthorizationCode     GrantType = original.GrantTypeAuthorizationCode
	GrantTypeClientCredentials     GrantType = original.GrantTypeClientCredentials
	GrantTypeImplicit              GrantType = original.GrantTypeImplicit
	GrantTypeResourceOwnerPassword GrantType = original.GrantTypeResourceOwnerPassword
)

func PossibleGrantTypeValues 

func PossibleGrantTypeValues() []GrantType

type GroupClient 

type GroupClient = original.GroupClient

func NewGroupClient 

func NewGroupClient(subscriptionID string) GroupClient

func NewGroupClientWithBaseURI 

func NewGroupClientWithBaseURI(baseURI string, subscriptionID string) GroupClient

type GroupCollection 

type GroupCollection = original.GroupCollection

type GroupCollectionIterator 

type GroupCollectionIterator = original.GroupCollectionIterator

func NewGroupCollectionIterator 

func NewGroupCollectionIterator(page GroupCollectionPage) GroupCollectionIterator

type GroupCollectionPage 

type GroupCollectionPage = original.GroupCollectionPage

func NewGroupCollectionPage 

func NewGroupCollectionPage(cur GroupCollection, getNextPage func(context.Context, GroupCollection) (GroupCollection, error)) GroupCollectionPage

type GroupContract 

type GroupContract = original.GroupContract

type GroupContractProperties 

type GroupContractProperties = original.GroupContractProperties

type GroupCreateParameters 

type GroupCreateParameters = original.GroupCreateParameters

type GroupCreateParametersProperties 

type GroupCreateParametersProperties = original.GroupCreateParametersProperties

type GroupType 

type GroupType = original.GroupType
const (
	GroupTypeCustom   GroupType = original.GroupTypeCustom
	GroupTypeExternal GroupType = original.GroupTypeExternal
	GroupTypeSystem   GroupType = original.GroupTypeSystem
)

func PossibleGroupTypeValues 

func PossibleGroupTypeValues() []GroupType

type GroupUpdateParameters 

type GroupUpdateParameters = original.GroupUpdateParameters

type GroupUpdateParametersProperties 

type GroupUpdateParametersProperties = original.GroupUpdateParametersProperties

type GroupUserClient 

type GroupUserClient = original.GroupUserClient

func NewGroupUserClient 

func NewGroupUserClient(subscriptionID string) GroupUserClient

func NewGroupUserClientWithBaseURI 

func NewGroupUserClientWithBaseURI(baseURI string, subscriptionID string) GroupUserClient

type HTTPCorrelationProtocol 

type HTTPCorrelationProtocol = original.HTTPCorrelationProtocol
const (
	HTTPCorrelationProtocolLegacy HTTPCorrelationProtocol = original.HTTPCorrelationProtocolLegacy
	HTTPCorrelationProtocolNone   HTTPCorrelationProtocol = original.HTTPCorrelationProtocolNone
	HTTPCorrelationProtocolW3C    HTTPCorrelationProtocol = original.HTTPCorrelationProtocolW3C
)

func PossibleHTTPCorrelationProtocolValues 

func PossibleHTTPCorrelationProtocolValues() []HTTPCorrelationProtocol

type HTTPHeader 

type HTTPHeader = original.HTTPHeader

type HTTPMessageDiagnostic 

type HTTPMessageDiagnostic = original.HTTPMessageDiagnostic

type HostnameConfiguration 

type HostnameConfiguration = original.HostnameConfiguration

type HostnameType 

type HostnameType = original.HostnameType
const (
	HostnameTypeDeveloperPortal HostnameType = original.HostnameTypeDeveloperPortal
	HostnameTypeManagement      HostnameType = original.HostnameTypeManagement
	HostnameTypePortal          HostnameType = original.HostnameTypePortal
	HostnameTypeProxy           HostnameType = original.HostnameTypeProxy
	HostnameTypeScm             HostnameType = original.HostnameTypeScm
)

func PossibleHostnameTypeValues 

func PossibleHostnameTypeValues() []HostnameType

type IdentityProviderBaseParameters 

type IdentityProviderBaseParameters = original.IdentityProviderBaseParameters

type IdentityProviderClient 

type IdentityProviderClient = original.IdentityProviderClient

func NewIdentityProviderClient 

func NewIdentityProviderClient(subscriptionID string) IdentityProviderClient

func NewIdentityProviderClientWithBaseURI 

func NewIdentityProviderClientWithBaseURI(baseURI string, subscriptionID string) IdentityProviderClient

type IdentityProviderContract 

type IdentityProviderContract = original.IdentityProviderContract

type IdentityProviderContractProperties 

type IdentityProviderContractProperties = original.IdentityProviderContractProperties

type IdentityProviderCreateContract 

type IdentityProviderCreateContract = original.IdentityProviderCreateContract

type IdentityProviderCreateContractProperties 

type IdentityProviderCreateContractProperties = original.IdentityProviderCreateContractProperties

type IdentityProviderList 

type IdentityProviderList = original.IdentityProviderList

type IdentityProviderListIterator 

type IdentityProviderListIterator = original.IdentityProviderListIterator

func NewIdentityProviderListIterator 

func NewIdentityProviderListIterator(page IdentityProviderListPage) IdentityProviderListIterator

type IdentityProviderListPage 

type IdentityProviderListPage = original.IdentityProviderListPage

func NewIdentityProviderListPage 

func NewIdentityProviderListPage(cur IdentityProviderList, getNextPage func(context.Context, IdentityProviderList) (IdentityProviderList, error)) IdentityProviderListPage

type IdentityProviderType 

type IdentityProviderType = original.IdentityProviderType
const (
	IdentityProviderTypeAad       IdentityProviderType = original.IdentityProviderTypeAad
	IdentityProviderTypeAadB2C    IdentityProviderType = original.IdentityProviderTypeAadB2C
	IdentityProviderTypeFacebook  IdentityProviderType = original.IdentityProviderTypeFacebook
	IdentityProviderTypeGoogle    IdentityProviderType = original.IdentityProviderTypeGoogle
	IdentityProviderTypeMicrosoft IdentityProviderType = original.IdentityProviderTypeMicrosoft
	IdentityProviderTypeTwitter   IdentityProviderType = original.IdentityProviderTypeTwitter
)

func PossibleIdentityProviderTypeValues 

func PossibleIdentityProviderTypeValues() []IdentityProviderType

type IdentityProviderUpdateParameters 

type IdentityProviderUpdateParameters = original.IdentityProviderUpdateParameters

type IdentityProviderUpdateProperties 

type IdentityProviderUpdateProperties = original.IdentityProviderUpdateProperties

type IssueAttachmentCollection 

type IssueAttachmentCollection = original.IssueAttachmentCollection

type IssueAttachmentCollectionIterator 

type IssueAttachmentCollectionIterator = original.IssueAttachmentCollectionIterator

func NewIssueAttachmentCollectionIterator 

func NewIssueAttachmentCollectionIterator(page IssueAttachmentCollectionPage) IssueAttachmentCollectionIterator

type IssueAttachmentCollectionPage 

type IssueAttachmentCollectionPage = original.IssueAttachmentCollectionPage

func NewIssueAttachmentCollectionPage 

func NewIssueAttachmentCollectionPage(cur IssueAttachmentCollection, getNextPage func(context.Context, IssueAttachmentCollection) (IssueAttachmentCollection, error)) IssueAttachmentCollectionPage

type IssueAttachmentContract 

type IssueAttachmentContract = original.IssueAttachmentContract

type IssueAttachmentContractProperties 

type IssueAttachmentContractProperties = original.IssueAttachmentContractProperties

type IssueClient 

type IssueClient = original.IssueClient

func NewIssueClient 

func NewIssueClient(subscriptionID string) IssueClient

func NewIssueClientWithBaseURI 

func NewIssueClientWithBaseURI(baseURI string, subscriptionID string) IssueClient

type IssueCollection 

type IssueCollection = original.IssueCollection

type IssueCollectionIterator 

type IssueCollectionIterator = original.IssueCollectionIterator

func NewIssueCollectionIterator 

func NewIssueCollectionIterator(page IssueCollectionPage) IssueCollectionIterator

type IssueCollectionPage 

type IssueCollectionPage = original.IssueCollectionPage

func NewIssueCollectionPage 

func NewIssueCollectionPage(cur IssueCollection, getNextPage func(context.Context, IssueCollection) (IssueCollection, error)) IssueCollectionPage

type IssueCommentCollection 

type IssueCommentCollection = original.IssueCommentCollection

type IssueCommentCollectionIterator 

type IssueCommentCollectionIterator = original.IssueCommentCollectionIterator

func NewIssueCommentCollectionIterator 

func NewIssueCommentCollectionIterator(page IssueCommentCollectionPage) IssueCommentCollectionIterator

type IssueCommentCollectionPage 

type IssueCommentCollectionPage = original.IssueCommentCollectionPage

func NewIssueCommentCollectionPage 

func NewIssueCommentCollectionPage(cur IssueCommentCollection, getNextPage func(context.Context, IssueCommentCollection) (IssueCommentCollection, error)) IssueCommentCollectionPage

type IssueCommentContract 

type IssueCommentContract = original.IssueCommentContract

type IssueCommentContractProperties 

type IssueCommentContractProperties = original.IssueCommentContractProperties

type IssueContract 

type IssueContract = original.IssueContract

type IssueContractBaseProperties 

type IssueContractBaseProperties = original.IssueContractBaseProperties

type IssueContractProperties 

type IssueContractProperties = original.IssueContractProperties

type IssueType 

type IssueType = original.IssueType
const (
	IssueTypeAgentStopped        IssueType = original.IssueTypeAgentStopped
	IssueTypeDNSResolution       IssueType = original.IssueTypeDNSResolution
	IssueTypeGuestFirewall       IssueType = original.IssueTypeGuestFirewall
	IssueTypeNetworkSecurityRule IssueType = original.IssueTypeNetworkSecurityRule
	IssueTypePlatform            IssueType = original.IssueTypePlatform
	IssueTypePortThrottled       IssueType = original.IssueTypePortThrottled
	IssueTypeSocketBind          IssueType = original.IssueTypeSocketBind
	IssueTypeUnknown             IssueType = original.IssueTypeUnknown
	IssueTypeUserDefinedRoute    IssueType = original.IssueTypeUserDefinedRoute
)

func PossibleIssueTypeValues 

func PossibleIssueTypeValues() []IssueType

type IssueUpdateContract 

type IssueUpdateContract = original.IssueUpdateContract

type IssueUpdateContractProperties 

type IssueUpdateContractProperties = original.IssueUpdateContractProperties

type KeyType 

type KeyType = original.KeyType
const (
	KeyTypePrimary   KeyType = original.KeyTypePrimary
	KeyTypeSecondary KeyType = original.KeyTypeSecondary
)

func PossibleKeyTypeValues 

func PossibleKeyTypeValues() []KeyType

type KeyVaultContractCreateProperties 

type KeyVaultContractCreateProperties = original.KeyVaultContractCreateProperties

type KeyVaultContractProperties 

type KeyVaultContractProperties = original.KeyVaultContractProperties

type KeyVaultLastAccessStatusContractProperties 

type KeyVaultLastAccessStatusContractProperties = original.KeyVaultLastAccessStatusContractProperties

type ListNetworkStatusContractByLocation 

type ListNetworkStatusContractByLocation = original.ListNetworkStatusContractByLocation

type LoggerClient 

type LoggerClient = original.LoggerClient

func NewLoggerClient 

func NewLoggerClient(subscriptionID string) LoggerClient

func NewLoggerClientWithBaseURI 

func NewLoggerClientWithBaseURI(baseURI string, subscriptionID string) LoggerClient

type LoggerCollection 

type LoggerCollection = original.LoggerCollection

type LoggerCollectionIterator 

type LoggerCollectionIterator = original.LoggerCollectionIterator

func NewLoggerCollectionIterator 

func NewLoggerCollectionIterator(page LoggerCollectionPage) LoggerCollectionIterator

type LoggerCollectionPage 

type LoggerCollectionPage = original.LoggerCollectionPage

func NewLoggerCollectionPage 

func NewLoggerCollectionPage(cur LoggerCollection, getNextPage func(context.Context, LoggerCollection) (LoggerCollection, error)) LoggerCollectionPage

type LoggerContract 

type LoggerContract = original.LoggerContract

type LoggerContractProperties 

type LoggerContractProperties = original.LoggerContractProperties

type LoggerType 

type LoggerType = original.LoggerType
const (
	LoggerTypeApplicationInsights LoggerType = original.LoggerTypeApplicationInsights
	LoggerTypeAzureEventHub       LoggerType = original.LoggerTypeAzureEventHub
	LoggerTypeAzureMonitor        LoggerType = original.LoggerTypeAzureMonitor
)

func PossibleLoggerTypeValues 

func PossibleLoggerTypeValues() []LoggerType

type LoggerUpdateContract 

type LoggerUpdateContract = original.LoggerUpdateContract

type LoggerUpdateParameters 

type LoggerUpdateParameters = original.LoggerUpdateParameters

type Method 

type Method = original.Method
const (
	MethodGET  Method = original.MethodGET
	MethodPOST Method = original.MethodPOST
)

func PossibleMethodValues 

func PossibleMethodValues() []Method

type NameAvailabilityReason 

type NameAvailabilityReason = original.NameAvailabilityReason
const (
	NameAvailabilityReasonAlreadyExists NameAvailabilityReason = original.NameAvailabilityReasonAlreadyExists
	NameAvailabilityReasonInvalid       NameAvailabilityReason = original.NameAvailabilityReasonInvalid
	NameAvailabilityReasonValid         NameAvailabilityReason = original.NameAvailabilityReasonValid
)

func PossibleNameAvailabilityReasonValues 

func PossibleNameAvailabilityReasonValues() []NameAvailabilityReason

type NamedValueClient 

type NamedValueClient = original.NamedValueClient

func NewNamedValueClient 

func NewNamedValueClient(subscriptionID string) NamedValueClient

func NewNamedValueClientWithBaseURI 

func NewNamedValueClientWithBaseURI(baseURI string, subscriptionID string) NamedValueClient

type NamedValueCollection 

type NamedValueCollection = original.NamedValueCollection

type NamedValueCollectionIterator 

type NamedValueCollectionIterator = original.NamedValueCollectionIterator

func NewNamedValueCollectionIterator 

func NewNamedValueCollectionIterator(page NamedValueCollectionPage) NamedValueCollectionIterator

type NamedValueCollectionPage 

type NamedValueCollectionPage = original.NamedValueCollectionPage

func NewNamedValueCollectionPage 

func NewNamedValueCollectionPage(cur NamedValueCollection, getNextPage func(context.Context, NamedValueCollection) (NamedValueCollection, error)) NamedValueCollectionPage

type NamedValueContract 

type NamedValueContract = original.NamedValueContract

type NamedValueContractProperties 

type NamedValueContractProperties = original.NamedValueContractProperties

type NamedValueCreateContract 

type NamedValueCreateContract = original.NamedValueCreateContract

type NamedValueCreateContractProperties 

type NamedValueCreateContractProperties = original.NamedValueCreateContractProperties

type NamedValueCreateOrUpdateFuture 

type NamedValueCreateOrUpdateFuture = original.NamedValueCreateOrUpdateFuture

type NamedValueEntityBaseParameters 

type NamedValueEntityBaseParameters = original.NamedValueEntityBaseParameters

type NamedValueRefreshSecretFuture 

type NamedValueRefreshSecretFuture = original.NamedValueRefreshSecretFuture

type NamedValueSecretContract 

type NamedValueSecretContract = original.NamedValueSecretContract

type NamedValueUpdateFuture 

type NamedValueUpdateFuture = original.NamedValueUpdateFuture

type NamedValueUpdateParameterProperties 

type NamedValueUpdateParameterProperties = original.NamedValueUpdateParameterProperties

type NamedValueUpdateParameters 

type NamedValueUpdateParameters = original.NamedValueUpdateParameters

type NetworkStatusClient 

type NetworkStatusClient = original.NetworkStatusClient

func NewNetworkStatusClient 

func NewNetworkStatusClient(subscriptionID string) NetworkStatusClient

func NewNetworkStatusClientWithBaseURI 

func NewNetworkStatusClientWithBaseURI(baseURI string, subscriptionID string) NetworkStatusClient

type NetworkStatusContract 

type NetworkStatusContract = original.NetworkStatusContract

type NetworkStatusContractByLocation 

type NetworkStatusContractByLocation = original.NetworkStatusContractByLocation

type NotificationClient 

type NotificationClient = original.NotificationClient

func NewNotificationClient 

func NewNotificationClient(subscriptionID string) NotificationClient

func NewNotificationClientWithBaseURI 

func NewNotificationClientWithBaseURI(baseURI string, subscriptionID string) NotificationClient

type NotificationCollection 

type NotificationCollection = original.NotificationCollection

type NotificationCollectionIterator 

type NotificationCollectionIterator = original.NotificationCollectionIterator

func NewNotificationCollectionIterator 

func NewNotificationCollectionIterator(page NotificationCollectionPage) NotificationCollectionIterator

type NotificationCollectionPage 

type NotificationCollectionPage = original.NotificationCollectionPage

func NewNotificationCollectionPage 

func NewNotificationCollectionPage(cur NotificationCollection, getNextPage func(context.Context, NotificationCollection) (NotificationCollection, error)) NotificationCollectionPage

type NotificationContract 

type NotificationContract = original.NotificationContract

type NotificationContractProperties 

type NotificationContractProperties = original.NotificationContractProperties

type NotificationName 

type NotificationName = original.NotificationName
const (
	NotificationNameAccountClosedPublisher                            NotificationName = original.NotificationNameAccountClosedPublisher
	NotificationNameBCC                                               NotificationName = original.NotificationNameBCC
	NotificationNameNewApplicationNotificationMessage                 NotificationName = original.NotificationNameNewApplicationNotificationMessage
	NotificationNameNewIssuePublisherNotificationMessage              NotificationName = original.NotificationNameNewIssuePublisherNotificationMessage
	NotificationNamePurchasePublisherNotificationMessage              NotificationName = original.NotificationNamePurchasePublisherNotificationMessage
	NotificationNameQuotaLimitApproachingPublisherNotificationMessage NotificationName = original.NotificationNameQuotaLimitApproachingPublisherNotificationMessage
	NotificationNameRequestPublisherNotificationMessage               NotificationName = original.NotificationNameRequestPublisherNotificationMessage
)

func PossibleNotificationNameValues 

func PossibleNotificationNameValues() []NotificationName

type NotificationRecipientEmailClient 

type NotificationRecipientEmailClient = original.NotificationRecipientEmailClient

func NewNotificationRecipientEmailClient 

func NewNotificationRecipientEmailClient(subscriptionID string) NotificationRecipientEmailClient

func NewNotificationRecipientEmailClientWithBaseURI 

func NewNotificationRecipientEmailClientWithBaseURI(baseURI string, subscriptionID string) NotificationRecipientEmailClient

type NotificationRecipientUserClient 

type NotificationRecipientUserClient = original.NotificationRecipientUserClient

func NewNotificationRecipientUserClient 

func NewNotificationRecipientUserClient(subscriptionID string) NotificationRecipientUserClient

func NewNotificationRecipientUserClientWithBaseURI 

func NewNotificationRecipientUserClientWithBaseURI(baseURI string, subscriptionID string) NotificationRecipientUserClient

type OAuth2AuthenticationSettingsContract 

type OAuth2AuthenticationSettingsContract = original.OAuth2AuthenticationSettingsContract

type OpenIDAuthenticationSettingsContract 

type OpenIDAuthenticationSettingsContract = original.OpenIDAuthenticationSettingsContract

type OpenIDConnectProviderClient 

type OpenIDConnectProviderClient = original.OpenIDConnectProviderClient

func NewOpenIDConnectProviderClient 

func NewOpenIDConnectProviderClient(subscriptionID string) OpenIDConnectProviderClient

func NewOpenIDConnectProviderClientWithBaseURI 

func NewOpenIDConnectProviderClientWithBaseURI(baseURI string, subscriptionID string) OpenIDConnectProviderClient

type OpenIDConnectProviderCollection 

type OpenIDConnectProviderCollection = original.OpenIDConnectProviderCollection

type OpenIDConnectProviderCollectionIterator 

type OpenIDConnectProviderCollectionIterator = original.OpenIDConnectProviderCollectionIterator

func NewOpenIDConnectProviderCollectionIterator 

func NewOpenIDConnectProviderCollectionIterator(page OpenIDConnectProviderCollectionPage) OpenIDConnectProviderCollectionIterator

type OpenIDConnectProviderCollectionPage 

type OpenIDConnectProviderCollectionPage = original.OpenIDConnectProviderCollectionPage

func NewOpenIDConnectProviderCollectionPage 

func NewOpenIDConnectProviderCollectionPage(cur OpenIDConnectProviderCollection, getNextPage func(context.Context, OpenIDConnectProviderCollection) (OpenIDConnectProviderCollection, error)) OpenIDConnectProviderCollectionPage

type OpenidConnectProviderContract 

type OpenidConnectProviderContract = original.OpenidConnectProviderContract

type OpenidConnectProviderContractProperties 

type OpenidConnectProviderContractProperties = original.OpenidConnectProviderContractProperties

type OpenidConnectProviderUpdateContract 

type OpenidConnectProviderUpdateContract = original.OpenidConnectProviderUpdateContract

type OpenidConnectProviderUpdateContractProperties 

type OpenidConnectProviderUpdateContractProperties = original.OpenidConnectProviderUpdateContractProperties

type Operation 

type Operation = original.Operation

type OperationClient 

type OperationClient = original.OperationClient

func NewOperationClient 

func NewOperationClient(subscriptionID string) OperationClient

func NewOperationClientWithBaseURI 

func NewOperationClientWithBaseURI(baseURI string, subscriptionID string) OperationClient

type OperationCollection 

type OperationCollection = original.OperationCollection

type OperationCollectionIterator 

type OperationCollectionIterator = original.OperationCollectionIterator

func NewOperationCollectionIterator 

func NewOperationCollectionIterator(page OperationCollectionPage) OperationCollectionIterator

type OperationCollectionPage 

type OperationCollectionPage = original.OperationCollectionPage

func NewOperationCollectionPage 

func NewOperationCollectionPage(cur OperationCollection, getNextPage func(context.Context, OperationCollection) (OperationCollection, error)) OperationCollectionPage

type OperationContract 

type OperationContract = original.OperationContract

type OperationContractProperties 

type OperationContractProperties = original.OperationContractProperties

type OperationDisplay 

type OperationDisplay = original.OperationDisplay

type OperationEntityBaseContract 

type OperationEntityBaseContract = original.OperationEntityBaseContract

type OperationListResult 

type OperationListResult = original.OperationListResult

type OperationListResultIterator 

type OperationListResultIterator = original.OperationListResultIterator

func NewOperationListResultIterator 

func NewOperationListResultIterator(page OperationListResultPage) OperationListResultIterator

type OperationListResultPage 

type OperationListResultPage = original.OperationListResultPage

func NewOperationListResultPage 

func NewOperationListResultPage(cur OperationListResult, getNextPage func(context.Context, OperationListResult) (OperationListResult, error)) OperationListResultPage

type OperationNameFormat 

type OperationNameFormat = original.OperationNameFormat
const (
	OperationNameFormatName OperationNameFormat = original.OperationNameFormatName
	OperationNameFormatURL  OperationNameFormat = original.OperationNameFormatURL
)

func PossibleOperationNameFormatValues 

func PossibleOperationNameFormatValues() []OperationNameFormat

type OperationResultContract 

type OperationResultContract = original.OperationResultContract

type OperationResultContractProperties 

type OperationResultContractProperties = original.OperationResultContractProperties

type OperationResultLogItemContract 

type OperationResultLogItemContract = original.OperationResultLogItemContract

type OperationTagResourceContractProperties 

type OperationTagResourceContractProperties = original.OperationTagResourceContractProperties

type OperationUpdateContract 

type OperationUpdateContract = original.OperationUpdateContract

type OperationUpdateContractProperties 

type OperationUpdateContractProperties = original.OperationUpdateContractProperties

type OperationsClient 

type OperationsClient = original.OperationsClient

func NewOperationsClient 

func NewOperationsClient(subscriptionID string) OperationsClient

func NewOperationsClientWithBaseURI 

func NewOperationsClientWithBaseURI(baseURI string, subscriptionID string) OperationsClient

type Origin 

type Origin = original.Origin
const (
	OriginInbound  Origin = original.OriginInbound
	OriginLocal    Origin = original.OriginLocal
	OriginOutbound Origin = original.OriginOutbound
)

func PossibleOriginValues 

func PossibleOriginValues() []Origin

type OutboundEnvironmentEndpoint 

type OutboundEnvironmentEndpoint = original.OutboundEnvironmentEndpoint

type OutboundEnvironmentEndpointList 

type OutboundEnvironmentEndpointList = original.OutboundEnvironmentEndpointList

type OutboundNetworkDependenciesEndpointsClient 

type OutboundNetworkDependenciesEndpointsClient = original.OutboundNetworkDependenciesEndpointsClient

func NewOutboundNetworkDependenciesEndpointsClient 

func NewOutboundNetworkDependenciesEndpointsClient(subscriptionID string) OutboundNetworkDependenciesEndpointsClient

func NewOutboundNetworkDependenciesEndpointsClientWithBaseURI 

func NewOutboundNetworkDependenciesEndpointsClientWithBaseURI(baseURI string, subscriptionID string) OutboundNetworkDependenciesEndpointsClient

type ParameterContract 

type ParameterContract = original.ParameterContract

type ParameterExampleContract 

type ParameterExampleContract = original.ParameterExampleContract

type PerformConnectivityCheckAsyncFuture 

type PerformConnectivityCheckAsyncFuture = original.PerformConnectivityCheckAsyncFuture

type PipelineDiagnosticSettings 

type PipelineDiagnosticSettings = original.PipelineDiagnosticSettings

type PlatformVersion 

type PlatformVersion = original.PlatformVersion
const (
	PlatformVersionMtv1         PlatformVersion = original.PlatformVersionMtv1
	PlatformVersionStv1         PlatformVersion = original.PlatformVersionStv1
	PlatformVersionStv2         PlatformVersion = original.PlatformVersionStv2
	PlatformVersionUndetermined PlatformVersion = original.PlatformVersionUndetermined
)

func PossiblePlatformVersionValues 

func PossiblePlatformVersionValues() []PlatformVersion

type PolicyClient 

type PolicyClient = original.PolicyClient

func NewPolicyClient 

func NewPolicyClient(subscriptionID string) PolicyClient

func NewPolicyClientWithBaseURI 

func NewPolicyClientWithBaseURI(baseURI string, subscriptionID string) PolicyClient

type PolicyCollection 

type PolicyCollection = original.PolicyCollection

type PolicyContentFormat 

type PolicyContentFormat = original.PolicyContentFormat
const (
	PolicyContentFormatRawxml     PolicyContentFormat = original.PolicyContentFormatRawxml
	PolicyContentFormatRawxmlLink PolicyContentFormat = original.PolicyContentFormatRawxmlLink
	PolicyContentFormatXML        PolicyContentFormat = original.PolicyContentFormatXML
	PolicyContentFormatXMLLink    PolicyContentFormat = original.PolicyContentFormatXMLLink
)

func PossiblePolicyContentFormatValues 

func PossiblePolicyContentFormatValues() []PolicyContentFormat

type PolicyContract 

type PolicyContract = original.PolicyContract

type PolicyContractProperties 

type PolicyContractProperties = original.PolicyContractProperties

type PolicyDescriptionClient 

type PolicyDescriptionClient = original.PolicyDescriptionClient

func NewPolicyDescriptionClient 

func NewPolicyDescriptionClient(subscriptionID string) PolicyDescriptionClient

func NewPolicyDescriptionClientWithBaseURI 

func NewPolicyDescriptionClientWithBaseURI(baseURI string, subscriptionID string) PolicyDescriptionClient

type PolicyDescriptionCollection 

type PolicyDescriptionCollection = original.PolicyDescriptionCollection

type PolicyDescriptionContract 

type PolicyDescriptionContract = original.PolicyDescriptionContract

type PolicyDescriptionContractProperties 

type PolicyDescriptionContractProperties = original.PolicyDescriptionContractProperties

type PolicyExportFormat 

type PolicyExportFormat = original.PolicyExportFormat
const (
	PolicyExportFormatRawxml PolicyExportFormat = original.PolicyExportFormatRawxml
	PolicyExportFormatXML    PolicyExportFormat = original.PolicyExportFormatXML
)

func PossiblePolicyExportFormatValues 

func PossiblePolicyExportFormatValues() []PolicyExportFormat

type PolicyScopeContract 

type PolicyScopeContract = original.PolicyScopeContract
const (
	PolicyScopeContractAll       PolicyScopeContract = original.PolicyScopeContractAll
	PolicyScopeContractAPI       PolicyScopeContract = original.PolicyScopeContractAPI
	PolicyScopeContractOperation PolicyScopeContract = original.PolicyScopeContractOperation
	PolicyScopeContractProduct   PolicyScopeContract = original.PolicyScopeContractProduct
	PolicyScopeContractTenant    PolicyScopeContract = original.PolicyScopeContractTenant
)

func PossiblePolicyScopeContractValues 

func PossiblePolicyScopeContractValues() []PolicyScopeContract

type PortalDelegationSettings 

type PortalDelegationSettings = original.PortalDelegationSettings

type PortalDelegationSettingsProperties 

type PortalDelegationSettingsProperties = original.PortalDelegationSettingsProperties

type PortalRevisionClient 

type PortalRevisionClient = original.PortalRevisionClient

func NewPortalRevisionClient 

func NewPortalRevisionClient(subscriptionID string) PortalRevisionClient

func NewPortalRevisionClientWithBaseURI 

func NewPortalRevisionClientWithBaseURI(baseURI string, subscriptionID string) PortalRevisionClient

type PortalRevisionCollection 

type PortalRevisionCollection = original.PortalRevisionCollection

type PortalRevisionCollectionIterator 

type PortalRevisionCollectionIterator = original.PortalRevisionCollectionIterator

func NewPortalRevisionCollectionIterator 

func NewPortalRevisionCollectionIterator(page PortalRevisionCollectionPage) PortalRevisionCollectionIterator

type PortalRevisionCollectionPage 

type PortalRevisionCollectionPage = original.PortalRevisionCollectionPage

func NewPortalRevisionCollectionPage 

func NewPortalRevisionCollectionPage(cur PortalRevisionCollection, getNextPage func(context.Context, PortalRevisionCollection) (PortalRevisionCollection, error)) PortalRevisionCollectionPage

type PortalRevisionContract 

type PortalRevisionContract = original.PortalRevisionContract

type PortalRevisionContractProperties 

type PortalRevisionContractProperties = original.PortalRevisionContractProperties

type PortalRevisionCreateOrUpdateFuture 

type PortalRevisionCreateOrUpdateFuture = original.PortalRevisionCreateOrUpdateFuture

type PortalRevisionStatus 

type PortalRevisionStatus = original.PortalRevisionStatus
const (
	PortalRevisionStatusCompleted  PortalRevisionStatus = original.PortalRevisionStatusCompleted
	PortalRevisionStatusFailed     PortalRevisionStatus = original.PortalRevisionStatusFailed
	PortalRevisionStatusPending    PortalRevisionStatus = original.PortalRevisionStatusPending
	PortalRevisionStatusPublishing PortalRevisionStatus = original.PortalRevisionStatusPublishing
)

func PossiblePortalRevisionStatusValues 

func PossiblePortalRevisionStatusValues() []PortalRevisionStatus

type PortalRevisionUpdateFuture 

type PortalRevisionUpdateFuture = original.PortalRevisionUpdateFuture

type PortalSettingValidationKeyContract 

type PortalSettingValidationKeyContract = original.PortalSettingValidationKeyContract

type PortalSettingsClient 

type PortalSettingsClient = original.PortalSettingsClient

func NewPortalSettingsClient 

func NewPortalSettingsClient(subscriptionID string) PortalSettingsClient

func NewPortalSettingsClientWithBaseURI 

func NewPortalSettingsClientWithBaseURI(baseURI string, subscriptionID string) PortalSettingsClient

type PortalSettingsCollection 

type PortalSettingsCollection = original.PortalSettingsCollection

type PortalSettingsContract 

type PortalSettingsContract = original.PortalSettingsContract

type PortalSettingsContractProperties 

type PortalSettingsContractProperties = original.PortalSettingsContractProperties

type PortalSigninSettingProperties 

type PortalSigninSettingProperties = original.PortalSigninSettingProperties

type PortalSigninSettings 

type PortalSigninSettings = original.PortalSigninSettings

type PortalSignupSettings 

type PortalSignupSettings = original.PortalSignupSettings

type PortalSignupSettingsProperties 

type PortalSignupSettingsProperties = original.PortalSignupSettingsProperties

type PreferredIPVersion 

type PreferredIPVersion = original.PreferredIPVersion
const (
	PreferredIPVersionIPv4 PreferredIPVersion = original.PreferredIPVersionIPv4
)

func PossiblePreferredIPVersionValues 

func PossiblePreferredIPVersionValues() []PreferredIPVersion

type PrivateEndpoint 

type PrivateEndpoint = original.PrivateEndpoint

type PrivateEndpointConnection 

type PrivateEndpointConnection = original.PrivateEndpointConnection

type PrivateEndpointConnectionClient 

type PrivateEndpointConnectionClient = original.PrivateEndpointConnectionClient

func NewPrivateEndpointConnectionClient 

func NewPrivateEndpointConnectionClient(subscriptionID string) PrivateEndpointConnectionClient

func NewPrivateEndpointConnectionClientWithBaseURI 

func NewPrivateEndpointConnectionClientWithBaseURI(baseURI string, subscriptionID string) PrivateEndpointConnectionClient

type PrivateEndpointConnectionCreateOrUpdateFuture 

type PrivateEndpointConnectionCreateOrUpdateFuture = original.PrivateEndpointConnectionCreateOrUpdateFuture

type PrivateEndpointConnectionDeleteFuture 

type PrivateEndpointConnectionDeleteFuture = original.PrivateEndpointConnectionDeleteFuture

type PrivateEndpointConnectionListResult 

type PrivateEndpointConnectionListResult = original.PrivateEndpointConnectionListResult

type PrivateEndpointConnectionProperties 

type PrivateEndpointConnectionProperties = original.PrivateEndpointConnectionProperties

type PrivateEndpointConnectionProvisioningState 

type PrivateEndpointConnectionProvisioningState = original.PrivateEndpointConnectionProvisioningState
const (
	PrivateEndpointConnectionProvisioningStateCreating  PrivateEndpointConnectionProvisioningState = original.PrivateEndpointConnectionProvisioningStateCreating
	PrivateEndpointConnectionProvisioningStateDeleting  PrivateEndpointConnectionProvisioningState = original.PrivateEndpointConnectionProvisioningStateDeleting
	PrivateEndpointConnectionProvisioningStateFailed    PrivateEndpointConnectionProvisioningState = original.PrivateEndpointConnectionProvisioningStateFailed
	PrivateEndpointConnectionProvisioningStateSucceeded PrivateEndpointConnectionProvisioningState = original.PrivateEndpointConnectionProvisioningStateSucceeded
)

func PossiblePrivateEndpointConnectionProvisioningStateValues 

func PossiblePrivateEndpointConnectionProvisioningStateValues() []PrivateEndpointConnectionProvisioningState

type PrivateEndpointConnectionRequest 

type PrivateEndpointConnectionRequest = original.PrivateEndpointConnectionRequest

type PrivateEndpointConnectionRequestProperties 

type PrivateEndpointConnectionRequestProperties = original.PrivateEndpointConnectionRequestProperties

type PrivateEndpointConnectionWrapperProperties 

type PrivateEndpointConnectionWrapperProperties = original.PrivateEndpointConnectionWrapperProperties

type PrivateEndpointServiceConnectionStatus 

type PrivateEndpointServiceConnectionStatus = original.PrivateEndpointServiceConnectionStatus
const (
	PrivateEndpointServiceConnectionStatusApproved PrivateEndpointServiceConnectionStatus = original.PrivateEndpointServiceConnectionStatusApproved
	PrivateEndpointServiceConnectionStatusPending  PrivateEndpointServiceConnectionStatus = original.PrivateEndpointServiceConnectionStatusPending
	PrivateEndpointServiceConnectionStatusRejected PrivateEndpointServiceConnectionStatus = original.PrivateEndpointServiceConnectionStatusRejected
)

func PossiblePrivateEndpointServiceConnectionStatusValues 

func PossiblePrivateEndpointServiceConnectionStatusValues() []PrivateEndpointServiceConnectionStatus

type PrivateLinkResource 

type PrivateLinkResource = original.PrivateLinkResource

type PrivateLinkResourceListResult 

type PrivateLinkResourceListResult = original.PrivateLinkResourceListResult

type PrivateLinkResourceProperties 

type PrivateLinkResourceProperties = original.PrivateLinkResourceProperties

type PrivateLinkServiceConnectionState 

type PrivateLinkServiceConnectionState = original.PrivateLinkServiceConnectionState

type ProductAPIClient 

type ProductAPIClient = original.ProductAPIClient

func NewProductAPIClient 

func NewProductAPIClient(subscriptionID string) ProductAPIClient

func NewProductAPIClientWithBaseURI 

func NewProductAPIClientWithBaseURI(baseURI string, subscriptionID string) ProductAPIClient

type ProductClient 

type ProductClient = original.ProductClient

func NewProductClient 

func NewProductClient(subscriptionID string) ProductClient

func NewProductClientWithBaseURI 

func NewProductClientWithBaseURI(baseURI string, subscriptionID string) ProductClient

type ProductCollection 

type ProductCollection = original.ProductCollection

type ProductCollectionIterator 

type ProductCollectionIterator = original.ProductCollectionIterator

func NewProductCollectionIterator 

func NewProductCollectionIterator(page ProductCollectionPage) ProductCollectionIterator

type ProductCollectionPage 

type ProductCollectionPage = original.ProductCollectionPage

func NewProductCollectionPage 

func NewProductCollectionPage(cur ProductCollection, getNextPage func(context.Context, ProductCollection) (ProductCollection, error)) ProductCollectionPage

type ProductContract 

type ProductContract = original.ProductContract

type ProductContractProperties 

type ProductContractProperties = original.ProductContractProperties

type ProductEntityBaseParameters 

type ProductEntityBaseParameters = original.ProductEntityBaseParameters

type ProductGroupClient 

type ProductGroupClient = original.ProductGroupClient

func NewProductGroupClient 

func NewProductGroupClient(subscriptionID string) ProductGroupClient

func NewProductGroupClientWithBaseURI 

func NewProductGroupClientWithBaseURI(baseURI string, subscriptionID string) ProductGroupClient

type ProductPolicyClient 

type ProductPolicyClient = original.ProductPolicyClient

func NewProductPolicyClient 

func NewProductPolicyClient(subscriptionID string) ProductPolicyClient

func NewProductPolicyClientWithBaseURI 

func NewProductPolicyClientWithBaseURI(baseURI string, subscriptionID string) ProductPolicyClient

type ProductState 

type ProductState = original.ProductState
const (
	ProductStateNotPublished ProductState = original.ProductStateNotPublished
	ProductStatePublished    ProductState = original.ProductStatePublished
)

func PossibleProductStateValues 

func PossibleProductStateValues() []ProductState

type ProductSubscriptionsClient 

type ProductSubscriptionsClient = original.ProductSubscriptionsClient

func NewProductSubscriptionsClient 

func NewProductSubscriptionsClient(subscriptionID string) ProductSubscriptionsClient

func NewProductSubscriptionsClientWithBaseURI 

func NewProductSubscriptionsClientWithBaseURI(baseURI string, subscriptionID string) ProductSubscriptionsClient

type ProductTagResourceContractProperties 

type ProductTagResourceContractProperties = original.ProductTagResourceContractProperties

type ProductUpdateParameters 

type ProductUpdateParameters = original.ProductUpdateParameters

type ProductUpdateProperties 

type ProductUpdateProperties = original.ProductUpdateProperties

type Protocol 

type Protocol = original.Protocol
const (
	ProtocolHTTP  Protocol = original.ProtocolHTTP
	ProtocolHTTPS Protocol = original.ProtocolHTTPS
	ProtocolWs    Protocol = original.ProtocolWs
	ProtocolWss   Protocol = original.ProtocolWss
)

func PossibleProtocolValues 

func PossibleProtocolValues() []Protocol

type ProvisioningState 

type ProvisioningState = original.ProvisioningState
const (
	ProvisioningStateCreated ProvisioningState = original.ProvisioningStateCreated
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

type ProxyResource 

type ProxyResource = original.ProxyResource

type PublicNetworkAccess 

type PublicNetworkAccess = original.PublicNetworkAccess
const (
	PublicNetworkAccessDisabled PublicNetworkAccess = original.PublicNetworkAccessDisabled
	PublicNetworkAccessEnabled  PublicNetworkAccess = original.PublicNetworkAccessEnabled
)

func PossiblePublicNetworkAccessValues 

func PossiblePublicNetworkAccessValues() []PublicNetworkAccess

type QuotaByCounterKeysClient 

type QuotaByCounterKeysClient = original.QuotaByCounterKeysClient

func NewQuotaByCounterKeysClient 

func NewQuotaByCounterKeysClient(subscriptionID string) QuotaByCounterKeysClient

func NewQuotaByCounterKeysClientWithBaseURI 

func NewQuotaByCounterKeysClientWithBaseURI(baseURI string, subscriptionID string) QuotaByCounterKeysClient

type QuotaByPeriodKeysClient 

type QuotaByPeriodKeysClient = original.QuotaByPeriodKeysClient

func NewQuotaByPeriodKeysClient 

func NewQuotaByPeriodKeysClient(subscriptionID string) QuotaByPeriodKeysClient

func NewQuotaByPeriodKeysClientWithBaseURI 

func NewQuotaByPeriodKeysClientWithBaseURI(baseURI string, subscriptionID string) QuotaByPeriodKeysClient

type QuotaCounterCollection 

type QuotaCounterCollection = original.QuotaCounterCollection

type QuotaCounterContract 

type QuotaCounterContract = original.QuotaCounterContract

type QuotaCounterValueContract 

type QuotaCounterValueContract = original.QuotaCounterValueContract

type QuotaCounterValueContractProperties 

type QuotaCounterValueContractProperties = original.QuotaCounterValueContractProperties

type QuotaCounterValueUpdateContract 

type QuotaCounterValueUpdateContract = original.QuotaCounterValueUpdateContract

type RecipientEmailCollection 

type RecipientEmailCollection = original.RecipientEmailCollection

type RecipientEmailContract 

type RecipientEmailContract = original.RecipientEmailContract

type RecipientEmailContractProperties 

type RecipientEmailContractProperties = original.RecipientEmailContractProperties

type RecipientUserCollection 

type RecipientUserCollection = original.RecipientUserCollection

type RecipientUserContract 

type RecipientUserContract = original.RecipientUserContract

type RecipientUsersContractProperties 

type RecipientUsersContractProperties = original.RecipientUsersContractProperties

type RecipientsContractProperties 

type RecipientsContractProperties = original.RecipientsContractProperties

type RegionClient 

type RegionClient = original.RegionClient

func NewRegionClient 

func NewRegionClient(subscriptionID string) RegionClient

func NewRegionClientWithBaseURI 

func NewRegionClientWithBaseURI(baseURI string, subscriptionID string) RegionClient

type RegionContract 

type RegionContract = original.RegionContract

type RegionListResult 

type RegionListResult = original.RegionListResult

type RegionListResultIterator 

type RegionListResultIterator = original.RegionListResultIterator

func NewRegionListResultIterator 

func NewRegionListResultIterator(page RegionListResultPage) RegionListResultIterator

type RegionListResultPage 

type RegionListResultPage = original.RegionListResultPage

func NewRegionListResultPage 

func NewRegionListResultPage(cur RegionListResult, getNextPage func(context.Context, RegionListResult) (RegionListResult, error)) RegionListResultPage

type RegistrationDelegationSettingsProperties 

type RegistrationDelegationSettingsProperties = original.RegistrationDelegationSettingsProperties

type RemotePrivateEndpointConnectionWrapper 

type RemotePrivateEndpointConnectionWrapper = original.RemotePrivateEndpointConnectionWrapper

type ReportCollection 

type ReportCollection = original.ReportCollection

type ReportCollectionIterator 

type ReportCollectionIterator = original.ReportCollectionIterator

func NewReportCollectionIterator 

func NewReportCollectionIterator(page ReportCollectionPage) ReportCollectionIterator

type ReportCollectionPage 

type ReportCollectionPage = original.ReportCollectionPage

func NewReportCollectionPage 

func NewReportCollectionPage(cur ReportCollection, getNextPage func(context.Context, ReportCollection) (ReportCollection, error)) ReportCollectionPage

type ReportRecordContract 

type ReportRecordContract = original.ReportRecordContract

type ReportsClient 

type ReportsClient = original.ReportsClient

func NewReportsClient 

func NewReportsClient(subscriptionID string) ReportsClient

func NewReportsClientWithBaseURI 

func NewReportsClientWithBaseURI(baseURI string, subscriptionID string) ReportsClient

type RepresentationContract 

type RepresentationContract = original.RepresentationContract

type RequestContract 

type RequestContract = original.RequestContract

type RequestReportCollection 

type RequestReportCollection = original.RequestReportCollection

type RequestReportRecordContract 

type RequestReportRecordContract = original.RequestReportRecordContract

type Resource 

type Resource = original.Resource

type ResourceLocationDataContract 

type ResourceLocationDataContract = original.ResourceLocationDataContract

type ResourceSku 

type ResourceSku = original.ResourceSku

type ResourceSkuCapacity 

type ResourceSkuCapacity = original.ResourceSkuCapacity

type ResourceSkuCapacityScaleType 

type ResourceSkuCapacityScaleType = original.ResourceSkuCapacityScaleType
const (
	ResourceSkuCapacityScaleTypeAutomatic ResourceSkuCapacityScaleType = original.ResourceSkuCapacityScaleTypeAutomatic
	ResourceSkuCapacityScaleTypeManual    ResourceSkuCapacityScaleType = original.ResourceSkuCapacityScaleTypeManual
	ResourceSkuCapacityScaleTypeNone      ResourceSkuCapacityScaleType = original.ResourceSkuCapacityScaleTypeNone
)

func PossibleResourceSkuCapacityScaleTypeValues 

func PossibleResourceSkuCapacityScaleTypeValues() []ResourceSkuCapacityScaleType

type ResourceSkuResult 

type ResourceSkuResult = original.ResourceSkuResult

type ResourceSkuResults 

type ResourceSkuResults = original.ResourceSkuResults

type ResourceSkuResultsIterator 

type ResourceSkuResultsIterator = original.ResourceSkuResultsIterator

func NewResourceSkuResultsIterator 

func NewResourceSkuResultsIterator(page ResourceSkuResultsPage) ResourceSkuResultsIterator

type ResourceSkuResultsPage 

type ResourceSkuResultsPage = original.ResourceSkuResultsPage

func NewResourceSkuResultsPage 

func NewResourceSkuResultsPage(cur ResourceSkuResults, getNextPage func(context.Context, ResourceSkuResults) (ResourceSkuResults, error)) ResourceSkuResultsPage

type ResponseContract 

type ResponseContract = original.ResponseContract

type SamplingSettings 

type SamplingSettings = original.SamplingSettings

type SamplingType 

type SamplingType = original.SamplingType
const (
	SamplingTypeFixed SamplingType = original.SamplingTypeFixed
)

func PossibleSamplingTypeValues 

func PossibleSamplingTypeValues() []SamplingType

type SaveConfigurationParameter 

type SaveConfigurationParameter = original.SaveConfigurationParameter

type SaveConfigurationParameterProperties 

type SaveConfigurationParameterProperties = original.SaveConfigurationParameterProperties

type SchemaCollection 

type SchemaCollection = original.SchemaCollection

type SchemaCollectionIterator 

type SchemaCollectionIterator = original.SchemaCollectionIterator

func NewSchemaCollectionIterator 

func NewSchemaCollectionIterator(page SchemaCollectionPage) SchemaCollectionIterator

type SchemaCollectionPage 

type SchemaCollectionPage = original.SchemaCollectionPage

func NewSchemaCollectionPage 

func NewSchemaCollectionPage(cur SchemaCollection, getNextPage func(context.Context, SchemaCollection) (SchemaCollection, error)) SchemaCollectionPage

type SchemaContract 

type SchemaContract = original.SchemaContract

type SchemaContractProperties 

type SchemaContractProperties = original.SchemaContractProperties

type SchemaDocumentProperties 

type SchemaDocumentProperties = original.SchemaDocumentProperties

type ServiceApplyNetworkConfigurationParameters 

type ServiceApplyNetworkConfigurationParameters = original.ServiceApplyNetworkConfigurationParameters

type ServiceApplyNetworkConfigurationUpdatesFuture 

type ServiceApplyNetworkConfigurationUpdatesFuture = original.ServiceApplyNetworkConfigurationUpdatesFuture

type ServiceBackupFuture 

type ServiceBackupFuture = original.ServiceBackupFuture

type ServiceBackupRestoreParameters 

type ServiceBackupRestoreParameters = original.ServiceBackupRestoreParameters

type ServiceBaseProperties 

type ServiceBaseProperties = original.ServiceBaseProperties

type ServiceCheckNameAvailabilityParameters 

type ServiceCheckNameAvailabilityParameters = original.ServiceCheckNameAvailabilityParameters

type ServiceClient 

type ServiceClient = original.ServiceClient

func NewServiceClient 

func NewServiceClient(subscriptionID string) ServiceClient

func NewServiceClientWithBaseURI 

func NewServiceClientWithBaseURI(baseURI string, subscriptionID string) ServiceClient

type ServiceCreateOrUpdateFuture 

type ServiceCreateOrUpdateFuture = original.ServiceCreateOrUpdateFuture

type ServiceDeleteFuture 

type ServiceDeleteFuture = original.ServiceDeleteFuture

type ServiceGetDomainOwnershipIdentifierResult 

type ServiceGetDomainOwnershipIdentifierResult = original.ServiceGetDomainOwnershipIdentifierResult

type ServiceGetSsoTokenResult 

type ServiceGetSsoTokenResult = original.ServiceGetSsoTokenResult

type ServiceIdentity 

type ServiceIdentity = original.ServiceIdentity

type ServiceListResult 

type ServiceListResult = original.ServiceListResult

type ServiceListResultIterator 

type ServiceListResultIterator = original.ServiceListResultIterator

func NewServiceListResultIterator 

func NewServiceListResultIterator(page ServiceListResultPage) ServiceListResultIterator

type ServiceListResultPage 

type ServiceListResultPage = original.ServiceListResultPage

func NewServiceListResultPage 

func NewServiceListResultPage(cur ServiceListResult, getNextPage func(context.Context, ServiceListResult) (ServiceListResult, error)) ServiceListResultPage

type ServiceNameAvailabilityResult 

type ServiceNameAvailabilityResult = original.ServiceNameAvailabilityResult

type ServiceProperties 

type ServiceProperties = original.ServiceProperties

type ServiceResource 

type ServiceResource = original.ServiceResource

type ServiceRestoreFuture 

type ServiceRestoreFuture = original.ServiceRestoreFuture

type ServiceSkuProperties 

type ServiceSkuProperties = original.ServiceSkuProperties

type ServiceSkusClient 

type ServiceSkusClient = original.ServiceSkusClient

func NewServiceSkusClient 

func NewServiceSkusClient(subscriptionID string) ServiceSkusClient

func NewServiceSkusClientWithBaseURI 

func NewServiceSkusClientWithBaseURI(baseURI string, subscriptionID string) ServiceSkusClient

type ServiceUpdateFuture 

type ServiceUpdateFuture = original.ServiceUpdateFuture

type ServiceUpdateParameters 

type ServiceUpdateParameters = original.ServiceUpdateParameters

type ServiceUpdateProperties 

type ServiceUpdateProperties = original.ServiceUpdateProperties

type Severity 

type Severity = original.Severity
const (
	SeverityError   Severity = original.SeverityError
	SeverityWarning Severity = original.SeverityWarning
)

func PossibleSeverityValues 

func PossibleSeverityValues() []Severity

type SignInSettingsClient 

type SignInSettingsClient = original.SignInSettingsClient

func NewSignInSettingsClient 

func NewSignInSettingsClient(subscriptionID string) SignInSettingsClient

func NewSignInSettingsClientWithBaseURI 

func NewSignInSettingsClientWithBaseURI(baseURI string, subscriptionID string) SignInSettingsClient

type SignUpSettingsClient 

type SignUpSettingsClient = original.SignUpSettingsClient

func NewSignUpSettingsClient 

func NewSignUpSettingsClient(subscriptionID string) SignUpSettingsClient

func NewSignUpSettingsClientWithBaseURI 

func NewSignUpSettingsClientWithBaseURI(baseURI string, subscriptionID string) SignUpSettingsClient

type Sku 

type Sku = original.Sku

type SkuCapabilities 

type SkuCapabilities = original.SkuCapabilities

type SkuCapacity 

type SkuCapacity = original.SkuCapacity

type SkuCapacityScaleType 

type SkuCapacityScaleType = original.SkuCapacityScaleType
const (
	SkuCapacityScaleTypeAutomatic SkuCapacityScaleType = original.SkuCapacityScaleTypeAutomatic
	SkuCapacityScaleTypeManual    SkuCapacityScaleType = original.SkuCapacityScaleTypeManual
	SkuCapacityScaleTypeNone      SkuCapacityScaleType = original.SkuCapacityScaleTypeNone
)

func PossibleSkuCapacityScaleTypeValues 

func PossibleSkuCapacityScaleTypeValues() []SkuCapacityScaleType

type SkuCosts 

type SkuCosts = original.SkuCosts

type SkuLocationInfo 

type SkuLocationInfo = original.SkuLocationInfo

type SkuRestrictionInfo 

type SkuRestrictionInfo = original.SkuRestrictionInfo

type SkuRestrictions 

type SkuRestrictions = original.SkuRestrictions

type SkuRestrictionsReasonCode 

type SkuRestrictionsReasonCode = original.SkuRestrictionsReasonCode
const (
	SkuRestrictionsReasonCodeNotAvailableForSubscription SkuRestrictionsReasonCode = original.SkuRestrictionsReasonCodeNotAvailableForSubscription
	SkuRestrictionsReasonCodeQuotaID                     SkuRestrictionsReasonCode = original.SkuRestrictionsReasonCodeQuotaID
)

func PossibleSkuRestrictionsReasonCodeValues 

func PossibleSkuRestrictionsReasonCodeValues() []SkuRestrictionsReasonCode

type SkuRestrictionsType 

type SkuRestrictionsType = original.SkuRestrictionsType
const (
	SkuRestrictionsTypeLocation SkuRestrictionsType = original.SkuRestrictionsTypeLocation
	SkuRestrictionsTypeZone     SkuRestrictionsType = original.SkuRestrictionsTypeZone
)

func PossibleSkuRestrictionsTypeValues 

func PossibleSkuRestrictionsTypeValues() []SkuRestrictionsType

type SkuType 

type SkuType = original.SkuType
const (
	SkuTypeBasic       SkuType = original.SkuTypeBasic
	SkuTypeConsumption SkuType = original.SkuTypeConsumption
	SkuTypeDeveloper   SkuType = original.SkuTypeDeveloper
	SkuTypeIsolated    SkuType = original.SkuTypeIsolated
	SkuTypePremium     SkuType = original.SkuTypePremium
	SkuTypeStandard    SkuType = original.SkuTypeStandard
)

func PossibleSkuTypeValues 

func PossibleSkuTypeValues() []SkuType

type SkuZoneDetails 

type SkuZoneDetails = original.SkuZoneDetails

type SkusClient 

type SkusClient = original.SkusClient

func NewSkusClient 

func NewSkusClient(subscriptionID string) SkusClient

func NewSkusClientWithBaseURI 

func NewSkusClientWithBaseURI(baseURI string, subscriptionID string) SkusClient

type SkusResult 

type SkusResult = original.SkusResult

type SkusResultIterator 

type SkusResultIterator = original.SkusResultIterator

func NewSkusResultIterator 

func NewSkusResultIterator(page SkusResultPage) SkusResultIterator

type SkusResultPage 

type SkusResultPage = original.SkusResultPage

func NewSkusResultPage 

func NewSkusResultPage(cur SkusResult, getNextPage func(context.Context, SkusResult) (SkusResult, error)) SkusResultPage

type SoapAPIType 

type SoapAPIType = original.SoapAPIType
const (
	SoapAPITypeGraphQL         SoapAPIType = original.SoapAPITypeGraphQL
	SoapAPITypeSoapPassThrough SoapAPIType = original.SoapAPITypeSoapPassThrough
	SoapAPITypeSoapToRest      SoapAPIType = original.SoapAPITypeSoapToRest
	SoapAPITypeWebSocket       SoapAPIType = original.SoapAPITypeWebSocket
)

func PossibleSoapAPITypeValues 

func PossibleSoapAPITypeValues() []SoapAPIType

type State 

type State = original.State
const (
	StateClosed   State = original.StateClosed
	StateOpen     State = original.StateOpen
	StateProposed State = original.StateProposed
	StateRemoved  State = original.StateRemoved
	StateResolved State = original.StateResolved
)

func PossibleStateValues 

func PossibleStateValues() []State

type StoreName 

type StoreName = original.StoreName
const (
	StoreNameCertificateAuthority StoreName = original.StoreNameCertificateAuthority
	StoreNameRoot                 StoreName = original.StoreNameRoot
)

func PossibleStoreNameValues 

func PossibleStoreNameValues() []StoreName

type SubscriptionClient 

type SubscriptionClient = original.SubscriptionClient

func NewSubscriptionClient 

func NewSubscriptionClient(subscriptionID string) SubscriptionClient

func NewSubscriptionClientWithBaseURI 

func NewSubscriptionClientWithBaseURI(baseURI string, subscriptionID string) SubscriptionClient

type SubscriptionCollection 

type SubscriptionCollection = original.SubscriptionCollection

type SubscriptionCollectionIterator 

type SubscriptionCollectionIterator = original.SubscriptionCollectionIterator

func NewSubscriptionCollectionIterator 

func NewSubscriptionCollectionIterator(page SubscriptionCollectionPage) SubscriptionCollectionIterator

type SubscriptionCollectionPage 

type SubscriptionCollectionPage = original.SubscriptionCollectionPage

func NewSubscriptionCollectionPage 

func NewSubscriptionCollectionPage(cur SubscriptionCollection, getNextPage func(context.Context, SubscriptionCollection) (SubscriptionCollection, error)) SubscriptionCollectionPage

type SubscriptionContract 

type SubscriptionContract = original.SubscriptionContract

type SubscriptionContractProperties 

type SubscriptionContractProperties = original.SubscriptionContractProperties

type SubscriptionCreateParameterProperties 

type SubscriptionCreateParameterProperties = original.SubscriptionCreateParameterProperties

type SubscriptionCreateParameters 

type SubscriptionCreateParameters = original.SubscriptionCreateParameters

type SubscriptionKeyParameterNamesContract 

type SubscriptionKeyParameterNamesContract = original.SubscriptionKeyParameterNamesContract

type SubscriptionKeysContract 

type SubscriptionKeysContract = original.SubscriptionKeysContract

type SubscriptionState 

type SubscriptionState = original.SubscriptionState
const (
	SubscriptionStateActive    SubscriptionState = original.SubscriptionStateActive
	SubscriptionStateCancelled SubscriptionState = original.SubscriptionStateCancelled
	SubscriptionStateExpired   SubscriptionState = original.SubscriptionStateExpired
	SubscriptionStateRejected  SubscriptionState = original.SubscriptionStateRejected
	SubscriptionStateSubmitted SubscriptionState = original.SubscriptionStateSubmitted
	SubscriptionStateSuspended SubscriptionState = original.SubscriptionStateSuspended
)

func PossibleSubscriptionStateValues 

func PossibleSubscriptionStateValues() []SubscriptionState

type SubscriptionUpdateParameterProperties 

type SubscriptionUpdateParameterProperties = original.SubscriptionUpdateParameterProperties

type SubscriptionUpdateParameters 

type SubscriptionUpdateParameters = original.SubscriptionUpdateParameters

type SubscriptionsDelegationSettingsProperties 

type SubscriptionsDelegationSettingsProperties = original.SubscriptionsDelegationSettingsProperties

type SystemData 

type SystemData = original.SystemData

type TagClient 

type TagClient = original.TagClient

func NewTagClient 

func NewTagClient(subscriptionID string) TagClient

func NewTagClientWithBaseURI 

func NewTagClientWithBaseURI(baseURI string, subscriptionID string) TagClient

type TagCollection 

type TagCollection = original.TagCollection

type TagCollectionIterator 

type TagCollectionIterator = original.TagCollectionIterator

func NewTagCollectionIterator 

func NewTagCollectionIterator(page TagCollectionPage) TagCollectionIterator

type TagCollectionPage 

type TagCollectionPage = original.TagCollectionPage

func NewTagCollectionPage 

func NewTagCollectionPage(cur TagCollection, getNextPage func(context.Context, TagCollection) (TagCollection, error)) TagCollectionPage

type TagContract 

type TagContract = original.TagContract

type TagContractProperties 

type TagContractProperties = original.TagContractProperties

type TagCreateUpdateParameters 

type TagCreateUpdateParameters = original.TagCreateUpdateParameters

type TagDescriptionBaseProperties 

type TagDescriptionBaseProperties = original.TagDescriptionBaseProperties

type TagDescriptionCollection 

type TagDescriptionCollection = original.TagDescriptionCollection

type TagDescriptionCollectionIterator 

type TagDescriptionCollectionIterator = original.TagDescriptionCollectionIterator

func NewTagDescriptionCollectionIterator 

func NewTagDescriptionCollectionIterator(page TagDescriptionCollectionPage) TagDescriptionCollectionIterator

type TagDescriptionCollectionPage 

type TagDescriptionCollectionPage = original.TagDescriptionCollectionPage

func NewTagDescriptionCollectionPage 

func NewTagDescriptionCollectionPage(cur TagDescriptionCollection, getNextPage func(context.Context, TagDescriptionCollection) (TagDescriptionCollection, error)) TagDescriptionCollectionPage

type TagDescriptionContract 

type TagDescriptionContract = original.TagDescriptionContract

type TagDescriptionContractProperties 

type TagDescriptionContractProperties = original.TagDescriptionContractProperties

type TagDescriptionCreateParameters 

type TagDescriptionCreateParameters = original.TagDescriptionCreateParameters

type TagResourceClient 

type TagResourceClient = original.TagResourceClient

func NewTagResourceClient 

func NewTagResourceClient(subscriptionID string) TagResourceClient

func NewTagResourceClientWithBaseURI 

func NewTagResourceClientWithBaseURI(baseURI string, subscriptionID string) TagResourceClient

type TagResourceCollection 

type TagResourceCollection = original.TagResourceCollection

type TagResourceCollectionIterator 

type TagResourceCollectionIterator = original.TagResourceCollectionIterator

func NewTagResourceCollectionIterator 

func NewTagResourceCollectionIterator(page TagResourceCollectionPage) TagResourceCollectionIterator

type TagResourceCollectionPage 

type TagResourceCollectionPage = original.TagResourceCollectionPage

func NewTagResourceCollectionPage 

func NewTagResourceCollectionPage(cur TagResourceCollection, getNextPage func(context.Context, TagResourceCollection) (TagResourceCollection, error)) TagResourceCollectionPage

type TagResourceContract 

type TagResourceContract = original.TagResourceContract

type TagTagResourceContractProperties 

type TagTagResourceContractProperties = original.TagTagResourceContractProperties

type TemplateName 

type TemplateName = original.TemplateName
const (
	TemplateNameAccountClosedDeveloper                            TemplateName = original.TemplateNameAccountClosedDeveloper
	TemplateNameApplicationApprovedNotificationMessage            TemplateName = original.TemplateNameApplicationApprovedNotificationMessage
	TemplateNameConfirmSignUpIdentityDefault                      TemplateName = original.TemplateNameConfirmSignUpIdentityDefault
	TemplateNameEmailChangeIdentityDefault                        TemplateName = original.TemplateNameEmailChangeIdentityDefault
	TemplateNameInviteUserNotificationMessage                     TemplateName = original.TemplateNameInviteUserNotificationMessage
	TemplateNameNewCommentNotificationMessage                     TemplateName = original.TemplateNameNewCommentNotificationMessage
	TemplateNameNewDeveloperNotificationMessage                   TemplateName = original.TemplateNameNewDeveloperNotificationMessage
	TemplateNameNewIssueNotificationMessage                       TemplateName = original.TemplateNameNewIssueNotificationMessage
	TemplateNamePasswordResetByAdminNotificationMessage           TemplateName = original.TemplateNamePasswordResetByAdminNotificationMessage
	TemplateNamePasswordResetIdentityDefault                      TemplateName = original.TemplateNamePasswordResetIdentityDefault
	TemplateNamePurchaseDeveloperNotificationMessage              TemplateName = original.TemplateNamePurchaseDeveloperNotificationMessage
	TemplateNameQuotaLimitApproachingDeveloperNotificationMessage TemplateName = original.TemplateNameQuotaLimitApproachingDeveloperNotificationMessage
	TemplateNameRejectDeveloperNotificationMessage                TemplateName = original.TemplateNameRejectDeveloperNotificationMessage
	TemplateNameRequestDeveloperNotificationMessage               TemplateName = original.TemplateNameRequestDeveloperNotificationMessage
)

func PossibleTemplateNameValues 

func PossibleTemplateNameValues() []TemplateName

type TenantAccessClient 

type TenantAccessClient = original.TenantAccessClient

func NewTenantAccessClient 

func NewTenantAccessClient(subscriptionID string) TenantAccessClient

func NewTenantAccessClientWithBaseURI 

func NewTenantAccessClientWithBaseURI(baseURI string, subscriptionID string) TenantAccessClient

type TenantAccessGitClient 

type TenantAccessGitClient = original.TenantAccessGitClient

func NewTenantAccessGitClient 

func NewTenantAccessGitClient(subscriptionID string) TenantAccessGitClient

func NewTenantAccessGitClientWithBaseURI 

func NewTenantAccessGitClientWithBaseURI(baseURI string, subscriptionID string) TenantAccessGitClient

type TenantConfigurationClient 

type TenantConfigurationClient = original.TenantConfigurationClient

func NewTenantConfigurationClient 

func NewTenantConfigurationClient(subscriptionID string) TenantConfigurationClient

func NewTenantConfigurationClientWithBaseURI 

func NewTenantConfigurationClientWithBaseURI(baseURI string, subscriptionID string) TenantConfigurationClient

type TenantConfigurationDeployFuture 

type TenantConfigurationDeployFuture = original.TenantConfigurationDeployFuture

type TenantConfigurationSaveFuture 

type TenantConfigurationSaveFuture = original.TenantConfigurationSaveFuture

type TenantConfigurationSyncStateContract 

type TenantConfigurationSyncStateContract = original.TenantConfigurationSyncStateContract

type TenantConfigurationSyncStateContractProperties 

type TenantConfigurationSyncStateContractProperties = original.TenantConfigurationSyncStateContractProperties

type TenantConfigurationValidateFuture 

type TenantConfigurationValidateFuture = original.TenantConfigurationValidateFuture

type TenantSettingsClient 

type TenantSettingsClient = original.TenantSettingsClient

func NewTenantSettingsClient 

func NewTenantSettingsClient(subscriptionID string) TenantSettingsClient

func NewTenantSettingsClientWithBaseURI 

func NewTenantSettingsClientWithBaseURI(baseURI string, subscriptionID string) TenantSettingsClient

type TenantSettingsCollection 

type TenantSettingsCollection = original.TenantSettingsCollection

type TenantSettingsCollectionIterator 

type TenantSettingsCollectionIterator = original.TenantSettingsCollectionIterator

func NewTenantSettingsCollectionIterator 

func NewTenantSettingsCollectionIterator(page TenantSettingsCollectionPage) TenantSettingsCollectionIterator

type TenantSettingsCollectionPage 

type TenantSettingsCollectionPage = original.TenantSettingsCollectionPage

func NewTenantSettingsCollectionPage 

func NewTenantSettingsCollectionPage(cur TenantSettingsCollection, getNextPage func(context.Context, TenantSettingsCollection) (TenantSettingsCollection, error)) TenantSettingsCollectionPage

type TenantSettingsContract 

type TenantSettingsContract = original.TenantSettingsContract

type TenantSettingsContractProperties 

type TenantSettingsContractProperties = original.TenantSettingsContractProperties

type TermsOfServiceProperties 

type TermsOfServiceProperties = original.TermsOfServiceProperties

type TokenBodyParameterContract 

type TokenBodyParameterContract = original.TokenBodyParameterContract

type TrackedResource 

type TrackedResource = original.TrackedResource

type UserClient 

type UserClient = original.UserClient

func NewUserClient 

func NewUserClient(subscriptionID string) UserClient

func NewUserClientWithBaseURI 

func NewUserClientWithBaseURI(baseURI string, subscriptionID string) UserClient

type UserCollection 

type UserCollection = original.UserCollection

type UserCollectionIterator 

type UserCollectionIterator = original.UserCollectionIterator

func NewUserCollectionIterator 

func NewUserCollectionIterator(page UserCollectionPage) UserCollectionIterator

type UserCollectionPage 

type UserCollectionPage = original.UserCollectionPage

func NewUserCollectionPage 

func NewUserCollectionPage(cur UserCollection, getNextPage func(context.Context, UserCollection) (UserCollection, error)) UserCollectionPage

type UserConfirmationPasswordClient 

type UserConfirmationPasswordClient = original.UserConfirmationPasswordClient

func NewUserConfirmationPasswordClient 

func NewUserConfirmationPasswordClient(subscriptionID string) UserConfirmationPasswordClient

func NewUserConfirmationPasswordClientWithBaseURI 

func NewUserConfirmationPasswordClientWithBaseURI(baseURI string, subscriptionID string) UserConfirmationPasswordClient

type UserContract 

type UserContract = original.UserContract

type UserContractProperties 

type UserContractProperties = original.UserContractProperties

type UserCreateParameterProperties 

type UserCreateParameterProperties = original.UserCreateParameterProperties

type UserCreateParameters 

type UserCreateParameters = original.UserCreateParameters

type UserEntityBaseParameters 

type UserEntityBaseParameters = original.UserEntityBaseParameters

type UserGroupClient 

type UserGroupClient = original.UserGroupClient

func NewUserGroupClient 

func NewUserGroupClient(subscriptionID string) UserGroupClient

func NewUserGroupClientWithBaseURI 

func NewUserGroupClientWithBaseURI(baseURI string, subscriptionID string) UserGroupClient

type UserIdentitiesClient 

type UserIdentitiesClient = original.UserIdentitiesClient

func NewUserIdentitiesClient 

func NewUserIdentitiesClient(subscriptionID string) UserIdentitiesClient

func NewUserIdentitiesClientWithBaseURI 

func NewUserIdentitiesClientWithBaseURI(baseURI string, subscriptionID string) UserIdentitiesClient

type UserIdentityCollection 

type UserIdentityCollection = original.UserIdentityCollection

type UserIdentityCollectionIterator 

type UserIdentityCollectionIterator = original.UserIdentityCollectionIterator

func NewUserIdentityCollectionIterator 

func NewUserIdentityCollectionIterator(page UserIdentityCollectionPage) UserIdentityCollectionIterator

type UserIdentityCollectionPage 

type UserIdentityCollectionPage = original.UserIdentityCollectionPage

func NewUserIdentityCollectionPage 

func NewUserIdentityCollectionPage(cur UserIdentityCollection, getNextPage func(context.Context, UserIdentityCollection) (UserIdentityCollection, error)) UserIdentityCollectionPage

type UserIdentityContract 

type UserIdentityContract = original.UserIdentityContract

type UserIdentityProperties 

type UserIdentityProperties = original.UserIdentityProperties

type UserState 

type UserState = original.UserState
const (
	UserStateActive  UserState = original.UserStateActive
	UserStateBlocked UserState = original.UserStateBlocked
	UserStateDeleted UserState = original.UserStateDeleted
	UserStatePending UserState = original.UserStatePending
)

func PossibleUserStateValues 

func PossibleUserStateValues() []UserState

type UserSubscriptionClient 

type UserSubscriptionClient = original.UserSubscriptionClient

func NewUserSubscriptionClient 

func NewUserSubscriptionClient(subscriptionID string) UserSubscriptionClient

func NewUserSubscriptionClientWithBaseURI 

func NewUserSubscriptionClientWithBaseURI(baseURI string, subscriptionID string) UserSubscriptionClient

type UserTokenParameterProperties 

type UserTokenParameterProperties = original.UserTokenParameterProperties

type UserTokenParameters 

type UserTokenParameters = original.UserTokenParameters

type UserTokenResult 

type UserTokenResult = original.UserTokenResult

type UserUpdateParameters 

type UserUpdateParameters = original.UserUpdateParameters

type UserUpdateParametersProperties 

type UserUpdateParametersProperties = original.UserUpdateParametersProperties

type Verbosity 

type Verbosity = original.Verbosity
const (
	VerbosityError       Verbosity = original.VerbosityError
	VerbosityInformation Verbosity = original.VerbosityInformation
	VerbosityVerbose     Verbosity = original.VerbosityVerbose
)

func PossibleVerbosityValues 

func PossibleVerbosityValues() []Verbosity

type VersioningScheme 

type VersioningScheme = original.VersioningScheme
const (
	VersioningSchemeHeader  VersioningScheme = original.VersioningSchemeHeader
	VersioningSchemeQuery   VersioningScheme = original.VersioningSchemeQuery
	VersioningSchemeSegment VersioningScheme = original.VersioningSchemeSegment
)

func PossibleVersioningSchemeValues 

func PossibleVersioningSchemeValues() []VersioningScheme

type VersioningScheme1 

type VersioningScheme1 = original.VersioningScheme1
const (
	VersioningScheme1Header  VersioningScheme1 = original.VersioningScheme1Header
	VersioningScheme1Query   VersioningScheme1 = original.VersioningScheme1Query
	VersioningScheme1Segment VersioningScheme1 = original.VersioningScheme1Segment
)

func PossibleVersioningScheme1Values 

func PossibleVersioningScheme1Values() []VersioningScheme1

type VirtualNetworkConfiguration 

type VirtualNetworkConfiguration = original.VirtualNetworkConfiguration

type VirtualNetworkType 

type VirtualNetworkType = original.VirtualNetworkType
const (
	VirtualNetworkTypeExternal VirtualNetworkType = original.VirtualNetworkTypeExternal
	VirtualNetworkTypeInternal VirtualNetworkType = original.VirtualNetworkTypeInternal
	VirtualNetworkTypeNone     VirtualNetworkType = original.VirtualNetworkTypeNone
)

func PossibleVirtualNetworkTypeValues 

func PossibleVirtualNetworkTypeValues() []VirtualNetworkType

type X509CertificateName 

type X509CertificateName = original.X509CertificateName

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.