armservicelinker

package module
v2.0.0-beta.1 Latest Latest
Warning

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

 Go to latest Published: Mar 19, 2024 License: MIT Imports: 14 Imported by: 0

README

Azure Service Linker Module for Go

PkgGoDev

The armservicelinker module provides operations for working with Azure Service Linker.

Source code

Getting started

Prerequisites

  • an Azure subscription
  • Go 1.18 or above (You could download and install the latest version of Go from here. It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, you could refer this doc.)

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Service Linker module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/servicelinker/armservicelinker/v2

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Service Linker. The azidentity module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more.

cred, err := azidentity.NewDefaultAzureCredential(nil)

For more information on authentication, please see the documentation for azidentity at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity.

Client Factory

Azure Service Linker module consists of one or more clients. We provide a client factory which could be used to create any client in this module.

clientFactory, err := armservicelinker.NewClientFactory(<subscription ID>, cred, nil)

You can use ClientOptions in package github.com/Azure/azure-sdk-for-go/sdk/azcore/arm to set endpoint to connect with public and sovereign clouds as well as Azure Stack. For more information, please see the documentation for azcore at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore.

options := arm.ClientOptions {
    ClientOptions: azcore.ClientOptions {
        Cloud: cloud.AzureChina,
    },
}
clientFactory, err := armservicelinker.NewClientFactory(<subscription ID>, cred, &options)

Clients

A client groups a set of related APIs, providing access to its functionality. Create one or more clients to access the APIs you require using client factory.

client := clientFactory.()

Fakes

The fake package contains types used for constructing in-memory fake servers used in unit tests. This allows writing tests to cover various success/error conditions without the need for connecting to a live service.

Please see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes.

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Service Linker label.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessKeyInfoBase 

type AccessKeyInfoBase struct {
	// REQUIRED; The authentication type.
	AuthType *AuthType

	// Optional. Indicates how to configure authentication. If optInAllAuth, service linker configures authentication such as
	// enabling identity on source resource and granting RBAC roles. If optOutAllAuth,
	// opt out authentication setup. Default is optInAllAuth.
	AuthMode *AuthMode

	// Permissions of the accessKey. Read and Write are for Azure Cosmos DB and Azure App Configuration, Listen, Send and Manage
	// are for Azure Event Hub and Azure Service Bus.
	Permissions []*AccessKeyPermissions
}

AccessKeyInfoBase - The access key directly from target resource properties, which target service is Azure Resource, such as Microsoft.Storage

func (*AccessKeyInfoBase) GetAuthInfoBase 

func (a *AccessKeyInfoBase) GetAuthInfoBase() *AuthInfoBase

GetAuthInfoBase implements the AuthInfoBaseClassification interface for type AccessKeyInfoBase.

func (AccessKeyInfoBase) MarshalJSON 

func (a AccessKeyInfoBase) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AccessKeyInfoBase.

func (*AccessKeyInfoBase) UnmarshalJSON 

func (a *AccessKeyInfoBase) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AccessKeyInfoBase.

type AccessKeyPermissions 

type AccessKeyPermissions string
const (
	AccessKeyPermissionsListen AccessKeyPermissions = "Listen"
	AccessKeyPermissionsManage AccessKeyPermissions = "Manage"
	AccessKeyPermissionsRead   AccessKeyPermissions = "Read"
	AccessKeyPermissionsSend   AccessKeyPermissions = "Send"
	AccessKeyPermissionsWrite  AccessKeyPermissions = "Write"
)

func PossibleAccessKeyPermissionsValues 

func PossibleAccessKeyPermissionsValues() []AccessKeyPermissions

PossibleAccessKeyPermissionsValues returns the possible values for the AccessKeyPermissions const type.

type ActionType 

type ActionType string

ActionType - Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. 

const (
	ActionTypeEnable   ActionType = "enable"
	ActionTypeInternal ActionType = "Internal"
	ActionTypeOptOut   ActionType = "optOut"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type AllowType 

type AllowType string

AllowType - Whether to allow firewall rules. 

const (
	AllowTypeFalse AllowType = "false"
	AllowTypeTrue  AllowType = "true"
)

func PossibleAllowTypeValues 

func PossibleAllowTypeValues() []AllowType

PossibleAllowTypeValues returns the possible values for the AllowType const type.

type AuthInfoBase 

type AuthInfoBase struct {
	// REQUIRED; The authentication type.
	AuthType *AuthType

	// Optional. Indicates how to configure authentication. If optInAllAuth, service linker configures authentication such as
	// enabling identity on source resource and granting RBAC roles. If optOutAllAuth,
	// opt out authentication setup. Default is optInAllAuth.
	AuthMode *AuthMode
}

AuthInfoBase - The authentication info

func (*AuthInfoBase) GetAuthInfoBase 

func (a *AuthInfoBase) GetAuthInfoBase() *AuthInfoBase

GetAuthInfoBase implements the AuthInfoBaseClassification interface for type AuthInfoBase.

func (AuthInfoBase) MarshalJSON 

func (a AuthInfoBase) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AuthInfoBase.

func (*AuthInfoBase) UnmarshalJSON 

func (a *AuthInfoBase) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AuthInfoBase.

type AuthInfoBaseClassification 

type AuthInfoBaseClassification interface {
	// GetAuthInfoBase returns the AuthInfoBase content of the underlying type.
	GetAuthInfoBase() *AuthInfoBase
}

AuthInfoBaseClassification provides polymorphic access to related types. Call the interface's GetAuthInfoBase() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *AccessKeyInfoBase, *AuthInfoBase, *EasyAuthMicrosoftEntraIDAuthInfo, *SecretAuthInfo, *ServicePrincipalCertificateAuthInfo, - *ServicePrincipalSecretAuthInfo, *SystemAssignedIdentityAuthInfo, *UserAccountAuthInfo, *UserAssignedIdentityAuthInfo

type AuthMode 

type AuthMode string

AuthMode - Indicates how to apply the authentication configuration operations. 

const (
	// AuthModeOptInAllAuth - Default authentication configuration according to the authentication type.
	AuthModeOptInAllAuth AuthMode = "optInAllAuth"
	// AuthModeOptOutAllAuth - Skip all authentication configuration such as enabling managed identity and granting RBAC roles
	AuthModeOptOutAllAuth AuthMode = "optOutAllAuth"
)

func PossibleAuthModeValues 

func PossibleAuthModeValues() []AuthMode

PossibleAuthModeValues returns the possible values for the AuthMode const type.

type AuthType 

type AuthType string

AuthType - The authentication type. 

const (
	AuthTypeAccessKey                   AuthType = "accessKey"
	AuthTypeEasyAuthMicrosoftEntraID    AuthType = "easyAuthMicrosoftEntraID"
	AuthTypeSecret                      AuthType = "secret"
	AuthTypeServicePrincipalCertificate AuthType = "servicePrincipalCertificate"
	AuthTypeServicePrincipalSecret      AuthType = "servicePrincipalSecret"
	AuthTypeSystemAssignedIdentity      AuthType = "systemAssignedIdentity"
	AuthTypeUserAccount                 AuthType = "userAccount"
	AuthTypeUserAssignedIdentity        AuthType = "userAssignedIdentity"
)

func PossibleAuthTypeValues 

func PossibleAuthTypeValues() []AuthType

PossibleAuthTypeValues returns the possible values for the AuthType const type.

type AzureKeyVaultProperties 

type AzureKeyVaultProperties struct {
	// REQUIRED; The azure resource type.
	Type *AzureResourceType

	// True if connect via Kubernetes CSI Driver.
	ConnectAsKubernetesCsiDriver *bool
}

AzureKeyVaultProperties - The resource properties when type is Azure Key Vault

func (*AzureKeyVaultProperties) GetAzureResourcePropertiesBase 

func (a *AzureKeyVaultProperties) GetAzureResourcePropertiesBase() *AzureResourcePropertiesBase

GetAzureResourcePropertiesBase implements the AzureResourcePropertiesBaseClassification interface for type AzureKeyVaultProperties.

func (AzureKeyVaultProperties) MarshalJSON 

func (a AzureKeyVaultProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureKeyVaultProperties.

func (*AzureKeyVaultProperties) UnmarshalJSON 

func (a *AzureKeyVaultProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureKeyVaultProperties.

type AzureResource 

type AzureResource struct {
	// REQUIRED; The target service type.
	Type *TargetServiceType

	// The Id of azure resource.
	ID *string

	// The azure resource connection related properties.
	ResourceProperties AzureResourcePropertiesBaseClassification
}

AzureResource - The azure resource info when target service type is AzureResource

func (*AzureResource) GetTargetServiceBase 

func (a *AzureResource) GetTargetServiceBase() *TargetServiceBase

GetTargetServiceBase implements the TargetServiceBaseClassification interface for type AzureResource.

func (AzureResource) MarshalJSON 

func (a AzureResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureResource.

func (*AzureResource) UnmarshalJSON 

func (a *AzureResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureResource.

type AzureResourcePropertiesBase 

type AzureResourcePropertiesBase struct {
	// REQUIRED; The azure resource type.
	Type *AzureResourceType
}

AzureResourcePropertiesBase - The azure resource properties

func (*AzureResourcePropertiesBase) GetAzureResourcePropertiesBase 

func (a *AzureResourcePropertiesBase) GetAzureResourcePropertiesBase() *AzureResourcePropertiesBase

GetAzureResourcePropertiesBase implements the AzureResourcePropertiesBaseClassification interface for type AzureResourcePropertiesBase.

func (AzureResourcePropertiesBase) MarshalJSON 

func (a AzureResourcePropertiesBase) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureResourcePropertiesBase.

func (*AzureResourcePropertiesBase) UnmarshalJSON 

func (a *AzureResourcePropertiesBase) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureResourcePropertiesBase.

type AzureResourcePropertiesBaseClassification 

type AzureResourcePropertiesBaseClassification interface {
	// GetAzureResourcePropertiesBase returns the AzureResourcePropertiesBase content of the underlying type.
	GetAzureResourcePropertiesBase() *AzureResourcePropertiesBase
}

AzureResourcePropertiesBaseClassification provides polymorphic access to related types. Call the interface's GetAzureResourcePropertiesBase() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *AzureKeyVaultProperties, *AzureResourcePropertiesBase

type AzureResourceType 

type AzureResourceType string

AzureResourceType - The azure resource type. 

const (
	AzureResourceTypeKeyVault AzureResourceType = "KeyVault"
)

func PossibleAzureResourceTypeValues 

func PossibleAzureResourceTypeValues() []AzureResourceType

PossibleAzureResourceTypeValues returns the possible values for the AzureResourceType const type.

type BasicErrorDryrunPrerequisiteResult 

type BasicErrorDryrunPrerequisiteResult struct {
	// REQUIRED; The type of dryrun result.
	Type *DryrunPrerequisiteResultType

	// The error code.
	Code *string

	// The error message.
	Message *string
}

BasicErrorDryrunPrerequisiteResult - The represent of basic error

func (*BasicErrorDryrunPrerequisiteResult) GetDryrunPrerequisiteResult 

func (b *BasicErrorDryrunPrerequisiteResult) GetDryrunPrerequisiteResult() *DryrunPrerequisiteResult

GetDryrunPrerequisiteResult implements the DryrunPrerequisiteResultClassification interface for type BasicErrorDryrunPrerequisiteResult.

func (BasicErrorDryrunPrerequisiteResult) MarshalJSON 

func (b BasicErrorDryrunPrerequisiteResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BasicErrorDryrunPrerequisiteResult.

func (*BasicErrorDryrunPrerequisiteResult) UnmarshalJSON 

func (b *BasicErrorDryrunPrerequisiteResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BasicErrorDryrunPrerequisiteResult.

type ClientFactory 

type ClientFactory struct {
	// contains filtered or unexported fields
}

ClientFactory is a client factory used to create any client in this module. Don't use this type directly, use NewClientFactory instead.

func NewClientFactory 

func NewClientFactory(credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error)

NewClientFactory creates a new instance of ClientFactory with the specified values. The parameter values will be propagated to any client created from this factory.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewConfigurationNamesClient 

func (c *ClientFactory) NewConfigurationNamesClient() *ConfigurationNamesClient

NewConfigurationNamesClient creates a new instance of ConfigurationNamesClient.

func (*ClientFactory) NewConnectorClient 

func (c *ClientFactory) NewConnectorClient() *ConnectorClient

NewConnectorClient creates a new instance of ConnectorClient.

func (*ClientFactory) NewLinkerClient 

func (c *ClientFactory) NewLinkerClient() *LinkerClient

NewLinkerClient creates a new instance of LinkerClient.

func (*ClientFactory) NewLinkersClient 

func (c *ClientFactory) NewLinkersClient() *LinkersClient

NewLinkersClient creates a new instance of LinkersClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

type ClientType 

type ClientType string

ClientType - The application client type 

const (
	ClientTypeDapr            ClientType = "dapr"
	ClientTypeDjango          ClientType = "django"
	ClientTypeDotnet          ClientType = "dotnet"
	ClientTypeGo              ClientType = "go"
	ClientTypeJava            ClientType = "java"
	ClientTypeJmsSpringBoot   ClientType = "jms-springBoot"
	ClientTypeKafkaSpringBoot ClientType = "kafka-springBoot"
	ClientTypeNodejs          ClientType = "nodejs"
	ClientTypeNone            ClientType = "none"
	ClientTypePhp             ClientType = "php"
	ClientTypePython          ClientType = "python"
	ClientTypeRuby            ClientType = "ruby"
	ClientTypeSpringBoot      ClientType = "springBoot"
)

func PossibleClientTypeValues 

func PossibleClientTypeValues() []ClientType

PossibleClientTypeValues returns the possible values for the ClientType const type.

type ConfigurationInfo 

type ConfigurationInfo struct {
	// Optional, indicate whether to apply configurations on source application. If enable, generate configurations and applied
	// to the source application. Default is enable. If optOut, no configuration
	// change will be made on source.
	Action *ActionType

	// A dictionary of additional configurations to be added. Service will auto generate a set of basic configurations and this
	// property is to full fill more customized configurations
	AdditionalConfigurations map[string]*string

	// A dictionary of additional properties to be added in the end of connection string.
	AdditionalConnectionStringProperties map[string]*string

	// An option to store configuration into different place
	ConfigurationStore *ConfigurationStore

	// Optional. A dictionary of default key name and customized key name mapping. If not specified, default key name will be
	// used for generate configurations
	CustomizedKeys map[string]*string

	// Indicates some additional properties for dapr client type
	DaprProperties *DaprProperties

	// Indicates whether to clean up previous operation when Linker is updating or deleting
	DeleteOrUpdateBehavior *DeleteOrUpdateBehavior
}

ConfigurationInfo - The configuration information, used to generate configurations or save to applications

func (ConfigurationInfo) MarshalJSON 

func (c ConfigurationInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationInfo.

func (*ConfigurationInfo) UnmarshalJSON 

func (c *ConfigurationInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationInfo.

type ConfigurationName 

type ConfigurationName struct {
	// Description for the configuration name.
	Description *string

	// Represent the configuration is required or not
	Required *bool
	Value    *string
}

ConfigurationName - The configuration names.

func (ConfigurationName) MarshalJSON 

func (c ConfigurationName) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationName.

func (*ConfigurationName) UnmarshalJSON 

func (c *ConfigurationName) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationName.

type ConfigurationNameItem 

type ConfigurationNameItem struct {
	// The result detail.
	Properties *ConfigurationNames
}

func (ConfigurationNameItem) MarshalJSON 

func (c ConfigurationNameItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationNameItem.

func (*ConfigurationNameItem) UnmarshalJSON 

func (c *ConfigurationNameItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationNameItem.

type ConfigurationNameResult 

type ConfigurationNameResult struct {
	// Expected configuration names for each target service.
	Value []*ConfigurationNameItem

	// READ-ONLY; Link to next page of resources.
	NextLink *string
}

ConfigurationNameResult - Configuration Name list which will be set based on different target resource, client type, auth type.

func (ConfigurationNameResult) MarshalJSON 

func (c ConfigurationNameResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationNameResult.

func (*ConfigurationNameResult) UnmarshalJSON 

func (c *ConfigurationNameResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationNameResult.

type ConfigurationNames 

type ConfigurationNames struct {
	// The auth type.
	AuthType *AuthType

	// The client type for configuration names.
	ClientType *ClientType

	// Deprecated, please use #/definitions/DaprConfigurationList instead
	DaprProperties *DaprProperties

	// The configuration names to be set in compute service environment.
	Names []*ConfigurationName

	// Indicates where the secrets in configuration from. Used when secrets are from Keyvault.
	SecretType *SecretSourceType

	// The target service provider name and resource name.
	TargetService *string
}

ConfigurationNames - The configuration names which will be set based on specific target resource, client type, auth type.

func (ConfigurationNames) MarshalJSON 

func (c ConfigurationNames) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationNames.

func (*ConfigurationNames) UnmarshalJSON 

func (c *ConfigurationNames) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationNames.

type ConfigurationNamesClient 

type ConfigurationNamesClient struct {
	// contains filtered or unexported fields
}

ConfigurationNamesClient contains the methods for the ConfigurationNames group. Don't use this type directly, use NewConfigurationNamesClient() instead.

func NewConfigurationNamesClient 

func NewConfigurationNamesClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*ConfigurationNamesClient, error)

NewConfigurationNamesClient creates a new instance of ConfigurationNamesClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ConfigurationNamesClient) NewListPager 

func (client *ConfigurationNamesClient) NewListPager(options *ConfigurationNamesClientListOptions) *runtime.Pager[ConfigurationNamesClientListResponse]

NewListPager - Lists the configuration names generated by Service Connector for all target, client types, auth types.

Generated from API version 2023-04-01-preview

  • options - ConfigurationNamesClientListOptions contains the optional parameters for the ConfigurationNamesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/ConfigurationNamesList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewConfigurationNamesClient().NewListPager(&armservicelinker.ConfigurationNamesClientListOptions{Filter: nil,
	SkipToken: nil,
})
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ConfigurationNameResult = armservicelinker.ConfigurationNameResult{
	// 	Value: []*armservicelinker.ConfigurationNameItem{
	// 		{
	// 			Properties: &armservicelinker.ConfigurationNames{
	// 				AuthType: to.Ptr(armservicelinker.AuthTypeSystemAssignedIdentity),
	// 				ClientType: to.Ptr(armservicelinker.ClientTypeNone),
	// 				Names: []*armservicelinker.ConfigurationName{
	// 					{
	// 						Description: to.Ptr("App configuration endpoint"),
	// 						Value: to.Ptr("AZURE_APPCONFIGURATION_ENDPOINT"),
	// 					},
	// 					{
	// 						Description: to.Ptr("The scopes required for the token."),
	// 						Value: to.Ptr("AZURE_APPCONFIGURATION_SCOPE"),
	// 				}},
	// 				TargetService: to.Ptr("MICROSOFT.APPCONFIGURATION/CONFIGURATIONSTORES"),
	// 			},
	// 		},
	// 		{
	// 			Properties: &armservicelinker.ConfigurationNames{
	// 				AuthType: to.Ptr(armservicelinker.AuthTypeUserAssignedIdentity),
	// 				ClientType: to.Ptr(armservicelinker.ClientTypeNone),
	// 				Names: []*armservicelinker.ConfigurationName{
	// 					{
	// 						Description: to.Ptr("App configuration endpoint"),
	// 						Value: to.Ptr("AZURE_APPCONFIGURATION_ENDPOINT"),
	// 					},
	// 					{
	// 						Description: to.Ptr("The client(application) ID of the user identity."),
	// 						Value: to.Ptr("AZURE_APPCONFIGURATION_CLIENTID"),
	// 					},
	// 					{
	// 						Description: to.Ptr("The scopes required for getting token."),
	// 						Value: to.Ptr("AZURE_APPCONFIGURATION_SCOPE"),
	// 				}},
	// 				TargetService: to.Ptr("MICROSOFT.APPCONFIGURATION/CONFIGURATIONSTORES"),
	// 			},
	// 	}},
	// }
}

Output:

type ConfigurationNamesClientListOptions 

type ConfigurationNamesClientListOptions struct {
	// OData filter options.
	Filter *string

	// OData skipToken option for pagination.
	SkipToken *string
}

ConfigurationNamesClientListOptions contains the optional parameters for the ConfigurationNamesClient.NewListPager method.

type ConfigurationNamesClientListResponse 

type ConfigurationNamesClientListResponse struct {
	// Configuration Name list which will be set based on different target resource, client type, auth type.
	ConfigurationNameResult
}

ConfigurationNamesClientListResponse contains the response from method ConfigurationNamesClient.NewListPager.

type ConfigurationResult 

type ConfigurationResult struct {
	// The configuration properties for source resource.
	Configurations []*SourceConfiguration
}

ConfigurationResult - Configurations for source resource, include appSettings, connectionString and serviceBindings

func (ConfigurationResult) MarshalJSON 

func (c ConfigurationResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationResult.

func (*ConfigurationResult) UnmarshalJSON 

func (c *ConfigurationResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationResult.

type ConfigurationStore 

type ConfigurationStore struct {
	// The app configuration id to store configuration
	AppConfigurationID *string
}

ConfigurationStore - An option to store configuration into different place

func (ConfigurationStore) MarshalJSON 

func (c ConfigurationStore) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfigurationStore.

func (*ConfigurationStore) UnmarshalJSON 

func (c *ConfigurationStore) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfigurationStore.

type ConfluentBootstrapServer 

type ConfluentBootstrapServer struct {
	// REQUIRED; The target service type.
	Type *TargetServiceType

	// The endpoint of service.
	Endpoint *string
}

ConfluentBootstrapServer - The service properties when target service type is ConfluentBootstrapServer

func (*ConfluentBootstrapServer) GetTargetServiceBase 

func (c *ConfluentBootstrapServer) GetTargetServiceBase() *TargetServiceBase

GetTargetServiceBase implements the TargetServiceBaseClassification interface for type ConfluentBootstrapServer.

func (ConfluentBootstrapServer) MarshalJSON 

func (c ConfluentBootstrapServer) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfluentBootstrapServer.

func (*ConfluentBootstrapServer) UnmarshalJSON 

func (c *ConfluentBootstrapServer) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfluentBootstrapServer.

type ConfluentSchemaRegistry 

type ConfluentSchemaRegistry struct {
	// REQUIRED; The target service type.
	Type *TargetServiceType

	// The endpoint of service.
	Endpoint *string
}

ConfluentSchemaRegistry - The service properties when target service type is ConfluentSchemaRegistry

func (*ConfluentSchemaRegistry) GetTargetServiceBase 

func (c *ConfluentSchemaRegistry) GetTargetServiceBase() *TargetServiceBase

GetTargetServiceBase implements the TargetServiceBaseClassification interface for type ConfluentSchemaRegistry.

func (ConfluentSchemaRegistry) MarshalJSON 

func (c ConfluentSchemaRegistry) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConfluentSchemaRegistry.

func (*ConfluentSchemaRegistry) UnmarshalJSON 

func (c *ConfluentSchemaRegistry) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConfluentSchemaRegistry.

type ConnectorClient 

type ConnectorClient struct {
	// contains filtered or unexported fields
}

ConnectorClient contains the methods for the Connector group. Don't use this type directly, use NewConnectorClient() instead.

func NewConnectorClient 

func NewConnectorClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*ConnectorClient, error)

NewConnectorClient creates a new instance of ConnectorClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ConnectorClient) BeginCreateDryrun 

func (client *ConnectorClient) BeginCreateDryrun(ctx context.Context, subscriptionID string, resourceGroupName string, location string, dryrunName string, parameters DryrunResource, options *ConnectorClientBeginCreateDryrunOptions) (*runtime.Poller[ConnectorClientCreateDryrunResponse], error)

BeginCreateDryrun - create a dryrun job to do necessary check before actual creation If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • subscriptionID - The ID of the target subscription.
  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • location - The name of Azure region.
  • dryrunName - The name of dryrun.
  • parameters - dryrun resource.
  • options - ConnectorClientBeginCreateDryrunOptions contains the optional parameters for the ConnectorClient.BeginCreateDryrun method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/ConnectorDryrunCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConnectorClient().BeginCreateDryrun(ctx, "00000000-0000-0000-0000-000000000000", "test-rg", "westus", "dryrunName", armservicelinker.DryrunResource{
	Properties: &armservicelinker.DryrunProperties{
		Parameters: &armservicelinker.CreateOrUpdateDryrunParameters{
			ActionName: to.Ptr(armservicelinker.DryrunActionNameCreateOrUpdate),
			AuthInfo: &armservicelinker.SecretAuthInfo{
				AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
				Name:     to.Ptr("name"),
				SecretInfo: &armservicelinker.ValueSecretInfo{
					SecretType: to.Ptr(armservicelinker.SecretTypeRawValue),
					Value:      to.Ptr("secret"),
				},
			},
			TargetService: &armservicelinker.AzureResource{
				Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
				ID:   to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
			},
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.DryrunResource = armservicelinker.DryrunResource{
// 	Name: to.Ptr("dryrunName"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.ServiceLinker/locations/westus/dryruns/dryrunName"),
// 	Properties: &armservicelinker.DryrunProperties{
// 		OperationPreviews: []*armservicelinker.DryrunOperationPreview{
// 			{
// 				Name: to.Ptr("configFirewallRule"),
// 				Description: to.Ptr("Config firewall rule for target service to allow source service access"),
// 				Action: to.Ptr("Microsoft.DocumentDb/databaseAccounts/write"),
// 				OperationType: to.Ptr(armservicelinker.DryrunPreviewOperationTypeConfigNetwork),
// 				Scope: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc"),
// 		}},
// 		Parameters: &armservicelinker.CreateOrUpdateDryrunParameters{
// 			ActionName: to.Ptr(armservicelinker.DryrunActionNameCreateOrUpdate),
// 			AuthInfo: &armservicelinker.SecretAuthInfo{
// 				AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
// 				Name: to.Ptr("name"),
// 			},
// 			TargetService: &armservicelinker.AzureResource{
// 				Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
// 			},
// 		},
// 		PrerequisiteResults: []armservicelinker.DryrunPrerequisiteResultClassification{
// 			&armservicelinker.BasicErrorDryrunPrerequisiteResult{
// 				Type: to.Ptr(armservicelinker.DryrunPrerequisiteResultTypeBasicError),
// 				Code: to.Ptr("ResourceNotFound"),
// 				Message: to.Ptr("Target resource is not found"),
// 			},
// 			&armservicelinker.PermissionsMissingDryrunPrerequisiteResult{
// 				Type: to.Ptr(armservicelinker.DryrunPrerequisiteResultTypePermissionsMissing),
// 				Permissions: []*string{
// 					to.Ptr("Microsoft.DocumentDb/databaseAccounts/write")},
// 					Scope: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc"),
// 			}},
// 			ProvisioningState: to.Ptr("Succeeded"),
// 		},
// 	}

Output:

func (*ConnectorClient) BeginCreateOrUpdate 

func (client *ConnectorClient) BeginCreateOrUpdate(ctx context.Context, subscriptionID string, resourceGroupName string, location string, connectorName string, parameters LinkerResource, options *ConnectorClientBeginCreateOrUpdateOptions) (*runtime.Poller[ConnectorClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or update Connector resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • subscriptionID - The ID of the target subscription.
  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • location - The name of Azure region.
  • connectorName - The name of resource.
  • parameters - Connector details.
  • options - ConnectorClientBeginCreateOrUpdateOptions contains the optional parameters for the ConnectorClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/PutConnector.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConnectorClient().BeginCreateOrUpdate(ctx, "00000000-0000-0000-0000-000000000000", "test-rg", "westus", "connectorName", armservicelinker.LinkerResource{
	Properties: &armservicelinker.LinkerProperties{
		AuthInfo: &armservicelinker.SecretAuthInfo{
			AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
		},
		SecretStore: &armservicelinker.SecretStore{
			KeyVaultID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.KeyVault/vaults/test-kv"),
		},
		TargetService: &armservicelinker.AzureResource{
			Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
			ID:   to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.LinkerResource = armservicelinker.LinkerResource{
// 	Name: to.Ptr("linkName"),
// 	Type: to.Ptr("Microsoft.ServiceLinker/links"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app/providers/Microsoft.ServiceLinker/links/linkName"),
// 	Properties: &armservicelinker.LinkerProperties{
// 		AuthInfo: &armservicelinker.SecretAuthInfo{
// 			AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
// 		},
// 		SecretStore: &armservicelinker.SecretStore{
// 			KeyVaultID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.KeyVault/vaults/test-kv"),
// 		},
// 		TargetService: &armservicelinker.AzureResource{
// 			Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
// 		},
// 	},
// }

Output:

func (*ConnectorClient) BeginDelete 

func (client *ConnectorClient) BeginDelete(ctx context.Context, subscriptionID string, resourceGroupName string, location string, connectorName string, options *ConnectorClientBeginDeleteOptions) (*runtime.Poller[ConnectorClientDeleteResponse], error)

BeginDelete - Delete a Connector. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • subscriptionID - The ID of the target subscription.
  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • location - The name of Azure region.
  • connectorName - The name of resource.
  • options - ConnectorClientBeginDeleteOptions contains the optional parameters for the ConnectorClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/DeleteConnector.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConnectorClient().BeginDelete(ctx, "00000000-0000-0000-0000-000000000000", "test-rg", "westus", "connectorName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*ConnectorClient) BeginUpdate 

func (client *ConnectorClient) BeginUpdate(ctx context.Context, subscriptionID string, resourceGroupName string, location string, connectorName string, parameters LinkerPatch, options *ConnectorClientBeginUpdateOptions) (*runtime.Poller[ConnectorClientUpdateResponse], error)

BeginUpdate - Operation to update an existing Connector. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • subscriptionID - The ID of the target subscription.
  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • location - The name of Azure region.
  • connectorName - The name of resource.
  • parameters - Connector details.
  • options - ConnectorClientBeginUpdateOptions contains the optional parameters for the ConnectorClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/PatchConnector.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConnectorClient().BeginUpdate(ctx, "00000000-0000-0000-0000-000000000000", "test-rg", "westus", "connectorName", armservicelinker.LinkerPatch{
	Properties: &armservicelinker.LinkerProperties{
		AuthInfo: &armservicelinker.ServicePrincipalSecretAuthInfo{
			AuthType:    to.Ptr(armservicelinker.AuthTypeServicePrincipalSecret),
			ClientID:    to.Ptr("name"),
			PrincipalID: to.Ptr("id"),
			Secret:      to.Ptr("secret"),
		},
		TargetService: &armservicelinker.AzureResource{
			Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
			ID:   to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.LinkerResource = armservicelinker.LinkerResource{
// 	Name: to.Ptr("linkName"),
// 	Type: to.Ptr("Microsoft.ServiceLinker/links"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app/providers/Microsoft.ServiceLinker/links/linkName"),
// 	Properties: &armservicelinker.LinkerProperties{
// 		AuthInfo: &armservicelinker.ServicePrincipalSecretAuthInfo{
// 			AuthType: to.Ptr(armservicelinker.AuthTypeServicePrincipalSecret),
// 			ClientID: to.Ptr("name"),
// 			PrincipalID: to.Ptr("id"),
// 		},
// 		TargetService: &armservicelinker.AzureResource{
// 			Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
// 		},
// 	},
// }

Output:

func (*ConnectorClient) BeginUpdateDryrun 

func (client *ConnectorClient) BeginUpdateDryrun(ctx context.Context, subscriptionID string, resourceGroupName string, location string, dryrunName string, parameters DryrunPatch, options *ConnectorClientBeginUpdateDryrunOptions) (*runtime.Poller[ConnectorClientUpdateDryrunResponse], error)

BeginUpdateDryrun - update a dryrun job to do necessary check before actual creation If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • subscriptionID - The ID of the target subscription.
  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • location - The name of Azure region.
  • dryrunName - The name of dryrun.
  • parameters - dryrun resource.
  • options - ConnectorClientBeginUpdateDryrunOptions contains the optional parameters for the ConnectorClient.BeginUpdateDryrun method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/ConnectorDryrunUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConnectorClient().BeginUpdateDryrun(ctx, "00000000-0000-0000-0000-000000000000", "test-rg", "westus", "dryrunName", armservicelinker.DryrunPatch{
	Properties: &armservicelinker.DryrunProperties{
		Parameters: &armservicelinker.CreateOrUpdateDryrunParameters{
			ActionName: to.Ptr(armservicelinker.DryrunActionNameCreateOrUpdate),
			AuthInfo: &armservicelinker.SecretAuthInfo{
				AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
				Name:     to.Ptr("name"),
				SecretInfo: &armservicelinker.ValueSecretInfo{
					SecretType: to.Ptr(armservicelinker.SecretTypeRawValue),
					Value:      to.Ptr("secret"),
				},
			},
			TargetService: &armservicelinker.AzureResource{
				Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
				ID:   to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
			},
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.DryrunResource = armservicelinker.DryrunResource{
// 	Name: to.Ptr("dryrunName"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.ServiceLinker/locations/westus/dryruns/dryrunName"),
// 	Properties: &armservicelinker.DryrunProperties{
// 		OperationPreviews: []*armservicelinker.DryrunOperationPreview{
// 			{
// 				Name: to.Ptr("configFirewallRule"),
// 				Description: to.Ptr("Config firewall rule for target service to allow source service access"),
// 				Action: to.Ptr("Microsoft.DocumentDb/databaseAccounts/write"),
// 				OperationType: to.Ptr(armservicelinker.DryrunPreviewOperationTypeConfigNetwork),
// 				Scope: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc"),
// 		}},
// 		Parameters: &armservicelinker.CreateOrUpdateDryrunParameters{
// 			ActionName: to.Ptr(armservicelinker.DryrunActionNameCreateOrUpdate),
// 			AuthInfo: &armservicelinker.SecretAuthInfo{
// 				AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
// 				Name: to.Ptr("name"),
// 			},
// 			TargetService: &armservicelinker.AzureResource{
// 				Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
// 			},
// 		},
// 		PrerequisiteResults: []armservicelinker.DryrunPrerequisiteResultClassification{
// 			&armservicelinker.BasicErrorDryrunPrerequisiteResult{
// 				Type: to.Ptr(armservicelinker.DryrunPrerequisiteResultTypeBasicError),
// 				Code: to.Ptr("ResourceNotFound"),
// 				Message: to.Ptr("Target resource is not found"),
// 			},
// 			&armservicelinker.PermissionsMissingDryrunPrerequisiteResult{
// 				Type: to.Ptr(armservicelinker.DryrunPrerequisiteResultTypePermissionsMissing),
// 				Permissions: []*string{
// 					to.Ptr("Microsoft.DocumentDb/databaseAccounts/write")},
// 					Scope: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc"),
// 			}},
// 			ProvisioningState: to.Ptr("Succeeded"),
// 		},
// 	}

Output:

func (*ConnectorClient) BeginValidate 

func (client *ConnectorClient) BeginValidate(ctx context.Context, subscriptionID string, resourceGroupName string, location string, connectorName string, options *ConnectorClientBeginValidateOptions) (*runtime.Poller[ConnectorClientValidateResponse], error)

BeginValidate - Validate a Connector. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • subscriptionID - The ID of the target subscription.
  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • location - The name of Azure region.
  • connectorName - The name of resource.
  • options - ConnectorClientBeginValidateOptions contains the optional parameters for the ConnectorClient.BeginValidate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/ValidateConnectorSuccess.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewConnectorClient().BeginValidate(ctx, "00000000-0000-0000-0000-000000000000", "test-rg", "westus", "connectorName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ValidateOperationResult = armservicelinker.ValidateOperationResult{
// 	Properties: &armservicelinker.ValidateResult{
// 		AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
// 		IsConnectionAvailable: to.Ptr(true),
// 		ReportEndTimeUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-07-12T22:06:09.000Z"); return t}()),
// 		ReportStartTimeUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-07-12T22:05:09.000Z"); return t}()),
// 		ValidationDetail: []*armservicelinker.ValidationResultItem{
// 			{
// 				Name: to.Ptr("TargetExistence"),
// 				Description: to.Ptr("The target existence is validated"),
// 				Result: to.Ptr(armservicelinker.ValidationResultStatusSuccess),
// 			},
// 			{
// 				Name: to.Ptr("TargetNetworkAccess"),
// 				Description: to.Ptr("Deny public network access is set to yes. Please confirm you are using private endpoint connection to access target resource."),
// 				Result: to.Ptr(armservicelinker.ValidationResultStatusWarning),
// 		}},
// 	},
// }

Output:

func (*ConnectorClient) DeleteDryrun 

func (client *ConnectorClient) DeleteDryrun(ctx context.Context, subscriptionID string, resourceGroupName string, location string, dryrunName string, options *ConnectorClientDeleteDryrunOptions) (ConnectorClientDeleteDryrunResponse, error)

DeleteDryrun - delete a dryrun job If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • subscriptionID - The ID of the target subscription.
  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • location - The name of Azure region.
  • dryrunName - The name of dryrun.
  • options - ConnectorClientDeleteDryrunOptions contains the optional parameters for the ConnectorClient.DeleteDryrun method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/ConnectorDryrunDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
_, err = clientFactory.NewConnectorClient().DeleteDryrun(ctx, "00000000-0000-0000-0000-000000000000", "test-rg", "westus", "dryrunName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}

Output:

func (*ConnectorClient) GenerateConfigurations 

func (client *ConnectorClient) GenerateConfigurations(ctx context.Context, subscriptionID string, resourceGroupName string, location string, connectorName string, options *ConnectorClientGenerateConfigurationsOptions) (ConnectorClientGenerateConfigurationsResponse, error)

GenerateConfigurations - Generate configurations for a Connector. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • subscriptionID - The ID of the target subscription.
  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • location - The name of Azure region.
  • connectorName - The name of resource.
  • options - ConnectorClientGenerateConfigurationsOptions contains the optional parameters for the ConnectorClient.GenerateConfigurations method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/GenerateConfigurations.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewConnectorClient().GenerateConfigurations(ctx, "00000000-0000-0000-0000-000000000000", "test-rg", "westus", "connectorName", &armservicelinker.ConnectorClientGenerateConfigurationsOptions{Parameters: &armservicelinker.ConfigurationInfo{
	CustomizedKeys: map[string]*string{
		"ASL_DocumentDb_ConnectionString": to.Ptr("MyConnectionstring"),
	},
},
})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ConfigurationResult = armservicelinker.ConfigurationResult{
// 	Configurations: []*armservicelinker.SourceConfiguration{
// 		{
// 			Name: to.Ptr("MyConnectionstring"),
// 			Value: to.Ptr("ConnectionString"),
// 	}},
// }

Output:

func (*ConnectorClient) Get 

func (client *ConnectorClient) Get(ctx context.Context, subscriptionID string, resourceGroupName string, location string, connectorName string, options *ConnectorClientGetOptions) (ConnectorClientGetResponse, error)

Get - Returns Connector resource for a given name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • subscriptionID - The ID of the target subscription.
  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • location - The name of Azure region.
  • connectorName - The name of resource.
  • options - ConnectorClientGetOptions contains the optional parameters for the ConnectorClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/Connectors.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewConnectorClient().Get(ctx, "00000000-0000-0000-0000-000000000000", "test-rg", "westus", "connectorName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.LinkerResource = armservicelinker.LinkerResource{
// 	Name: to.Ptr("linkName"),
// 	Type: to.Ptr("Microsoft.ServiceLinker/devConnectors"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.ServiceLinker/devConnnectors/linkName"),
// 	SystemData: &armservicelinker.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-07-12T22:05:09.000Z"); return t}()),
// 	},
// 	Properties: &armservicelinker.LinkerProperties{
// 		AuthInfo: &armservicelinker.SystemAssignedIdentityAuthInfo{
// 			AuthType: to.Ptr(armservicelinker.AuthTypeSystemAssignedIdentity),
// 			Roles: []*string{
// 				to.Ptr("customizedOwner")},
// 			},
// 			PublicNetworkSolution: &armservicelinker.PublicNetworkSolution{
// 				Action: to.Ptr(armservicelinker.ActionTypeEnable),
// 				DeleteOrUpdateBehavior: to.Ptr(armservicelinker.DeleteOrUpdateBehaviorForcedCleanup),
// 				FirewallRules: &armservicelinker.FirewallRules{
// 					CallerClientIP: to.Ptr(armservicelinker.AllowTypeTrue),
// 					IPRanges: []*string{
// 						to.Ptr("182.22.120")},
// 					},
// 				},
// 				TargetService: &armservicelinker.AzureResource{
// 					Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
// 				},
// 			},
// 		}

Output:

func (*ConnectorClient) GetDryrun 

func (client *ConnectorClient) GetDryrun(ctx context.Context, subscriptionID string, resourceGroupName string, location string, dryrunName string, options *ConnectorClientGetDryrunOptions) (ConnectorClientGetDryrunResponse, error)

GetDryrun - get a dryrun job If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • subscriptionID - The ID of the target subscription.
  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • location - The name of Azure region.
  • dryrunName - The name of dryrun.
  • options - ConnectorClientGetDryrunOptions contains the optional parameters for the ConnectorClient.GetDryrun method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/ConnectorDryrunGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewConnectorClient().GetDryrun(ctx, "00000000-0000-0000-0000-000000000000", "test-rg", "westus", "dryrunName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.DryrunResource = armservicelinker.DryrunResource{
// 	Name: to.Ptr("dryrunName"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.ServiceLinker/locations/westus/dryruns/dryrunName"),
// 	SystemData: &armservicelinker.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-07-12T22:05:09.000Z"); return t}()),
// 	},
// 	Properties: &armservicelinker.DryrunProperties{
// 		Parameters: &armservicelinker.CreateOrUpdateDryrunParameters{
// 			ActionName: to.Ptr(armservicelinker.DryrunActionNameCreateOrUpdate),
// 			AuthInfo: &armservicelinker.SecretAuthInfo{
// 				AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
// 				Name: to.Ptr("username"),
// 			},
// 			TargetService: &armservicelinker.AzureResource{
// 				Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
// 			},
// 		},
// 	},
// }

Output:

func (*ConnectorClient) NewListDryrunPager 

func (client *ConnectorClient) NewListDryrunPager(subscriptionID string, resourceGroupName string, location string, options *ConnectorClientListDryrunOptions) *runtime.Pager[ConnectorClientListDryrunResponse]

NewListDryrunPager - list dryrun jobs

Generated from API version 2023-04-01-preview

  • subscriptionID - The ID of the target subscription.
  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • location - The name of Azure region.
  • options - ConnectorClientListDryrunOptions contains the optional parameters for the ConnectorClient.NewListDryrunPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/ConnectorDryrunList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewConnectorClient().NewListDryrunPager("00000000-0000-0000-0000-000000000000", "test-rg", "westus", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.DryrunList = armservicelinker.DryrunList{
	// 	Value: []*armservicelinker.DryrunResource{
	// 		{
	// 			Name: to.Ptr("dryrunName"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.ServiceLinker/locations/westus/dryruns/dryrunName"),
	// 			SystemData: &armservicelinker.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-07-12T22:05:09.000Z"); return t}()),
	// 			},
	// 			Properties: &armservicelinker.DryrunProperties{
	// 				Parameters: &armservicelinker.CreateOrUpdateDryrunParameters{
	// 					ActionName: to.Ptr(armservicelinker.DryrunActionNameCreateOrUpdate),
	// 					AuthInfo: &armservicelinker.SecretAuthInfo{
	// 						AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
	// 						Name: to.Ptr("username"),
	// 					},
	// 					TargetService: &armservicelinker.AzureResource{
	// 						Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
	// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
	// 					},
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

func (*ConnectorClient) NewListPager 

func (client *ConnectorClient) NewListPager(subscriptionID string, resourceGroupName string, location string, options *ConnectorClientListOptions) *runtime.Pager[ConnectorClientListResponse]

NewListPager - Returns list of connector which connects to the resource, which supports to config the target service during the resource provision.

Generated from API version 2023-04-01-preview

  • subscriptionID - The ID of the target subscription.
  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • location - The name of Azure region.
  • options - ConnectorClientListOptions contains the optional parameters for the ConnectorClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/ConnectorList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewConnectorClient().NewListPager("00000000-0000-0000-0000-000000000000", "test-rg", "westus", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ResourceList = armservicelinker.ResourceList{
	// 	Value: []*armservicelinker.LinkerResource{
	// 		{
	// 			Name: to.Ptr("linkName"),
	// 			Type: to.Ptr("Microsoft.ServiceLinker/devConnectors"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.ServiceLinker/linkers/linkName"),
	// 			SystemData: &armservicelinker.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-07-12T22:05:09.000Z"); return t}()),
	// 			},
	// 			Properties: &armservicelinker.LinkerProperties{
	// 				AuthInfo: &armservicelinker.SecretAuthInfo{
	// 					AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
	// 					Name: to.Ptr("username"),
	// 				},
	// 				TargetService: &armservicelinker.AzureResource{
	// 					Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
	// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

type ConnectorClientBeginCreateDryrunOptions 

type ConnectorClientBeginCreateDryrunOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ConnectorClientBeginCreateDryrunOptions contains the optional parameters for the ConnectorClient.BeginCreateDryrun method.

type ConnectorClientBeginCreateOrUpdateOptions 

type ConnectorClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ConnectorClientBeginCreateOrUpdateOptions contains the optional parameters for the ConnectorClient.BeginCreateOrUpdate method.

type ConnectorClientBeginDeleteOptions 

type ConnectorClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ConnectorClientBeginDeleteOptions contains the optional parameters for the ConnectorClient.BeginDelete method.

type ConnectorClientBeginUpdateDryrunOptions 

type ConnectorClientBeginUpdateDryrunOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ConnectorClientBeginUpdateDryrunOptions contains the optional parameters for the ConnectorClient.BeginUpdateDryrun method.

type ConnectorClientBeginUpdateOptions 

type ConnectorClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ConnectorClientBeginUpdateOptions contains the optional parameters for the ConnectorClient.BeginUpdate method.

type ConnectorClientBeginValidateOptions 

type ConnectorClientBeginValidateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ConnectorClientBeginValidateOptions contains the optional parameters for the ConnectorClient.BeginValidate method.

type ConnectorClientCreateDryrunResponse 

type ConnectorClientCreateDryrunResponse struct {
	// a dryrun job resource
	DryrunResource
}

ConnectorClientCreateDryrunResponse contains the response from method ConnectorClient.BeginCreateDryrun.

type ConnectorClientCreateOrUpdateResponse 

type ConnectorClientCreateOrUpdateResponse struct {
	// Linker of source and target resource
	LinkerResource
}

ConnectorClientCreateOrUpdateResponse contains the response from method ConnectorClient.BeginCreateOrUpdate.

type ConnectorClientDeleteDryrunOptions 

type ConnectorClientDeleteDryrunOptions struct {
}

ConnectorClientDeleteDryrunOptions contains the optional parameters for the ConnectorClient.DeleteDryrun method.

type ConnectorClientDeleteDryrunResponse 

type ConnectorClientDeleteDryrunResponse struct {
}

ConnectorClientDeleteDryrunResponse contains the response from method ConnectorClient.DeleteDryrun.

type ConnectorClientDeleteResponse 

type ConnectorClientDeleteResponse struct {
}

ConnectorClientDeleteResponse contains the response from method ConnectorClient.BeginDelete.

type ConnectorClientGenerateConfigurationsOptions 

type ConnectorClientGenerateConfigurationsOptions struct {
	// Connection Info, including format, secret store, etc
	Parameters *ConfigurationInfo
}

ConnectorClientGenerateConfigurationsOptions contains the optional parameters for the ConnectorClient.GenerateConfigurations method.

type ConnectorClientGenerateConfigurationsResponse 

type ConnectorClientGenerateConfigurationsResponse struct {
	// Configurations for source resource, include appSettings, connectionString and serviceBindings
	ConfigurationResult
}

ConnectorClientGenerateConfigurationsResponse contains the response from method ConnectorClient.GenerateConfigurations.

type ConnectorClientGetDryrunOptions 

type ConnectorClientGetDryrunOptions struct {
}

ConnectorClientGetDryrunOptions contains the optional parameters for the ConnectorClient.GetDryrun method.

type ConnectorClientGetDryrunResponse 

type ConnectorClientGetDryrunResponse struct {
	// a dryrun job resource
	DryrunResource
}

ConnectorClientGetDryrunResponse contains the response from method ConnectorClient.GetDryrun.

type ConnectorClientGetOptions 

type ConnectorClientGetOptions struct {
}

ConnectorClientGetOptions contains the optional parameters for the ConnectorClient.Get method.

type ConnectorClientGetResponse 

type ConnectorClientGetResponse struct {
	// Linker of source and target resource
	LinkerResource
}

ConnectorClientGetResponse contains the response from method ConnectorClient.Get.

type ConnectorClientListDryrunOptions 

type ConnectorClientListDryrunOptions struct {
}

ConnectorClientListDryrunOptions contains the optional parameters for the ConnectorClient.NewListDryrunPager method.

type ConnectorClientListDryrunResponse 

type ConnectorClientListDryrunResponse struct {
	// The list of dryrun.
	DryrunList
}

ConnectorClientListDryrunResponse contains the response from method ConnectorClient.NewListDryrunPager.

type ConnectorClientListOptions 

type ConnectorClientListOptions struct {
}

ConnectorClientListOptions contains the optional parameters for the ConnectorClient.NewListPager method.

type ConnectorClientListResponse 

type ConnectorClientListResponse struct {
	// The list of Linker.
	ResourceList
}

ConnectorClientListResponse contains the response from method ConnectorClient.NewListPager.

type ConnectorClientUpdateDryrunResponse 

type ConnectorClientUpdateDryrunResponse struct {
	// a dryrun job resource
	DryrunResource
}

ConnectorClientUpdateDryrunResponse contains the response from method ConnectorClient.BeginUpdateDryrun.

type ConnectorClientUpdateResponse 

type ConnectorClientUpdateResponse struct {
	// Linker of source and target resource
	LinkerResource
}

ConnectorClientUpdateResponse contains the response from method ConnectorClient.BeginUpdate.

type ConnectorClientValidateResponse 

type ConnectorClientValidateResponse struct {
	// The validation operation result for a Linker.
	ValidateOperationResult
}

ConnectorClientValidateResponse contains the response from method ConnectorClient.BeginValidate.

type CreateOrUpdateDryrunParameters 

type CreateOrUpdateDryrunParameters struct {
	// REQUIRED; The name of action for you dryrun job.
	ActionName *DryrunActionName

	// The authentication type.
	AuthInfo AuthInfoBaseClassification

	// The application client type
	ClientType *ClientType

	// The connection information consumed by applications, including secrets, connection strings.
	ConfigurationInfo *ConfigurationInfo

	// The network solution.
	PublicNetworkSolution *PublicNetworkSolution

	// connection scope in source service.
	Scope *string

	// An option to store secret value in secure place
	SecretStore *SecretStore

	// The target service properties
	TargetService TargetServiceBaseClassification

	// The VNet solution.
	VNetSolution *VNetSolution

	// READ-ONLY; The provisioning state.
	ProvisioningState *string
}

CreateOrUpdateDryrunParameters - The dryrun parameters for creation or update a linker

func (*CreateOrUpdateDryrunParameters) GetDryrunParameters 

func (c *CreateOrUpdateDryrunParameters) GetDryrunParameters() *DryrunParameters

GetDryrunParameters implements the DryrunParametersClassification interface for type CreateOrUpdateDryrunParameters.

func (CreateOrUpdateDryrunParameters) MarshalJSON 

func (c CreateOrUpdateDryrunParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CreateOrUpdateDryrunParameters.

func (*CreateOrUpdateDryrunParameters) UnmarshalJSON 

func (c *CreateOrUpdateDryrunParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CreateOrUpdateDryrunParameters.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

const (
	CreatedByTypeApplication     CreatedByType = "Application"
	CreatedByTypeKey             CreatedByType = "Key"
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	CreatedByTypeUser            CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type DaprBindingComponentDirection 

type DaprBindingComponentDirection string

DaprBindingComponentDirection - The direction supported by the dapr binding component 

const (
	DaprBindingComponentDirectionInput  DaprBindingComponentDirection = "input"
	DaprBindingComponentDirectionOutput DaprBindingComponentDirection = "output"
)

func PossibleDaprBindingComponentDirectionValues 

func PossibleDaprBindingComponentDirectionValues() []DaprBindingComponentDirection

PossibleDaprBindingComponentDirectionValues returns the possible values for the DaprBindingComponentDirection const type.

type DaprConfigurationList 

type DaprConfigurationList struct {
	// The list of dapr configurations
	Value []*DaprConfigurationResource

	// READ-ONLY; Link to next page of resources.
	NextLink *string
}

DaprConfigurationList - Dapr configuration list supported by Service Connector

func (DaprConfigurationList) MarshalJSON 

func (d DaprConfigurationList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DaprConfigurationList.

func (*DaprConfigurationList) UnmarshalJSON 

func (d *DaprConfigurationList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DaprConfigurationList.

type DaprConfigurationProperties 

type DaprConfigurationProperties struct {
	// The authentication type.
	AuthType *AuthType

	// Indicates some additional properties for dapr client type
	DaprProperties *DaprProperties

	// Supported target resource type, extract from resource id, uppercase
	TargetType *string
}

func (DaprConfigurationProperties) MarshalJSON 

func (d DaprConfigurationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DaprConfigurationProperties.

func (*DaprConfigurationProperties) UnmarshalJSON 

func (d *DaprConfigurationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DaprConfigurationProperties.

type DaprConfigurationResource 

type DaprConfigurationResource struct {
	// The properties of the dapr configuration.
	Properties *DaprConfigurationProperties
}

DaprConfigurationResource - Represent one resource of the dapr configuration list

func (DaprConfigurationResource) MarshalJSON 

func (d DaprConfigurationResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DaprConfigurationResource.

func (*DaprConfigurationResource) UnmarshalJSON 

func (d *DaprConfigurationResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DaprConfigurationResource.

type DaprMetadata 

type DaprMetadata struct {
	// The description of the metadata, returned from configuration api
	Description *string

	// Metadata property name.
	Name *string

	// The value indicating whether the metadata is required or not
	Required *DaprMetadataRequired

	// The secret name where dapr could get value
	SecretRef *string

	// Metadata property value.
	Value *string
}

DaprMetadata - The dapr component metadata.

func (DaprMetadata) MarshalJSON 

func (d DaprMetadata) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DaprMetadata.

func (*DaprMetadata) UnmarshalJSON 

func (d *DaprMetadata) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DaprMetadata.

type DaprMetadataRequired 

type DaprMetadataRequired string

DaprMetadataRequired - The value indicating whether the metadata is required or not 

const (
	DaprMetadataRequiredFalse DaprMetadataRequired = "false"
	DaprMetadataRequiredTrue  DaprMetadataRequired = "true"
)

func PossibleDaprMetadataRequiredValues 

func PossibleDaprMetadataRequiredValues() []DaprMetadataRequired

PossibleDaprMetadataRequiredValues returns the possible values for the DaprMetadataRequired const type.

type DaprProperties 

type DaprProperties struct {
	// The dapr component type
	ComponentType *string

	// Additional dapr metadata
	Metadata []*DaprMetadata

	// The dapr component scopes
	Scopes []*string

	// The name of a secret store dapr to retrieve secret
	SecretStoreComponent *string

	// The dapr component version
	Version *string

	// READ-ONLY; The direction supported by the dapr binding component
	BindingComponentDirection *DaprBindingComponentDirection

	// READ-ONLY; The runtime version supported by the properties
	RuntimeVersion *string
}

DaprProperties - Indicates some additional properties for dapr client type

func (DaprProperties) MarshalJSON 

func (d DaprProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DaprProperties.

func (*DaprProperties) UnmarshalJSON 

func (d *DaprProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DaprProperties.

type DatabaseAADAuthInfo 

type DatabaseAADAuthInfo struct {
	// Username created in the database which is mapped to a user in AAD.
	UserName *string
}

DatabaseAADAuthInfo - The extra auth info required by Database AAD authentication.

func (DatabaseAADAuthInfo) MarshalJSON 

func (d DatabaseAADAuthInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DatabaseAADAuthInfo.

func (*DatabaseAADAuthInfo) UnmarshalJSON 

func (d *DatabaseAADAuthInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DatabaseAADAuthInfo.

type DeleteOrUpdateBehavior 

type DeleteOrUpdateBehavior string

DeleteOrUpdateBehavior - The cleanup behavior to indicate whether clean up operation when resource is deleted or updated 

const (
	DeleteOrUpdateBehaviorDefault       DeleteOrUpdateBehavior = "Default"
	DeleteOrUpdateBehaviorForcedCleanup DeleteOrUpdateBehavior = "ForcedCleanup"
)

func PossibleDeleteOrUpdateBehaviorValues 

func PossibleDeleteOrUpdateBehaviorValues() []DeleteOrUpdateBehavior

PossibleDeleteOrUpdateBehaviorValues returns the possible values for the DeleteOrUpdateBehavior const type.

type DryrunActionName 

type DryrunActionName string

DryrunActionName - The name of action for you dryrun job. 

const (
	DryrunActionNameCreateOrUpdate DryrunActionName = "createOrUpdate"
)

func PossibleDryrunActionNameValues 

func PossibleDryrunActionNameValues() []DryrunActionName

PossibleDryrunActionNameValues returns the possible values for the DryrunActionName const type.

type DryrunList 

type DryrunList struct {
	// The link used to get the next page of dryrun list.
	NextLink *string

	// The list of dryrun.
	Value []*DryrunResource
}

DryrunList - The list of dryrun.

func (DryrunList) MarshalJSON 

func (d DryrunList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DryrunList.

func (*DryrunList) UnmarshalJSON 

func (d *DryrunList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DryrunList.

type DryrunOperationPreview 

type DryrunOperationPreview struct {
	// The action defined by RBAC, refer https://docs.microsoft.com/azure/role-based-access-control/role-definitions#actions-format
	Action *string

	// The description of the operation
	Description *string

	// The operation name
	Name *string

	// The operation type
	OperationType *DryrunPreviewOperationType

	// The scope of the operation, refer https://docs.microsoft.com/azure/role-based-access-control/scope-overview
	Scope *string
}

DryrunOperationPreview - The preview of the operations for creation

func (DryrunOperationPreview) MarshalJSON 

func (d DryrunOperationPreview) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DryrunOperationPreview.

func (*DryrunOperationPreview) UnmarshalJSON 

func (d *DryrunOperationPreview) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DryrunOperationPreview.

type DryrunParameters 

type DryrunParameters struct {
	// REQUIRED; The name of action for you dryrun job.
	ActionName *DryrunActionName
}

DryrunParameters - The parameters of the dryrun

func (*DryrunParameters) GetDryrunParameters 

func (d *DryrunParameters) GetDryrunParameters() *DryrunParameters

GetDryrunParameters implements the DryrunParametersClassification interface for type DryrunParameters.

func (DryrunParameters) MarshalJSON 

func (d DryrunParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DryrunParameters.

func (*DryrunParameters) UnmarshalJSON 

func (d *DryrunParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DryrunParameters.

type DryrunParametersClassification 

type DryrunParametersClassification interface {
	// GetDryrunParameters returns the DryrunParameters content of the underlying type.
	GetDryrunParameters() *DryrunParameters
}

DryrunParametersClassification provides polymorphic access to related types. Call the interface's GetDryrunParameters() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *CreateOrUpdateDryrunParameters, *DryrunParameters

type DryrunPatch 

type DryrunPatch struct {
	// The properties of the dryrun job.
	Properties *DryrunProperties
}

DryrunPatch - a dryrun job to be updated.

func (DryrunPatch) MarshalJSON 

func (d DryrunPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DryrunPatch.

func (*DryrunPatch) UnmarshalJSON 

func (d *DryrunPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DryrunPatch.

type DryrunPrerequisiteResult 

type DryrunPrerequisiteResult struct {
	// REQUIRED; The type of dryrun result.
	Type *DryrunPrerequisiteResultType
}

DryrunPrerequisiteResult - A result of dryrun

func (*DryrunPrerequisiteResult) GetDryrunPrerequisiteResult 

func (d *DryrunPrerequisiteResult) GetDryrunPrerequisiteResult() *DryrunPrerequisiteResult

GetDryrunPrerequisiteResult implements the DryrunPrerequisiteResultClassification interface for type DryrunPrerequisiteResult.

func (DryrunPrerequisiteResult) MarshalJSON 

func (d DryrunPrerequisiteResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DryrunPrerequisiteResult.

func (*DryrunPrerequisiteResult) UnmarshalJSON 

func (d *DryrunPrerequisiteResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DryrunPrerequisiteResult.

type DryrunPrerequisiteResultClassification 

type DryrunPrerequisiteResultClassification interface {
	// GetDryrunPrerequisiteResult returns the DryrunPrerequisiteResult content of the underlying type.
	GetDryrunPrerequisiteResult() *DryrunPrerequisiteResult
}

DryrunPrerequisiteResultClassification provides polymorphic access to related types. Call the interface's GetDryrunPrerequisiteResult() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *BasicErrorDryrunPrerequisiteResult, *DryrunPrerequisiteResult, *PermissionsMissingDryrunPrerequisiteResult

type DryrunPrerequisiteResultType 

type DryrunPrerequisiteResultType string

DryrunPrerequisiteResultType - The type of dryrun result. 

const (
	DryrunPrerequisiteResultTypeBasicError         DryrunPrerequisiteResultType = "basicError"
	DryrunPrerequisiteResultTypePermissionsMissing DryrunPrerequisiteResultType = "permissionsMissing"
)

func PossibleDryrunPrerequisiteResultTypeValues 

func PossibleDryrunPrerequisiteResultTypeValues() []DryrunPrerequisiteResultType

PossibleDryrunPrerequisiteResultTypeValues returns the possible values for the DryrunPrerequisiteResultType const type.

type DryrunPreviewOperationType 

type DryrunPreviewOperationType string

DryrunPreviewOperationType - The operation type 

const (
	DryrunPreviewOperationTypeConfigAuth       DryrunPreviewOperationType = "configAuth"
	DryrunPreviewOperationTypeConfigConnection DryrunPreviewOperationType = "configConnection"
	DryrunPreviewOperationTypeConfigNetwork    DryrunPreviewOperationType = "configNetwork"
)

func PossibleDryrunPreviewOperationTypeValues 

func PossibleDryrunPreviewOperationTypeValues() []DryrunPreviewOperationType

PossibleDryrunPreviewOperationTypeValues returns the possible values for the DryrunPreviewOperationType const type.

type DryrunProperties 

type DryrunProperties struct {
	// The parameters of the dryrun
	Parameters DryrunParametersClassification

	// READ-ONLY; the preview of the operations for creation
	OperationPreviews []*DryrunOperationPreview

	// READ-ONLY; the result of the dryrun
	PrerequisiteResults []DryrunPrerequisiteResultClassification

	// READ-ONLY; The provisioning state.
	ProvisioningState *string
}

DryrunProperties - The properties of the dryrun job

func (DryrunProperties) MarshalJSON 

func (d DryrunProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DryrunProperties.

func (*DryrunProperties) UnmarshalJSON 

func (d *DryrunProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DryrunProperties.

type DryrunResource 

type DryrunResource struct {
	// The properties of the dryrun job.
	Properties *DryrunProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

DryrunResource - a dryrun job resource

func (DryrunResource) MarshalJSON 

func (d DryrunResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DryrunResource.

func (*DryrunResource) UnmarshalJSON 

func (d *DryrunResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DryrunResource.

type EasyAuthMicrosoftEntraIDAuthInfo 

type EasyAuthMicrosoftEntraIDAuthInfo struct {
	// REQUIRED; The authentication type.
	AuthType *AuthType

	// Optional. Indicates how to configure authentication. If optInAllAuth, service linker configures authentication such as
	// enabling identity on source resource and granting RBAC roles. If optOutAllAuth,
	// opt out authentication setup. Default is optInAllAuth.
	AuthMode *AuthMode

	// Application clientId for EasyAuth Microsoft Entra ID.
	ClientID *string

	// Indicates whether to clean up previous operation when Linker is updating or deleting
	DeleteOrUpdateBehavior *DeleteOrUpdateBehavior

	// Application Secret for EasyAuth Microsoft Entra ID.
	Secret *string
}

EasyAuthMicrosoftEntraIDAuthInfo - The authentication info when authType is EasyAuth Microsoft Entra ID

func (*EasyAuthMicrosoftEntraIDAuthInfo) GetAuthInfoBase 

func (e *EasyAuthMicrosoftEntraIDAuthInfo) GetAuthInfoBase() *AuthInfoBase

GetAuthInfoBase implements the AuthInfoBaseClassification interface for type EasyAuthMicrosoftEntraIDAuthInfo.

func (EasyAuthMicrosoftEntraIDAuthInfo) MarshalJSON 

func (e EasyAuthMicrosoftEntraIDAuthInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EasyAuthMicrosoftEntraIDAuthInfo.

func (*EasyAuthMicrosoftEntraIDAuthInfo) UnmarshalJSON 

func (e *EasyAuthMicrosoftEntraIDAuthInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EasyAuthMicrosoftEntraIDAuthInfo.

type ErrorAdditionalInfo 

type ErrorAdditionalInfo struct {
	// READ-ONLY; The additional info.
	Info any

	// READ-ONLY; The additional info type.
	Type *string
}

ErrorAdditionalInfo - The resource management error additional info.

func (ErrorAdditionalInfo) MarshalJSON 

func (e ErrorAdditionalInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ErrorAdditionalInfo.

func (*ErrorAdditionalInfo) UnmarshalJSON 

func (e *ErrorAdditionalInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorAdditionalInfo.

type ErrorDetail 

type ErrorDetail struct {
	// READ-ONLY; The error additional info.
	AdditionalInfo []*ErrorAdditionalInfo

	// READ-ONLY; The error code.
	Code *string

	// READ-ONLY; The error details.
	Details []*ErrorDetail

	// READ-ONLY; The error message.
	Message *string

	// READ-ONLY; The error target.
	Target *string
}

ErrorDetail - The error detail.

func (ErrorDetail) MarshalJSON 

func (e ErrorDetail) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ErrorDetail.

func (*ErrorDetail) UnmarshalJSON 

func (e *ErrorDetail) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorDetail.

type ErrorResponse 

type ErrorResponse struct {
	// The error object.
	Error *ErrorDetail
}

ErrorResponse - Common error response for all Azure Resource Manager APIs to return error details for failed operations. (This also follows the OData error response format.).

func (ErrorResponse) MarshalJSON 

func (e ErrorResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ErrorResponse.

func (*ErrorResponse) UnmarshalJSON 

func (e *ErrorResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponse.

type FirewallRules 

type FirewallRules struct {
	// Allow Azure services to access the target service if true.
	AzureServices *AllowType

	// Allow caller client IP to access the target service if true. the property is used when connecting local application to
	// target service.
	CallerClientIP *AllowType

	// This value specifies the set of IP addresses or IP address ranges in CIDR form to be included as the allowed list of client
	// IPs for a given database account.
	IPRanges []*string
}

FirewallRules - Target service's firewall rules. to allow connections from source service.

func (FirewallRules) MarshalJSON 

func (f FirewallRules) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type FirewallRules.

func (*FirewallRules) UnmarshalJSON 

func (f *FirewallRules) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type FirewallRules.

type KeyVaultSecretReferenceSecretInfo 

type KeyVaultSecretReferenceSecretInfo struct {
	// REQUIRED; The secret type.
	SecretType *SecretType

	// Name of the Key Vault secret.
	Name *string

	// Version of the Key Vault secret.
	Version *string
}

KeyVaultSecretReferenceSecretInfo - The secret info when type is keyVaultSecretReference. It's for scenario that user provides a secret stored in user's keyvault and source is Azure Kubernetes. The key Vault's resource id is linked to secretStore.keyVaultId.

func (*KeyVaultSecretReferenceSecretInfo) GetSecretInfoBase 

func (k *KeyVaultSecretReferenceSecretInfo) GetSecretInfoBase() *SecretInfoBase

GetSecretInfoBase implements the SecretInfoBaseClassification interface for type KeyVaultSecretReferenceSecretInfo.

func (KeyVaultSecretReferenceSecretInfo) MarshalJSON 

func (k KeyVaultSecretReferenceSecretInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KeyVaultSecretReferenceSecretInfo.

func (*KeyVaultSecretReferenceSecretInfo) UnmarshalJSON 

func (k *KeyVaultSecretReferenceSecretInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KeyVaultSecretReferenceSecretInfo.

type KeyVaultSecretURISecretInfo 

type KeyVaultSecretURISecretInfo struct {
	// REQUIRED; The secret type.
	SecretType *SecretType

	// URI to the keyvault secret
	Value *string
}

KeyVaultSecretURISecretInfo - The secret info when type is keyVaultSecretUri. It's for scenario that user provides a secret stored in user's keyvault and source is Web App, Spring Cloud or Container App.

func (*KeyVaultSecretURISecretInfo) GetSecretInfoBase 

func (k *KeyVaultSecretURISecretInfo) GetSecretInfoBase() *SecretInfoBase

GetSecretInfoBase implements the SecretInfoBaseClassification interface for type KeyVaultSecretURISecretInfo.

func (KeyVaultSecretURISecretInfo) MarshalJSON 

func (k KeyVaultSecretURISecretInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KeyVaultSecretURISecretInfo.

func (*KeyVaultSecretURISecretInfo) UnmarshalJSON 

func (k *KeyVaultSecretURISecretInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KeyVaultSecretURISecretInfo.

type LinkerClient 

type LinkerClient struct {
	// contains filtered or unexported fields
}

LinkerClient contains the methods for the Linker group. Don't use this type directly, use NewLinkerClient() instead.

func NewLinkerClient 

func NewLinkerClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*LinkerClient, error)

NewLinkerClient creates a new instance of LinkerClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*LinkerClient) BeginCreateOrUpdate 

func (client *LinkerClient) BeginCreateOrUpdate(ctx context.Context, resourceURI string, linkerName string, parameters LinkerResource, options *LinkerClientBeginCreateOrUpdateOptions) (*runtime.Poller[LinkerClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or update Linker resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • linkerName - The name Linker resource.
  • parameters - Linker details.
  • options - LinkerClientBeginCreateOrUpdateOptions contains the optional parameters for the LinkerClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/PutLinker.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewLinkerClient().BeginCreateOrUpdate(ctx, "subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app", "linkName", armservicelinker.LinkerResource{
	Properties: &armservicelinker.LinkerProperties{
		AuthInfo: &armservicelinker.SecretAuthInfo{
			AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
			Name:     to.Ptr("name"),
			SecretInfo: &armservicelinker.ValueSecretInfo{
				SecretType: to.Ptr(armservicelinker.SecretTypeRawValue),
				Value:      to.Ptr("secret"),
			},
		},
		TargetService: &armservicelinker.AzureResource{
			Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
			ID:   to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DBforPostgreSQL/servers/test-pg/databases/test-db"),
		},
		VNetSolution: &armservicelinker.VNetSolution{
			Type: to.Ptr(armservicelinker.VNetSolutionTypeServiceEndpoint),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.LinkerResource = armservicelinker.LinkerResource{
// 	Name: to.Ptr("linkName"),
// 	Type: to.Ptr("Microsoft.ServiceLinker/links"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app/providers/Microsoft.ServiceLinker/links/linkName"),
// 	Properties: &armservicelinker.LinkerProperties{
// 		AuthInfo: &armservicelinker.SecretAuthInfo{
// 			AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
// 			Name: to.Ptr("name"),
// 		},
// 		TargetService: &armservicelinker.AzureResource{
// 			Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DBforPostgreSQL/servers/test-pg/databases/test-db"),
// 		},
// 		VNetSolution: &armservicelinker.VNetSolution{
// 			Type: to.Ptr(armservicelinker.VNetSolutionTypeServiceEndpoint),
// 		},
// 	},
// }

Output:

func (*LinkerClient) BeginDelete 

func (client *LinkerClient) BeginDelete(ctx context.Context, resourceURI string, linkerName string, options *LinkerClientBeginDeleteOptions) (*runtime.Poller[LinkerClientDeleteResponse], error)

BeginDelete - Delete a Linker. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • linkerName - The name Linker resource.
  • options - LinkerClientBeginDeleteOptions contains the optional parameters for the LinkerClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/DeleteLinker.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewLinkerClient().BeginDelete(ctx, "subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app", "linkName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*LinkerClient) BeginUpdate 

func (client *LinkerClient) BeginUpdate(ctx context.Context, resourceURI string, linkerName string, parameters LinkerPatch, options *LinkerClientBeginUpdateOptions) (*runtime.Poller[LinkerClientUpdateResponse], error)

BeginUpdate - Operation to update an existing Linker. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • linkerName - The name Linker resource.
  • parameters - Linker details.
  • options - LinkerClientBeginUpdateOptions contains the optional parameters for the LinkerClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/PatchLinker.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewLinkerClient().BeginUpdate(ctx, "subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app", "linkName", armservicelinker.LinkerPatch{
	Properties: &armservicelinker.LinkerProperties{
		AuthInfo: &armservicelinker.ServicePrincipalSecretAuthInfo{
			AuthType:    to.Ptr(armservicelinker.AuthTypeServicePrincipalSecret),
			ClientID:    to.Ptr("name"),
			PrincipalID: to.Ptr("id"),
			Secret:      to.Ptr("secret"),
		},
		TargetService: &armservicelinker.AzureResource{
			Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
			ID:   to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.LinkerResource = armservicelinker.LinkerResource{
// 	Name: to.Ptr("linkName"),
// 	Type: to.Ptr("Microsoft.ServiceLinker/links"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app/providers/Microsoft.ServiceLinker/links/linkName"),
// 	Properties: &armservicelinker.LinkerProperties{
// 		AuthInfo: &armservicelinker.ServicePrincipalSecretAuthInfo{
// 			AuthType: to.Ptr(armservicelinker.AuthTypeServicePrincipalSecret),
// 			ClientID: to.Ptr("name"),
// 			PrincipalID: to.Ptr("id"),
// 		},
// 		TargetService: &armservicelinker.AzureResource{
// 			Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
// 		},
// 	},
// }

Output:

func (*LinkerClient) BeginValidate 

func (client *LinkerClient) BeginValidate(ctx context.Context, resourceURI string, linkerName string, options *LinkerClientBeginValidateOptions) (*runtime.Poller[LinkerClientValidateResponse], error)

BeginValidate - Validate a Linker. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • linkerName - The name Linker resource.
  • options - LinkerClientBeginValidateOptions contains the optional parameters for the LinkerClient.BeginValidate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/ValidateLinkerSuccess.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewLinkerClient().BeginValidate(ctx, "subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app", "linkName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ValidateOperationResult = armservicelinker.ValidateOperationResult{
// 	Properties: &armservicelinker.ValidateResult{
// 		AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
// 		IsConnectionAvailable: to.Ptr(true),
// 		ReportEndTimeUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-07-12T22:06:09.000Z"); return t}()),
// 		ReportStartTimeUTC: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-07-12T22:05:09.000Z"); return t}()),
// 		SourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
// 		TargetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
// 		ValidationDetail: []*armservicelinker.ValidationResultItem{
// 			{
// 				Name: to.Ptr("TargetExistence"),
// 				Description: to.Ptr("The target existence is validated"),
// 				Result: to.Ptr(armservicelinker.ValidationResultStatusSuccess),
// 			},
// 			{
// 				Name: to.Ptr("TargetNetworkAccess"),
// 				Description: to.Ptr("Deny public network access is set to yes. Please confirm you are using private endpoint connection to access target resource."),
// 				Result: to.Ptr(armservicelinker.ValidationResultStatusWarning),
// 		}},
// 	},
// }

Output:

func (*LinkerClient) Get 

func (client *LinkerClient) Get(ctx context.Context, resourceURI string, linkerName string, options *LinkerClientGetOptions) (LinkerClientGetResponse, error)

Get - Returns Linker resource for a given name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • linkerName - The name Linker resource.
  • options - LinkerClientGetOptions contains the optional parameters for the LinkerClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/Linker.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewLinkerClient().Get(ctx, "subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app", "linkName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.LinkerResource = armservicelinker.LinkerResource{
// 	Name: to.Ptr("linkName"),
// 	Type: to.Ptr("Microsoft.ServiceLinker/links"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app/providers/Microsoft.ServiceLinker/links/linkName"),
// 	SystemData: &armservicelinker.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-07-12T22:05:09.000Z"); return t}()),
// 	},
// 	Properties: &armservicelinker.LinkerProperties{
// 		AuthInfo: &armservicelinker.SecretAuthInfo{
// 			AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
// 			Name: to.Ptr("name"),
// 		},
// 		ClientType: to.Ptr(armservicelinker.ClientTypeDotnet),
// 		ConfigurationInfo: &armservicelinker.ConfigurationInfo{
// 			AdditionalConfigurations: map[string]*string{
// 				"throttlingLimit": to.Ptr("100"),
// 			},
// 			CustomizedKeys: map[string]*string{
// 				"AZURE_MYSQL_CONNECTIONSTRING": to.Ptr("myConnectionstring"),
// 				"AZURE_MYSQL_SSLMODE": to.Ptr("mySslmode"),
// 			},
// 			DeleteOrUpdateBehavior: to.Ptr(armservicelinker.DeleteOrUpdateBehaviorForcedCleanup),
// 		},
// 		PublicNetworkSolution: &armservicelinker.PublicNetworkSolution{
// 			Action: to.Ptr(armservicelinker.ActionTypeEnable),
// 		},
// 		Scope: to.Ptr("AKS-Namespace"),
// 		SecretStore: &armservicelinker.SecretStore{
// 			KeyVaultID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.KeyVault/vaults/kvname"),
// 		},
// 		TargetService: &armservicelinker.AzureResource{
// 			Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
// 		},
// 	},
// }

Output:

func (*LinkerClient) ListConfigurations 

func (client *LinkerClient) ListConfigurations(ctx context.Context, resourceURI string, linkerName string, options *LinkerClientListConfigurationsOptions) (LinkerClientListConfigurationsResponse, error)

ListConfigurations - list source configurations for a Linker. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • linkerName - The name Linker resource.
  • options - LinkerClientListConfigurationsOptions contains the optional parameters for the LinkerClient.ListConfigurations method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/GetConfigurations.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewLinkerClient().ListConfigurations(ctx, "subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.App/containerApps/test-app", "linkName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ConfigurationResult = armservicelinker.ConfigurationResult{
// 	Configurations: []*armservicelinker.SourceConfiguration{
// 		{
// 			Name: to.Ptr("AZURE_POSTGRESQL_HOST"),
// 			ConfigType: to.Ptr(armservicelinker.LinkerConfigurationTypeDefault),
// 			Value: to.Ptr("Host"),
// 		},
// 		{
// 			Name: to.Ptr("AZURE_POSTGRESQL_USER"),
// 			ConfigType: to.Ptr(armservicelinker.LinkerConfigurationTypeDefault),
// 			Value: to.Ptr("Username"),
// 		},
// 		{
// 			Name: to.Ptr("AZURE_POSTGRESQL_DATABASE"),
// 			ConfigType: to.Ptr(armservicelinker.LinkerConfigurationTypeDefault),
// 			Value: to.Ptr("DatabaseName"),
// 		},
// 		{
// 			Name: to.Ptr("AZURE_POSTGRESQL_PORT"),
// 			ConfigType: to.Ptr(armservicelinker.LinkerConfigurationTypeDefault),
// 			Value: to.Ptr("Port"),
// 		},
// 		{
// 			Name: to.Ptr("AZURE_POSTGRESQL_PASSWORD"),
// 			ConfigType: to.Ptr(armservicelinker.LinkerConfigurationTypeKeyVaultSecret),
// 			KeyVaultReferenceIdentity: to.Ptr("system"),
// 			Value: to.Ptr("SecretUri"),
// 	}},
// }

Output:

func (*LinkerClient) NewListPager 

func (client *LinkerClient) NewListPager(resourceURI string, options *LinkerClientListOptions) *runtime.Pager[LinkerClientListResponse]

NewListPager - Returns list of Linkers which connects to the resource. which supports to config both application and target service during the resource provision.

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • options - LinkerClientListOptions contains the optional parameters for the LinkerClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/LinkerList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewLinkerClient().NewListPager("subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.ResourceList = armservicelinker.ResourceList{
	// 	Value: []*armservicelinker.LinkerResource{
	// 		{
	// 			Name: to.Ptr("linkName"),
	// 			Type: to.Ptr("Microsoft.ServiceLinker/links"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.ServiceLinker/links/linkName"),
	// 			SystemData: &armservicelinker.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-07-12T22:05:09.000Z"); return t}()),
	// 			},
	// 			Properties: &armservicelinker.LinkerProperties{
	// 				AuthInfo: &armservicelinker.SecretAuthInfo{
	// 					AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
	// 					Name: to.Ptr("username"),
	// 				},
	// 				TargetService: &armservicelinker.AzureResource{
	// 					Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
	// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

type LinkerClientBeginCreateOrUpdateOptions 

type LinkerClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

LinkerClientBeginCreateOrUpdateOptions contains the optional parameters for the LinkerClient.BeginCreateOrUpdate method.

type LinkerClientBeginDeleteOptions 

type LinkerClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

LinkerClientBeginDeleteOptions contains the optional parameters for the LinkerClient.BeginDelete method.

type LinkerClientBeginUpdateOptions 

type LinkerClientBeginUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

LinkerClientBeginUpdateOptions contains the optional parameters for the LinkerClient.BeginUpdate method.

type LinkerClientBeginValidateOptions 

type LinkerClientBeginValidateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

LinkerClientBeginValidateOptions contains the optional parameters for the LinkerClient.BeginValidate method.

type LinkerClientCreateOrUpdateResponse 

type LinkerClientCreateOrUpdateResponse struct {
	// Linker of source and target resource
	LinkerResource
}

LinkerClientCreateOrUpdateResponse contains the response from method LinkerClient.BeginCreateOrUpdate.

type LinkerClientDeleteResponse 

type LinkerClientDeleteResponse struct {
}

LinkerClientDeleteResponse contains the response from method LinkerClient.BeginDelete.

type LinkerClientGetOptions 

type LinkerClientGetOptions struct {
}

LinkerClientGetOptions contains the optional parameters for the LinkerClient.Get method.

type LinkerClientGetResponse 

type LinkerClientGetResponse struct {
	// Linker of source and target resource
	LinkerResource
}

LinkerClientGetResponse contains the response from method LinkerClient.Get.

type LinkerClientListConfigurationsOptions 

type LinkerClientListConfigurationsOptions struct {
}

LinkerClientListConfigurationsOptions contains the optional parameters for the LinkerClient.ListConfigurations method.

type LinkerClientListConfigurationsResponse 

type LinkerClientListConfigurationsResponse struct {
	// Configurations for source resource, include appSettings, connectionString and serviceBindings
	ConfigurationResult
}

LinkerClientListConfigurationsResponse contains the response from method LinkerClient.ListConfigurations.

type LinkerClientListOptions 

type LinkerClientListOptions struct {
}

LinkerClientListOptions contains the optional parameters for the LinkerClient.NewListPager method.

type LinkerClientListResponse 

type LinkerClientListResponse struct {
	// The list of Linker.
	ResourceList
}

LinkerClientListResponse contains the response from method LinkerClient.NewListPager.

type LinkerClientUpdateResponse 

type LinkerClientUpdateResponse struct {
	// Linker of source and target resource
	LinkerResource
}

LinkerClientUpdateResponse contains the response from method LinkerClient.BeginUpdate.

type LinkerClientValidateResponse 

type LinkerClientValidateResponse struct {
	// The validation operation result for a Linker.
	ValidateOperationResult
}

LinkerClientValidateResponse contains the response from method LinkerClient.BeginValidate.

type LinkerConfigurationType 

type LinkerConfigurationType string

LinkerConfigurationType - Type of configuration to determine whether the configuration can be modified after creation. KeyvaultSecret means the configuration references a key vault secret, such as App Service/ACA key vault reference. Default means the configuration is real value, such as user name, raw secret, etc. 

const (
	LinkerConfigurationTypeDefault        LinkerConfigurationType = "Default"
	LinkerConfigurationTypeKeyVaultSecret LinkerConfigurationType = "KeyVaultSecret"
)

func PossibleLinkerConfigurationTypeValues 

func PossibleLinkerConfigurationTypeValues() []LinkerConfigurationType

PossibleLinkerConfigurationTypeValues returns the possible values for the LinkerConfigurationType const type.

type LinkerPatch 

type LinkerPatch struct {
	// Linker properties
	Properties *LinkerProperties
}

LinkerPatch - A Linker to be updated.

func (LinkerPatch) MarshalJSON 

func (l LinkerPatch) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LinkerPatch.

func (*LinkerPatch) UnmarshalJSON 

func (l *LinkerPatch) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LinkerPatch.

type LinkerProperties 

type LinkerProperties struct {
	// The authentication type.
	AuthInfo AuthInfoBaseClassification

	// The application client type
	ClientType *ClientType

	// The connection information consumed by applications, including secrets, connection strings.
	ConfigurationInfo *ConfigurationInfo

	// The network solution.
	PublicNetworkSolution *PublicNetworkSolution

	// connection scope in source service.
	Scope *string

	// An option to store secret value in secure place
	SecretStore *SecretStore

	// The target service properties
	TargetService TargetServiceBaseClassification

	// The VNet solution.
	VNetSolution *VNetSolution

	// READ-ONLY; The provisioning state.
	ProvisioningState *string
}

LinkerProperties - The properties of the Linker.

func (LinkerProperties) MarshalJSON 

func (l LinkerProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LinkerProperties.

func (*LinkerProperties) UnmarshalJSON 

func (l *LinkerProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LinkerProperties.

type LinkerResource 

type LinkerResource struct {
	// REQUIRED; The properties of the Linker.
	Properties *LinkerProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

LinkerResource - Linker of source and target resource

func (LinkerResource) MarshalJSON 

func (l LinkerResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LinkerResource.

func (*LinkerResource) UnmarshalJSON 

func (l *LinkerResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LinkerResource.

type LinkersClient 

type LinkersClient struct {
	// contains filtered or unexported fields
}

LinkersClient contains the methods for the Linkers group. Don't use this type directly, use NewLinkersClient() instead.

func NewLinkersClient 

func NewLinkersClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*LinkersClient, error)

NewLinkersClient creates a new instance of LinkersClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*LinkersClient) BeginCreateDryrun 

func (client *LinkersClient) BeginCreateDryrun(ctx context.Context, resourceURI string, dryrunName string, parameters DryrunResource, options *LinkersClientBeginCreateDryrunOptions) (*runtime.Poller[LinkersClientCreateDryrunResponse], error)

BeginCreateDryrun - create a dryrun job to do necessary check before actual creation If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • dryrunName - The name of dryrun.
  • parameters - dryrun resource.
  • options - LinkersClientBeginCreateDryrunOptions contains the optional parameters for the LinkersClient.BeginCreateDryrun method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/PutDryrun.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewLinkersClient().BeginCreateDryrun(ctx, "subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app", "dryrunName", armservicelinker.DryrunResource{
	Properties: &armservicelinker.DryrunProperties{
		Parameters: &armservicelinker.CreateOrUpdateDryrunParameters{
			ActionName: to.Ptr(armservicelinker.DryrunActionNameCreateOrUpdate),
			AuthInfo: &armservicelinker.SecretAuthInfo{
				AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
				Name:     to.Ptr("name"),
				SecretInfo: &armservicelinker.ValueSecretInfo{
					SecretType: to.Ptr(armservicelinker.SecretTypeRawValue),
					Value:      to.Ptr("secret"),
				},
			},
			TargetService: &armservicelinker.AzureResource{
				Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
				ID:   to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
			},
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.DryrunResource = armservicelinker.DryrunResource{
// 	Name: to.Ptr("dryrunName"),
// 	Type: to.Ptr("Microsoft.ServiceLinker/dryruns"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app/providers/Microsoft.ServiceLinker/dryruns/dryrunName"),
// 	Properties: &armservicelinker.DryrunProperties{
// 		OperationPreviews: []*armservicelinker.DryrunOperationPreview{
// 			{
// 				Name: to.Ptr("configFirewallRule"),
// 				Description: to.Ptr("Config firewall rule for target service to allow source service access"),
// 				Action: to.Ptr("Microsoft.DocumentDb/databaseAccounts/write"),
// 				OperationType: to.Ptr(armservicelinker.DryrunPreviewOperationTypeConfigNetwork),
// 				Scope: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc"),
// 		}},
// 		Parameters: &armservicelinker.CreateOrUpdateDryrunParameters{
// 			ActionName: to.Ptr(armservicelinker.DryrunActionNameCreateOrUpdate),
// 			AuthInfo: &armservicelinker.SecretAuthInfo{
// 				AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
// 				Name: to.Ptr("name"),
// 			},
// 			TargetService: &armservicelinker.AzureResource{
// 				Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
// 			},
// 		},
// 		PrerequisiteResults: []armservicelinker.DryrunPrerequisiteResultClassification{
// 			&armservicelinker.BasicErrorDryrunPrerequisiteResult{
// 				Type: to.Ptr(armservicelinker.DryrunPrerequisiteResultTypeBasicError),
// 				Code: to.Ptr("ResourceNotFound"),
// 				Message: to.Ptr("Target resource is not found"),
// 			},
// 			&armservicelinker.PermissionsMissingDryrunPrerequisiteResult{
// 				Type: to.Ptr(armservicelinker.DryrunPrerequisiteResultTypePermissionsMissing),
// 				Permissions: []*string{
// 					to.Ptr("Microsoft.DocumentDb/databaseAccounts/write")},
// 					Scope: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc"),
// 			}},
// 			ProvisioningState: to.Ptr("Succeeded"),
// 		},
// 	}

Output:

func (*LinkersClient) BeginUpdateDryrun 

func (client *LinkersClient) BeginUpdateDryrun(ctx context.Context, resourceURI string, dryrunName string, parameters DryrunPatch, options *LinkersClientBeginUpdateDryrunOptions) (*runtime.Poller[LinkersClientUpdateDryrunResponse], error)

BeginUpdateDryrun - add a dryrun job to do necessary check before actual creation If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • dryrunName - The name of dryrun.
  • parameters - dryrun resource.
  • options - LinkersClientBeginUpdateDryrunOptions contains the optional parameters for the LinkersClient.BeginUpdateDryrun method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/PatchDryrun.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewLinkersClient().BeginUpdateDryrun(ctx, "subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app", "dryrunName", armservicelinker.DryrunPatch{
	Properties: &armservicelinker.DryrunProperties{
		Parameters: &armservicelinker.CreateOrUpdateDryrunParameters{
			ActionName: to.Ptr(armservicelinker.DryrunActionNameCreateOrUpdate),
			AuthInfo: &armservicelinker.SecretAuthInfo{
				AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
				Name:     to.Ptr("name"),
				SecretInfo: &armservicelinker.ValueSecretInfo{
					SecretType: to.Ptr(armservicelinker.SecretTypeRawValue),
					Value:      to.Ptr("secret"),
				},
			},
			TargetService: &armservicelinker.AzureResource{
				Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
				ID:   to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
			},
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.DryrunResource = armservicelinker.DryrunResource{
// 	Name: to.Ptr("dryrunName"),
// 	Type: to.Ptr("Microsoft.ServiceLinker/dryruns"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app/providers/Microsoft.ServiceLinker/dryruns/dryrunName"),
// 	Properties: &armservicelinker.DryrunProperties{
// 		OperationPreviews: []*armservicelinker.DryrunOperationPreview{
// 			{
// 				Name: to.Ptr("configFirewallRule"),
// 				Description: to.Ptr("Config firewall rule for target service to allow source service access"),
// 				Action: to.Ptr("Microsoft.DocumentDb/databaseAccounts/write"),
// 				OperationType: to.Ptr(armservicelinker.DryrunPreviewOperationTypeConfigNetwork),
// 				Scope: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc"),
// 		}},
// 		Parameters: &armservicelinker.CreateOrUpdateDryrunParameters{
// 			ActionName: to.Ptr(armservicelinker.DryrunActionNameCreateOrUpdate),
// 			AuthInfo: &armservicelinker.SecretAuthInfo{
// 				AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
// 				Name: to.Ptr("name"),
// 			},
// 			TargetService: &armservicelinker.AzureResource{
// 				Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
// 			},
// 		},
// 		PrerequisiteResults: []armservicelinker.DryrunPrerequisiteResultClassification{
// 			&armservicelinker.BasicErrorDryrunPrerequisiteResult{
// 				Type: to.Ptr(armservicelinker.DryrunPrerequisiteResultTypeBasicError),
// 				Code: to.Ptr("ResourceNotFound"),
// 				Message: to.Ptr("Target resource is not found"),
// 			},
// 			&armservicelinker.PermissionsMissingDryrunPrerequisiteResult{
// 				Type: to.Ptr(armservicelinker.DryrunPrerequisiteResultTypePermissionsMissing),
// 				Permissions: []*string{
// 					to.Ptr("Microsoft.DocumentDb/databaseAccounts/write")},
// 					Scope: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc"),
// 			}},
// 			ProvisioningState: to.Ptr("Succeeded"),
// 		},
// 	}

Output:

func (*LinkersClient) DeleteDryrun 

func (client *LinkersClient) DeleteDryrun(ctx context.Context, resourceURI string, dryrunName string, options *LinkersClientDeleteDryrunOptions) (LinkersClientDeleteDryrunResponse, error)

DeleteDryrun - delete a dryrun job If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • dryrunName - The name of dryrun.
  • options - LinkersClientDeleteDryrunOptions contains the optional parameters for the LinkersClient.DeleteDryrun method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/DeleteDryrun.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
_, err = clientFactory.NewLinkersClient().DeleteDryrun(ctx, "subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app", "dryrunName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}

Output:

func (*LinkersClient) GenerateConfigurations 

func (client *LinkersClient) GenerateConfigurations(ctx context.Context, resourceURI string, linkerName string, options *LinkersClientGenerateConfigurationsOptions) (LinkersClientGenerateConfigurationsResponse, error)

GenerateConfigurations - Generate configurations for a Linker. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • linkerName - The name Linker resource.
  • options - LinkersClientGenerateConfigurationsOptions contains the optional parameters for the LinkersClient.GenerateConfigurations method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/LinkerGenerateConfigurations.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewLinkersClient().GenerateConfigurations(ctx, "subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app", "linkName", &armservicelinker.LinkersClientGenerateConfigurationsOptions{Parameters: &armservicelinker.ConfigurationInfo{
	CustomizedKeys: map[string]*string{
		"ASL_DocumentDb_ConnectionString": to.Ptr("MyConnectionstring"),
	},
},
})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.ConfigurationResult = armservicelinker.ConfigurationResult{
// 	Configurations: []*armservicelinker.SourceConfiguration{
// 		{
// 			Name: to.Ptr("MyConnectionstring"),
// 			Value: to.Ptr("ConnectionString"),
// 	}},
// }

Output:

func (*LinkersClient) GetDryrun 

func (client *LinkersClient) GetDryrun(ctx context.Context, resourceURI string, dryrunName string, options *LinkersClientGetDryrunOptions) (LinkersClientGetDryrunResponse, error)

GetDryrun - get a dryrun job If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • dryrunName - The name of dryrun.
  • options - LinkersClientGetDryrunOptions contains the optional parameters for the LinkersClient.GetDryrun method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/GetDryrun.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewLinkersClient().GetDryrun(ctx, "subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app", "dryrunName", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
// You could use response here. We use blank identifier for just demo purposes.
_ = res
// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
// res.DryrunResource = armservicelinker.DryrunResource{
// 	Name: to.Ptr("dryrunName"),
// 	Type: to.Ptr("Microsoft.ServiceLinker/dryruns"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app/providers/Microsoft.ServiceLinker/dryruns/dryrunName"),
// 	SystemData: &armservicelinker.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-07-12T22:05:09.000Z"); return t}()),
// 	},
// 	Properties: &armservicelinker.DryrunProperties{
// 		Parameters: &armservicelinker.CreateOrUpdateDryrunParameters{
// 			ActionName: to.Ptr(armservicelinker.DryrunActionNameCreateOrUpdate),
// 			AuthInfo: &armservicelinker.SecretAuthInfo{
// 				AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
// 				Name: to.Ptr("username"),
// 			},
// 			TargetService: &armservicelinker.AzureResource{
// 				Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
// 			},
// 		},
// 	},
// }

Output:

func (*LinkersClient) NewListDaprConfigurationsPager 

func (client *LinkersClient) NewListDaprConfigurationsPager(resourceURI string, options *LinkersClientListDaprConfigurationsOptions) *runtime.Pager[LinkersClientListDaprConfigurationsResponse]

NewListDaprConfigurationsPager - List the dapr configuration supported by Service Connector.

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • options - LinkersClientListDaprConfigurationsOptions contains the optional parameters for the LinkersClient.NewListDaprConfigurationsPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/GetDaprConfigurations.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewLinkersClient().NewListDaprConfigurationsPager("subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.DaprConfigurationList = armservicelinker.DaprConfigurationList{
	// 	Value: []*armservicelinker.DaprConfigurationResource{
	// 		{
	// 			Properties: &armservicelinker.DaprConfigurationProperties{
	// 				AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
	// 				DaprProperties: &armservicelinker.DaprProperties{
	// 					BindingComponentDirection: to.Ptr(armservicelinker.DaprBindingComponentDirectionInput),
	// 					ComponentType: to.Ptr("bindings"),
	// 					Metadata: []*armservicelinker.DaprMetadata{
	// 						{
	// 							Name: to.Ptr("containerName"),
	// 							Description: to.Ptr("The name of the container to be used for Dapr state."),
	// 							Required: to.Ptr(armservicelinker.DaprMetadataRequiredTrue),
	// 					}},
	// 					RuntimeVersion: to.Ptr("1.10"),
	// 					Version: to.Ptr("v1"),
	// 				},
	// 				TargetType: to.Ptr("MICROSOFT.STORAGE/STORAGEACCOUNTS/BLOBSERVICES"),
	// 			},
	// 	}},
	// }
}

Output:

func (*LinkersClient) NewListDryrunPager 

func (client *LinkersClient) NewListDryrunPager(resourceURI string, options *LinkersClientListDryrunOptions) *runtime.Pager[LinkersClientListDryrunResponse]

NewListDryrunPager - list dryrun jobs

Generated from API version 2023-04-01-preview

  • resourceURI - The fully qualified Azure Resource manager identifier of the resource to be connected.
  • options - LinkersClientListDryrunOptions contains the optional parameters for the LinkersClient.NewListDryrunPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/ListDryrun.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewLinkersClient().NewListDryrunPager("subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app", nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.DryrunList = armservicelinker.DryrunList{
	// 	Value: []*armservicelinker.DryrunResource{
	// 		{
	// 			Name: to.Ptr("dryrunName"),
	// 			Type: to.Ptr("Microsoft.ServiceLinker/dryruns"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.Web/sites/test-app/providers/Microsoft.ServiceLinker/dryruns/dryrunName"),
	// 			SystemData: &armservicelinker.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-07-12T22:05:09.000Z"); return t}()),
	// 			},
	// 			Properties: &armservicelinker.DryrunProperties{
	// 				Parameters: &armservicelinker.CreateOrUpdateDryrunParameters{
	// 					ActionName: to.Ptr(armservicelinker.DryrunActionNameCreateOrUpdate),
	// 					AuthInfo: &armservicelinker.SecretAuthInfo{
	// 						AuthType: to.Ptr(armservicelinker.AuthTypeSecret),
	// 						Name: to.Ptr("username"),
	// 					},
	// 					TargetService: &armservicelinker.AzureResource{
	// 						Type: to.Ptr(armservicelinker.TargetServiceTypeAzureResource),
	// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/test-rg/providers/Microsoft.DocumentDb/databaseAccounts/test-acc/mongodbDatabases/test-db"),
	// 					},
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

type LinkersClientBeginCreateDryrunOptions 

type LinkersClientBeginCreateDryrunOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

LinkersClientBeginCreateDryrunOptions contains the optional parameters for the LinkersClient.BeginCreateDryrun method.

type LinkersClientBeginUpdateDryrunOptions 

type LinkersClientBeginUpdateDryrunOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

LinkersClientBeginUpdateDryrunOptions contains the optional parameters for the LinkersClient.BeginUpdateDryrun method.

type LinkersClientCreateDryrunResponse 

type LinkersClientCreateDryrunResponse struct {
	// a dryrun job resource
	DryrunResource
}

LinkersClientCreateDryrunResponse contains the response from method LinkersClient.BeginCreateDryrun.

type LinkersClientDeleteDryrunOptions 

type LinkersClientDeleteDryrunOptions struct {
}

LinkersClientDeleteDryrunOptions contains the optional parameters for the LinkersClient.DeleteDryrun method.

type LinkersClientDeleteDryrunResponse 

type LinkersClientDeleteDryrunResponse struct {
}

LinkersClientDeleteDryrunResponse contains the response from method LinkersClient.DeleteDryrun.

type LinkersClientGenerateConfigurationsOptions 

type LinkersClientGenerateConfigurationsOptions struct {
	// Connection Info, including format, secret store, etc
	Parameters *ConfigurationInfo
}

LinkersClientGenerateConfigurationsOptions contains the optional parameters for the LinkersClient.GenerateConfigurations method.

type LinkersClientGenerateConfigurationsResponse 

type LinkersClientGenerateConfigurationsResponse struct {
	// Configurations for source resource, include appSettings, connectionString and serviceBindings
	ConfigurationResult
}

LinkersClientGenerateConfigurationsResponse contains the response from method LinkersClient.GenerateConfigurations.

type LinkersClientGetDryrunOptions 

type LinkersClientGetDryrunOptions struct {
}

LinkersClientGetDryrunOptions contains the optional parameters for the LinkersClient.GetDryrun method.

type LinkersClientGetDryrunResponse 

type LinkersClientGetDryrunResponse struct {
	// a dryrun job resource
	DryrunResource
}

LinkersClientGetDryrunResponse contains the response from method LinkersClient.GetDryrun.

type LinkersClientListDaprConfigurationsOptions 

type LinkersClientListDaprConfigurationsOptions struct {
}

LinkersClientListDaprConfigurationsOptions contains the optional parameters for the LinkersClient.NewListDaprConfigurationsPager method.

type LinkersClientListDaprConfigurationsResponse 

type LinkersClientListDaprConfigurationsResponse struct {
	// Dapr configuration list supported by Service Connector
	DaprConfigurationList
}

LinkersClientListDaprConfigurationsResponse contains the response from method LinkersClient.NewListDaprConfigurationsPager.

type LinkersClientListDryrunOptions 

type LinkersClientListDryrunOptions struct {
}

LinkersClientListDryrunOptions contains the optional parameters for the LinkersClient.NewListDryrunPager method.

type LinkersClientListDryrunResponse 

type LinkersClientListDryrunResponse struct {
	// The list of dryrun.
	DryrunList
}

LinkersClientListDryrunResponse contains the response from method LinkersClient.NewListDryrunPager.

type LinkersClientUpdateDryrunResponse 

type LinkersClientUpdateDryrunResponse struct {
	// a dryrun job resource
	DryrunResource
}

LinkersClientUpdateDryrunResponse contains the response from method LinkersClient.BeginUpdateDryrun.

type Operation 

type Operation struct {
	// Localized display information for this particular operation.
	Display *OperationDisplay

	// READ-ONLY; Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
	ActionType *ActionType

	// READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for ARM/control-plane
	// operations.
	IsDataAction *bool

	// READ-ONLY; The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write",
	// "Microsoft.Compute/virtualMachines/capture/action"
	Name *string

	// READ-ONLY; The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default
	// value is "user,system"
	Origin *Origin
}

Operation - Details of a REST API operation, returned from the Resource Provider Operations API

func (Operation) MarshalJSON 

func (o Operation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

func (o *Operation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; The short, localized friendly description of the operation; suitable for tool tips and detailed views.
	Description *string

	// READ-ONLY; The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual
	// Machine", "Restart Virtual Machine".
	Operation *string

	// READ-ONLY; The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft
	// Compute".
	Provider *string

	// READ-ONLY; The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job
	// Schedule Collections".
	Resource *string
}

OperationDisplay - Localized display information for this particular operation.

func (OperationDisplay) MarshalJSON 

func (o OperationDisplay) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

func (o *OperationDisplay) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult 

type OperationListResult struct {
	// READ-ONLY; URL to get the next set of operation list results (if there are any).
	NextLink *string

	// READ-ONLY; List of operations supported by the resource provider
	Value []*Operation
}

OperationListResult - A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.

func (OperationListResult) MarshalJSON 

func (o OperationListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

func (o *OperationListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationsClient 

type OperationsClient struct {
	// contains filtered or unexported fields
}

OperationsClient contains the methods for the Operations group. Don't use this type directly, use NewOperationsClient() instead.

func NewOperationsClient 

func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error)

NewOperationsClient creates a new instance of OperationsClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OperationsClient) NewListPager 

func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse]

NewListPager - Lists the available ServiceLinker REST API operations.

Generated from API version 2023-04-01-preview

  • options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c16ce913afbdaa073e8ca5e480f3b465db2de542/specification/servicelinker/resource-manager/Microsoft.ServiceLinker/preview/2023-04-01-preview/examples/OperationsList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armservicelinker.NewClientFactory(cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewOperationsClient().NewListPager(nil)
for pager.More() {
	page, err := pager.NextPage(ctx)
	if err != nil {
		log.Fatalf("failed to advance page: %v", err)
	}
	for _, v := range page.Value {
		// You could use page here. We use blank identifier for just demo purposes.
		_ = v
	}
	// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// page.OperationListResult = armservicelinker.OperationListResult{
	// 	Value: []*armservicelinker.Operation{
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/register/action"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("Register the subscription for Microsoft.ServiceLinker"),
	// 				Operation: to.Ptr("Register the Microsoft.ServiceLinker"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("Microsoft.ServiceLinker"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/unregister/action"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("Unregister the subscription for Microsoft.ServiceLinker"),
	// 				Operation: to.Ptr("Unregister the Microsoft.ServiceLinker"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("Microsoft.ServiceLinker"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/operations/read"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("read operations"),
	// 				Operation: to.Ptr("read_operations"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("operations"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/dryruns/read"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("list dryrun jobs"),
	// 				Operation: to.Ptr("Dryrun_List"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("dryruns"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/dryruns/read"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("get a dryrun job"),
	// 				Operation: to.Ptr("Dryrun_Get"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("dryruns"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/dryruns/write"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("create a dryrun job to do necessary check before actual creation"),
	// 				Operation: to.Ptr("Dryrun_Create"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("dryruns"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/dryruns/delete"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("delete a dryrun job"),
	// 				Operation: to.Ptr("Dryrun_Delete"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("dryruns"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/dryruns/write"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("add a dryrun job to do necessary check before actual creation"),
	// 				Operation: to.Ptr("Dryrun_Update"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("dryruns"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/locations/operationStatuses/read"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("read operationStatuses"),
	// 				Operation: to.Ptr("read_operationStatuses"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("locations/operationStatuses"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/locations/operationStatuses/write"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("write operationStatuses"),
	// 				Operation: to.Ptr("write_operationStatuses"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("locations/operationStatuses"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/linkers/read"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("Returns list of Linkers which connects to the resource."),
	// 				Operation: to.Ptr("Linker_List"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("linkers"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/linkers/read"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("Returns Linker resource for a given name."),
	// 				Operation: to.Ptr("Linker_Get"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("linkers"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/linkers/write"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("Create or update linker resource."),
	// 				Operation: to.Ptr("Linker_CreateOrUpdate"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("linkers"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/linkers/delete"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("Delete a link."),
	// 				Operation: to.Ptr("Linker_Delete"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("linkers"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/linkers/write"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("Operation to update an existing link."),
	// 				Operation: to.Ptr("Linker_Update"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("linkers"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/linkers/validateLinker/action"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("Validate a link."),
	// 				Operation: to.Ptr("Linker_Validate"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("linkers"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ServiceLinker/linkers/listConfigurations/action"),
	// 			Display: &armservicelinker.OperationDisplay{
	// 				Description: to.Ptr("list source configurations for a linker."),
	// 				Operation: to.Ptr("Linker_ListConfigurations"),
	// 				Provider: to.Ptr("Microsoft.ServiceLinker"),
	// 				Resource: to.Ptr("linkers"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 	}},
	// }
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type Origin 

type Origin string

Origin - The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" 

const (
	OriginSystem     Origin = "system"
	OriginUser       Origin = "user"
	OriginUserSystem Origin = "user,system"
)

func PossibleOriginValues 

func PossibleOriginValues() []Origin

PossibleOriginValues returns the possible values for the Origin const type.

type PermissionsMissingDryrunPrerequisiteResult 

type PermissionsMissingDryrunPrerequisiteResult struct {
	// REQUIRED; The type of dryrun result.
	Type *DryrunPrerequisiteResultType

	// The permission list
	Permissions []*string

	// The recommended role to resolve permissions missing
	RecommendedRole *string

	// The permission scope
	Scope *string
}

PermissionsMissingDryrunPrerequisiteResult - The represent of missing permissions

func (*PermissionsMissingDryrunPrerequisiteResult) GetDryrunPrerequisiteResult 

func (p *PermissionsMissingDryrunPrerequisiteResult) GetDryrunPrerequisiteResult() *DryrunPrerequisiteResult

GetDryrunPrerequisiteResult implements the DryrunPrerequisiteResultClassification interface for type PermissionsMissingDryrunPrerequisiteResult.

func (PermissionsMissingDryrunPrerequisiteResult) MarshalJSON 

func (p PermissionsMissingDryrunPrerequisiteResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PermissionsMissingDryrunPrerequisiteResult.

func (*PermissionsMissingDryrunPrerequisiteResult) UnmarshalJSON 

func (p *PermissionsMissingDryrunPrerequisiteResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PermissionsMissingDryrunPrerequisiteResult.

type ProxyResource 

type ProxyResource struct {
	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

ProxyResource - The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location

func (ProxyResource) MarshalJSON 

func (p ProxyResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProxyResource.

func (*ProxyResource) UnmarshalJSON 

func (p *ProxyResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProxyResource.

type PublicNetworkSolution 

type PublicNetworkSolution struct {
	// Optional. Indicates public network solution. If enable, enable public network access of target service with best try. Default
	// is enable. If optOut, opt out public network access configuration.
	Action *ActionType

	// Indicates whether to clean up previous operation(such as firewall rules) when Linker is updating or deleting
	DeleteOrUpdateBehavior *DeleteOrUpdateBehavior

	// Describe firewall rules of target service to make sure source application could connect to the target.
	FirewallRules *FirewallRules
}

PublicNetworkSolution - Indicates public network solution, include firewall rules

func (PublicNetworkSolution) MarshalJSON 

func (p PublicNetworkSolution) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PublicNetworkSolution.

func (*PublicNetworkSolution) UnmarshalJSON 

func (p *PublicNetworkSolution) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PublicNetworkSolution.

type Resource 

type Resource struct {
	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

Resource - Common fields that are returned in the response for all Azure Resource Manager resources

func (Resource) MarshalJSON 

func (r Resource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Resource.

func (*Resource) UnmarshalJSON 

func (r *Resource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

type ResourceList 

type ResourceList struct {
	// The Linker used to get the next page of Linker list.
	NextLink *string

	// The list of Linkers.
	Value []*LinkerResource
}

ResourceList - The list of Linker.

func (ResourceList) MarshalJSON 

func (r ResourceList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceList.

func (*ResourceList) UnmarshalJSON 

func (r *ResourceList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceList.

type SecretAuthInfo 

type SecretAuthInfo struct {
	// REQUIRED; The authentication type.
	AuthType *AuthType

	// Optional. Indicates how to configure authentication. If optInAllAuth, service linker configures authentication such as
	// enabling identity on source resource and granting RBAC roles. If optOutAllAuth,
	// opt out authentication setup. Default is optInAllAuth.
	AuthMode *AuthMode

	// Username or account name for secret auth.
	Name *string

	// Password or key vault secret for secret auth.
	SecretInfo SecretInfoBaseClassification
}

SecretAuthInfo - The authentication info when authType is secret

func (*SecretAuthInfo) GetAuthInfoBase 

func (s *SecretAuthInfo) GetAuthInfoBase() *AuthInfoBase

GetAuthInfoBase implements the AuthInfoBaseClassification interface for type SecretAuthInfo.

func (SecretAuthInfo) MarshalJSON 

func (s SecretAuthInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecretAuthInfo.

func (*SecretAuthInfo) UnmarshalJSON 

func (s *SecretAuthInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecretAuthInfo.

type SecretInfoBase 

type SecretInfoBase struct {
	// REQUIRED; The secret type.
	SecretType *SecretType
}

SecretInfoBase - The secret info

func (*SecretInfoBase) GetSecretInfoBase 

func (s *SecretInfoBase) GetSecretInfoBase() *SecretInfoBase

GetSecretInfoBase implements the SecretInfoBaseClassification interface for type SecretInfoBase.

func (SecretInfoBase) MarshalJSON 

func (s SecretInfoBase) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecretInfoBase.

func (*SecretInfoBase) UnmarshalJSON 

func (s *SecretInfoBase) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecretInfoBase.

type SecretInfoBaseClassification 

type SecretInfoBaseClassification interface {
	// GetSecretInfoBase returns the SecretInfoBase content of the underlying type.
	GetSecretInfoBase() *SecretInfoBase
}

SecretInfoBaseClassification provides polymorphic access to related types. Call the interface's GetSecretInfoBase() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *KeyVaultSecretReferenceSecretInfo, *KeyVaultSecretURISecretInfo, *SecretInfoBase, *ValueSecretInfo

type SecretSourceType 

type SecretSourceType string

SecretSourceType - The type of secret source. 

const (
	SecretSourceTypeKeyVaultSecret SecretSourceType = "keyVaultSecret"
	SecretSourceTypeRawValue       SecretSourceType = "rawValue"
)

func PossibleSecretSourceTypeValues 

func PossibleSecretSourceTypeValues() []SecretSourceType

PossibleSecretSourceTypeValues returns the possible values for the SecretSourceType const type.

type SecretStore 

type SecretStore struct {
	// The key vault id to store secret
	KeyVaultID *string

	// The key vault secret name to store secret, only valid when storing one secret
	KeyVaultSecretName *string
}

SecretStore - An option to store secret value in secure place

func (SecretStore) MarshalJSON 

func (s SecretStore) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SecretStore.

func (*SecretStore) UnmarshalJSON 

func (s *SecretStore) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SecretStore.

type SecretType 

type SecretType string

SecretType - The secret type. 

const (
	SecretTypeKeyVaultSecretReference SecretType = "keyVaultSecretReference"
	SecretTypeKeyVaultSecretURI       SecretType = "keyVaultSecretUri"
	SecretTypeRawValue                SecretType = "rawValue"
)

func PossibleSecretTypeValues 

func PossibleSecretTypeValues() []SecretType

PossibleSecretTypeValues returns the possible values for the SecretType const type.

type SelfHostedServer 

type SelfHostedServer struct {
	// REQUIRED; The target service type.
	Type *TargetServiceType

	// The endpoint of service.
	Endpoint *string
}

SelfHostedServer - The service properties when target service type is SelfHostedServer

func (*SelfHostedServer) GetTargetServiceBase 

func (s *SelfHostedServer) GetTargetServiceBase() *TargetServiceBase

GetTargetServiceBase implements the TargetServiceBaseClassification interface for type SelfHostedServer.

func (SelfHostedServer) MarshalJSON 

func (s SelfHostedServer) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SelfHostedServer.

func (*SelfHostedServer) UnmarshalJSON 

func (s *SelfHostedServer) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SelfHostedServer.

type ServicePrincipalCertificateAuthInfo 

type ServicePrincipalCertificateAuthInfo struct {
	// REQUIRED; The authentication type.
	AuthType *AuthType

	// REQUIRED; ServicePrincipal certificate for servicePrincipal auth.
	Certificate *string

	// REQUIRED; Application clientId for servicePrincipal auth.
	ClientID *string

	// REQUIRED; Principal Id for servicePrincipal auth.
	PrincipalID *string

	// Optional. Indicates how to configure authentication. If optInAllAuth, service linker configures authentication such as
	// enabling identity on source resource and granting RBAC roles. If optOutAllAuth,
	// opt out authentication setup. Default is optInAllAuth.
	AuthMode *AuthMode

	// Indicates whether to clean up previous operation when Linker is updating or deleting
	DeleteOrUpdateBehavior *DeleteOrUpdateBehavior

	// Optional, this value specifies the Azure roles to be assigned. Automatically
	Roles []*string
}

ServicePrincipalCertificateAuthInfo - The authentication info when authType is servicePrincipal certificate

func (*ServicePrincipalCertificateAuthInfo) GetAuthInfoBase 

func (s *ServicePrincipalCertificateAuthInfo) GetAuthInfoBase() *AuthInfoBase

GetAuthInfoBase implements the AuthInfoBaseClassification interface for type ServicePrincipalCertificateAuthInfo.

func (ServicePrincipalCertificateAuthInfo) MarshalJSON 

func (s ServicePrincipalCertificateAuthInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServicePrincipalCertificateAuthInfo.

func (*ServicePrincipalCertificateAuthInfo) UnmarshalJSON 

func (s *ServicePrincipalCertificateAuthInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServicePrincipalCertificateAuthInfo.

type ServicePrincipalSecretAuthInfo 

type ServicePrincipalSecretAuthInfo struct {
	// REQUIRED; The authentication type.
	AuthType *AuthType

	// REQUIRED; ServicePrincipal application clientId for servicePrincipal auth.
	ClientID *string

	// REQUIRED; Principal Id for servicePrincipal auth.
	PrincipalID *string

	// REQUIRED; Secret for servicePrincipal auth.
	Secret *string

	// Optional. Indicates how to configure authentication. If optInAllAuth, service linker configures authentication such as
	// enabling identity on source resource and granting RBAC roles. If optOutAllAuth,
	// opt out authentication setup. Default is optInAllAuth.
	AuthMode *AuthMode

	// Indicates whether to clean up previous operation when Linker is updating or deleting
	DeleteOrUpdateBehavior *DeleteOrUpdateBehavior

	// Optional, this value specifies the Azure roles to be assigned. Automatically
	Roles []*string

	// Username created in the database which is mapped to a user in AAD.
	UserName *string
}

ServicePrincipalSecretAuthInfo - The authentication info when authType is servicePrincipal secret

func (*ServicePrincipalSecretAuthInfo) GetAuthInfoBase 

func (s *ServicePrincipalSecretAuthInfo) GetAuthInfoBase() *AuthInfoBase

GetAuthInfoBase implements the AuthInfoBaseClassification interface for type ServicePrincipalSecretAuthInfo.

func (ServicePrincipalSecretAuthInfo) MarshalJSON 

func (s ServicePrincipalSecretAuthInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServicePrincipalSecretAuthInfo.

func (*ServicePrincipalSecretAuthInfo) UnmarshalJSON 

func (s *ServicePrincipalSecretAuthInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServicePrincipalSecretAuthInfo.

type SourceConfiguration 

type SourceConfiguration struct {
	// Descriptive information for the configuration
	Description *string

	// The identity for key vault reference, system or user-assigned managed identity ID
	KeyVaultReferenceIdentity *string

	// The name of setting.
	Name *string

	// The value of setting
	Value *string

	// READ-ONLY; The type of setting
	ConfigType *LinkerConfigurationType
}

SourceConfiguration - A configuration item for source resource

func (SourceConfiguration) MarshalJSON 

func (s SourceConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SourceConfiguration.

func (*SourceConfiguration) UnmarshalJSON 

func (s *SourceConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SourceConfiguration.

type SystemAssignedIdentityAuthInfo 

type SystemAssignedIdentityAuthInfo struct {
	// REQUIRED; The authentication type.
	AuthType *AuthType

	// Optional. Indicates how to configure authentication. If optInAllAuth, service linker configures authentication such as
	// enabling identity on source resource and granting RBAC roles. If optOutAllAuth,
	// opt out authentication setup. Default is optInAllAuth.
	AuthMode *AuthMode

	// Indicates whether to clean up previous operation when Linker is updating or deleting
	DeleteOrUpdateBehavior *DeleteOrUpdateBehavior

	// Optional, this value specifies the Azure role to be assigned
	Roles []*string

	// Username created in the database which is mapped to a user in AAD.
	UserName *string
}

SystemAssignedIdentityAuthInfo - The authentication info when authType is systemAssignedIdentity

func (*SystemAssignedIdentityAuthInfo) GetAuthInfoBase 

func (s *SystemAssignedIdentityAuthInfo) GetAuthInfoBase() *AuthInfoBase

GetAuthInfoBase implements the AuthInfoBaseClassification interface for type SystemAssignedIdentityAuthInfo.

func (SystemAssignedIdentityAuthInfo) MarshalJSON 

func (s SystemAssignedIdentityAuthInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SystemAssignedIdentityAuthInfo.

func (*SystemAssignedIdentityAuthInfo) UnmarshalJSON 

func (s *SystemAssignedIdentityAuthInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SystemAssignedIdentityAuthInfo.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

SystemData - Metadata pertaining to creation and last modification of the resource.

func (SystemData) MarshalJSON 

func (s SystemData) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

func (s *SystemData) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type TargetServiceBase 

type TargetServiceBase struct {
	// REQUIRED; The target service type.
	Type *TargetServiceType
}

TargetServiceBase - The target service properties

func (*TargetServiceBase) GetTargetServiceBase 

func (t *TargetServiceBase) GetTargetServiceBase() *TargetServiceBase

GetTargetServiceBase implements the TargetServiceBaseClassification interface for type TargetServiceBase.

func (TargetServiceBase) MarshalJSON 

func (t TargetServiceBase) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TargetServiceBase.

func (*TargetServiceBase) UnmarshalJSON 

func (t *TargetServiceBase) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TargetServiceBase.

type TargetServiceBaseClassification 

type TargetServiceBaseClassification interface {
	// GetTargetServiceBase returns the TargetServiceBase content of the underlying type.
	GetTargetServiceBase() *TargetServiceBase
}

TargetServiceBaseClassification provides polymorphic access to related types. Call the interface's GetTargetServiceBase() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *AzureResource, *ConfluentBootstrapServer, *ConfluentSchemaRegistry, *SelfHostedServer, *TargetServiceBase

type TargetServiceType 

type TargetServiceType string

TargetServiceType - The target service type. 

const (
	TargetServiceTypeAzureResource            TargetServiceType = "AzureResource"
	TargetServiceTypeConfluentBootstrapServer TargetServiceType = "ConfluentBootstrapServer"
	TargetServiceTypeConfluentSchemaRegistry  TargetServiceType = "ConfluentSchemaRegistry"
	TargetServiceTypeSelfHostedServer         TargetServiceType = "SelfHostedServer"
)

func PossibleTargetServiceTypeValues 

func PossibleTargetServiceTypeValues() []TargetServiceType

PossibleTargetServiceTypeValues returns the possible values for the TargetServiceType const type.

type UserAccountAuthInfo 

type UserAccountAuthInfo struct {
	// REQUIRED; The authentication type.
	AuthType *AuthType

	// Optional. Indicates how to configure authentication. If optInAllAuth, service linker configures authentication such as
	// enabling identity on source resource and granting RBAC roles. If optOutAllAuth,
	// opt out authentication setup. Default is optInAllAuth.
	AuthMode *AuthMode

	// Indicates whether to clean up previous operation when Linker is updating or deleting
	DeleteOrUpdateBehavior *DeleteOrUpdateBehavior

	// Principal Id for user account.
	PrincipalID *string

	// Optional, this value specifies the Azure roles to be assigned. Automatically
	Roles []*string

	// Username created in the database which is mapped to a user in AAD.
	UserName *string
}

UserAccountAuthInfo - The authentication info when authType is user account

func (*UserAccountAuthInfo) GetAuthInfoBase 

func (u *UserAccountAuthInfo) GetAuthInfoBase() *AuthInfoBase

GetAuthInfoBase implements the AuthInfoBaseClassification interface for type UserAccountAuthInfo.

func (UserAccountAuthInfo) MarshalJSON 

func (u UserAccountAuthInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserAccountAuthInfo.

func (*UserAccountAuthInfo) UnmarshalJSON 

func (u *UserAccountAuthInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserAccountAuthInfo.

type UserAssignedIdentityAuthInfo 

type UserAssignedIdentityAuthInfo struct {
	// REQUIRED; The authentication type.
	AuthType *AuthType

	// Optional. Indicates how to configure authentication. If optInAllAuth, service linker configures authentication such as
	// enabling identity on source resource and granting RBAC roles. If optOutAllAuth,
	// opt out authentication setup. Default is optInAllAuth.
	AuthMode *AuthMode

	// Client Id for userAssignedIdentity.
	ClientID *string

	// Indicates whether to clean up previous operation when Linker is updating or deleting
	DeleteOrUpdateBehavior *DeleteOrUpdateBehavior

	// Optional, this value specifies the Azure role to be assigned
	Roles []*string

	// Subscription id for userAssignedIdentity.
	SubscriptionID *string

	// Username created in the database which is mapped to a user in AAD.
	UserName *string
}

UserAssignedIdentityAuthInfo - The authentication info when authType is userAssignedIdentity

func (*UserAssignedIdentityAuthInfo) GetAuthInfoBase 

func (u *UserAssignedIdentityAuthInfo) GetAuthInfoBase() *AuthInfoBase

GetAuthInfoBase implements the AuthInfoBaseClassification interface for type UserAssignedIdentityAuthInfo.

func (UserAssignedIdentityAuthInfo) MarshalJSON 

func (u UserAssignedIdentityAuthInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentityAuthInfo.

func (*UserAssignedIdentityAuthInfo) UnmarshalJSON 

func (u *UserAssignedIdentityAuthInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentityAuthInfo.

type VNetSolution 

type VNetSolution struct {
	// Indicates whether to clean up previous operation when Linker is updating or deleting
	DeleteOrUpdateBehavior *DeleteOrUpdateBehavior

	// Type of VNet solution.
	Type *VNetSolutionType
}

VNetSolution - The VNet solution for linker

func (VNetSolution) MarshalJSON 

func (v VNetSolution) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VNetSolution.

func (*VNetSolution) UnmarshalJSON 

func (v *VNetSolution) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VNetSolution.

type VNetSolutionType 

type VNetSolutionType string

VNetSolutionType - Type of VNet solution. 

const (
	VNetSolutionTypePrivateLink     VNetSolutionType = "privateLink"
	VNetSolutionTypeServiceEndpoint VNetSolutionType = "serviceEndpoint"
)

func PossibleVNetSolutionTypeValues 

func PossibleVNetSolutionTypeValues() []VNetSolutionType

PossibleVNetSolutionTypeValues returns the possible values for the VNetSolutionType const type.

type ValidateOperationResult 

type ValidateOperationResult struct {
	// The validation result detail.
	Properties *ValidateResult

	// Validated Linker id.
	ResourceID *string

	// Validation operation status.
	Status *string
}

ValidateOperationResult - The validation operation result for a Linker.

func (ValidateOperationResult) MarshalJSON 

func (v ValidateOperationResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidateOperationResult.

func (*ValidateOperationResult) UnmarshalJSON 

func (v *ValidateOperationResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidateOperationResult.

type ValidateResult 

type ValidateResult struct {
	// The authentication type.
	AuthType *AuthType

	// A boolean value indicating whether the connection is available or not
	IsConnectionAvailable *bool

	// The linker name.
	LinkerName *string

	// The end time of the validation report.
	ReportEndTimeUTC *time.Time

	// The start time of the validation report.
	ReportStartTimeUTC *time.Time

	// The resource id of the Linker source application.
	SourceID *string

	// The resource Id of target service.
	TargetID *string

	// The detail of validation result
	ValidationDetail []*ValidationResultItem
}

ValidateResult - The validation result for a Linker.

func (ValidateResult) MarshalJSON 

func (v ValidateResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidateResult.

func (*ValidateResult) UnmarshalJSON 

func (v *ValidateResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidateResult.

type ValidationResultItem 

type ValidationResultItem struct {
	// The display name of validation item
	Description *string

	// The error code of validation result
	ErrorCode *string

	// The error message of validation result
	ErrorMessage *string

	// The validation item name.
	Name *string

	// The result of validation
	Result *ValidationResultStatus
}

ValidationResultItem - The validation item for a Linker.

func (ValidationResultItem) MarshalJSON 

func (v ValidationResultItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidationResultItem.

func (*ValidationResultItem) UnmarshalJSON 

func (v *ValidationResultItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidationResultItem.

type ValidationResultStatus 

type ValidationResultStatus string

ValidationResultStatus - The result of validation 

const (
	ValidationResultStatusFailure ValidationResultStatus = "failure"
	ValidationResultStatusSuccess ValidationResultStatus = "success"
	ValidationResultStatusWarning ValidationResultStatus = "warning"
)

func PossibleValidationResultStatusValues 

func PossibleValidationResultStatusValues() []ValidationResultStatus

PossibleValidationResultStatusValues returns the possible values for the ValidationResultStatus const type.

type ValueSecretInfo 

type ValueSecretInfo struct {
	// REQUIRED; The secret type.
	SecretType *SecretType

	// The actual value of the secret.
	Value *string
}

ValueSecretInfo - The secret info when type is rawValue. It's for scenarios that user input the secret.

func (*ValueSecretInfo) GetSecretInfoBase 

func (v *ValueSecretInfo) GetSecretInfoBase() *SecretInfoBase

GetSecretInfoBase implements the SecretInfoBaseClassification interface for type ValueSecretInfo.

func (ValueSecretInfo) MarshalJSON 

func (v ValueSecretInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValueSecretInfo.

func (*ValueSecretInfo) UnmarshalJSON 

func (v *ValueSecretInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValueSecretInfo.

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.