armanalysisservices

package module
v0.0.0-...-45adee8 Latest Latest
Warning

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

 Go to latest Published: Dec 1, 2024 License: MIT Imports: 12 Imported by: 0

README

Azure Analysis Services Module for Go

The armanalysisservices module provides operations for working with Azure Analysis Services.

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 Analysis Services module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Analysis Services. 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 Analysis Services 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 := armanalysisservices.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 := armanalysisservices.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.NewServersClient()

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 Analysis Services 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 CheckServerNameAvailabilityParameters 

type CheckServerNameAvailabilityParameters struct {
	// Name for checking availability.
	Name *string

	// The resource type of azure analysis services.
	Type *string
}

CheckServerNameAvailabilityParameters - Details of server name request body.

func (CheckServerNameAvailabilityParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CheckServerNameAvailabilityParameters.

func (*CheckServerNameAvailabilityParameters) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckServerNameAvailabilityParameters.

type CheckServerNameAvailabilityResult 

type CheckServerNameAvailabilityResult struct {
	// The detailed message of the request unavailability.
	Message *string

	// Indicator of available of the server name.
	NameAvailable *bool

	// The reason of unavailability.
	Reason *string
}

CheckServerNameAvailabilityResult - The checking result of server name availability.

func (CheckServerNameAvailabilityResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CheckServerNameAvailabilityResult.

func (*CheckServerNameAvailabilityResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckServerNameAvailabilityResult.

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(subscriptionID string, 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.

  • subscriptionID - A unique identifier for a Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewServersClient 

func (c *ClientFactory) NewServersClient() *ServersClient

NewServersClient creates a new instance of ServersClient.

type ConnectionMode 

type ConnectionMode string

ConnectionMode - How the read-write server's participation in the query pool is controlled. It can have the following values: * readOnly - indicates that the read-write server is intended not to participate in query operations * all - indicates that the read-write server can participate in query operations Specifying readOnly when capacity is 1 results in error. 

const (
	ConnectionModeAll      ConnectionMode = "All"
	ConnectionModeReadOnly ConnectionMode = "ReadOnly"
)

func PossibleConnectionModeValues 

func PossibleConnectionModeValues() []ConnectionMode

PossibleConnectionModeValues returns the possible values for the ConnectionMode const type.

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 http status code
	HTTPStatusCode *int32

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

	// READ-ONLY; The error sub code
	SubCode *int32

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

	// READ-ONLY; the timestamp for the error.
	TimeStamp *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 - Describes the format of Error response.

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 GatewayDetails 

type GatewayDetails struct {
	// Gateway resource to be associated with the server.
	GatewayResourceID *string

	// READ-ONLY; Uri of the DMTS cluster.
	DmtsClusterURI *string

	// READ-ONLY; Gateway object id from in the DMTS cluster for the gateway resource.
	GatewayObjectID *string
}

GatewayDetails - The gateway details.

func (GatewayDetails) MarshalJSON 

func (g GatewayDetails) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GatewayDetails.

func (*GatewayDetails) UnmarshalJSON 

func (g *GatewayDetails) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GatewayDetails.

type GatewayListStatusError 

type GatewayListStatusError struct {
	// Error of the list gateway status.
	Error *ErrorDetail
}

GatewayListStatusError - Status of gateway is error.

func (GatewayListStatusError) MarshalJSON 

func (g GatewayListStatusError) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GatewayListStatusError.

func (*GatewayListStatusError) UnmarshalJSON 

func (g *GatewayListStatusError) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GatewayListStatusError.

type GatewayListStatusLive 

type GatewayListStatusLive struct {
	// Live message of list gateway. Status: 0 - Live
	Status *int32
}

GatewayListStatusLive - Status of gateway is live.

func (GatewayListStatusLive) MarshalJSON 

func (g GatewayListStatusLive) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GatewayListStatusLive.

func (*GatewayListStatusLive) UnmarshalJSON 

func (g *GatewayListStatusLive) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GatewayListStatusLive.

type IPv4FirewallRule 

type IPv4FirewallRule struct {
	// The rule name.
	FirewallRuleName *string

	// The end range of IPv4.
	RangeEnd *string

	// The start range of IPv4.
	RangeStart *string
}

IPv4FirewallRule - The detail of firewall rule.

func (IPv4FirewallRule) MarshalJSON 

func (i IPv4FirewallRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPv4FirewallRule.

func (*IPv4FirewallRule) UnmarshalJSON 

func (i *IPv4FirewallRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPv4FirewallRule.

type IPv4FirewallSettings 

type IPv4FirewallSettings struct {
	// The indicator of enabling PBI service.
	EnablePowerBIService *bool

	// An array of firewall rules.
	FirewallRules []*IPv4FirewallRule
}

IPv4FirewallSettings - An array of firewall rules.

func (IPv4FirewallSettings) MarshalJSON 

func (i IPv4FirewallSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPv4FirewallSettings.

func (*IPv4FirewallSettings) UnmarshalJSON 

func (i *IPv4FirewallSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPv4FirewallSettings.

type LogSpecifications 

type LogSpecifications struct {
	// READ-ONLY; The blob duration for the log.
	BlobDuration *string

	// READ-ONLY; The displayed name of log.
	DisplayName *string

	// READ-ONLY; The name of metric.
	Name *string
}

LogSpecifications - The log metric specification for exposing performance metrics to shoebox.

func (LogSpecifications) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LogSpecifications.

func (*LogSpecifications) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LogSpecifications.

type ManagedMode 

type ManagedMode int32

ManagedMode - The managed mode of the server (0 = not managed, 1 = managed). 

const (
	ManagedModeOne  ManagedMode = 1
	ManagedModeZero ManagedMode = 0
)

func PossibleManagedModeValues 

func PossibleManagedModeValues() []ManagedMode

PossibleManagedModeValues returns the possible values for the ManagedMode const type.

type MetricDimensions 

type MetricDimensions struct {
	// READ-ONLY; Dimension display name.
	DisplayName *string

	// READ-ONLY; Dimension name.
	Name *string
}

MetricDimensions - Metric dimension.

func (MetricDimensions) MarshalJSON 

func (m MetricDimensions) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MetricDimensions.

func (*MetricDimensions) UnmarshalJSON 

func (m *MetricDimensions) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MetricDimensions.

type MetricSpecifications 

type MetricSpecifications struct {
	// READ-ONLY; The aggregation type of metric.
	AggregationType *string

	// READ-ONLY; The dimensions of metric.
	Dimensions []*MetricDimensions

	// READ-ONLY; The displayed description of metric.
	DisplayDescription *string

	// READ-ONLY; The displayed name of metric.
	DisplayName *string

	// READ-ONLY; The name of metric.
	Name *string

	// READ-ONLY; The unit of the metric.
	Unit *string
}

MetricSpecifications - Available operation metric specification for exposing performance metrics to shoebox.

func (MetricSpecifications) MarshalJSON 

func (m MetricSpecifications) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MetricSpecifications.

func (*MetricSpecifications) UnmarshalJSON 

func (m *MetricSpecifications) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MetricSpecifications.

type Operation 

type Operation struct {
	// The object that represents the operation.
	Display *OperationDisplay

	// Additional properties to expose performance metrics to shoebox.
	Properties *OperationProperties

	// READ-ONLY; Operation name: {provider}/{resource}/{operation}.
	Name *string

	// READ-ONLY; The origin
	Origin *string
}

Operation - A Consumption REST API operation.

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; Description of the operation object.
	Description *string

	// READ-ONLY; Operation type: Read, write, delete, etc.
	Operation *string

	// READ-ONLY; Service provider: Microsoft.Consumption.
	Provider *string

	// READ-ONLY; Resource on which the operation is performed: UsageDetail, etc.
	Resource *string
}

OperationDisplay - The object that represents the 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 analysis services operations supported by the Microsoft.AnalysisServices resource provider.
	Value []*Operation
}

OperationListResult - Result of listing consumption operations. It contains a list of operations and a 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 OperationProperties 

type OperationProperties struct {
	// Performance metrics to shoebox.
	ServiceSpecification *OperationPropertiesServiceSpecification
}

OperationProperties - Additional properties to expose performance metrics to shoebox.

func (OperationProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationProperties.

func (*OperationProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationProperties.

type OperationPropertiesServiceSpecification 

type OperationPropertiesServiceSpecification struct {
	// READ-ONLY; The log specifications.
	LogSpecifications []*LogSpecifications

	// READ-ONLY; The metric specifications.
	MetricSpecifications []*MetricSpecifications
}

OperationPropertiesServiceSpecification - Performance metrics to shoebox.

func (OperationPropertiesServiceSpecification) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationPropertiesServiceSpecification.

func (*OperationPropertiesServiceSpecification) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationPropertiesServiceSpecification.

type OperationStatus 

type OperationStatus struct {
	// The end time of the operation.
	EndTime *string

	// The error detail of the operation if any.
	Error *ErrorDetail

	// The operation Id.
	ID *string

	// The operation name.
	Name *string

	// The start time of the operation.
	StartTime *string

	// The status of the operation.
	Status *string
}

OperationStatus - The status of operation.

func (OperationStatus) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationStatus.

func (*OperationStatus) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationStatus.

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 all of the available consumption REST API operations.

Generated from API version 2017-08-01

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

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// Result of listing consumption operations. It contains a list of operations and a URL link to get the next set of results.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - The current deployment state of Analysis Services resource. The provisioningState is to indicate states for resource provisioning. 

const (
	ProvisioningStateDeleting     ProvisioningState = "Deleting"
	ProvisioningStateFailed       ProvisioningState = "Failed"
	ProvisioningStatePaused       ProvisioningState = "Paused"
	ProvisioningStatePausing      ProvisioningState = "Pausing"
	ProvisioningStatePreparing    ProvisioningState = "Preparing"
	ProvisioningStateProvisioning ProvisioningState = "Provisioning"
	ProvisioningStateResuming     ProvisioningState = "Resuming"
	ProvisioningStateScaling      ProvisioningState = "Scaling"
	ProvisioningStateSucceeded    ProvisioningState = "Succeeded"
	ProvisioningStateSuspended    ProvisioningState = "Suspended"
	ProvisioningStateSuspending   ProvisioningState = "Suspending"
	ProvisioningStateUpdating     ProvisioningState = "Updating"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type Resource 

type Resource struct {
	// REQUIRED; Location of the Analysis Services resource.
	Location *string

	// REQUIRED; The SKU of the Analysis Services resource.
	SKU *ResourceSKU

	// Key-value pairs of additional resource provisioning properties.
	Tags map[string]*string

	// READ-ONLY; An identifier that represents the Analysis Services resource.
	ID *string

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

	// READ-ONLY; The type of the Analysis Services resource.
	Type *string
}

Resource - Represents an instance of an Analysis Services resource.

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 ResourceSKU 

type ResourceSKU struct {
	// REQUIRED; Name of the SKU level.
	Name *string

	// The number of instances in the read only query pool.
	Capacity *int32

	// The name of the Azure pricing tier to which the SKU applies.
	Tier *SKUTier
}

ResourceSKU - Represents the SKU name and Azure pricing tier for Analysis Services resource.

func (ResourceSKU) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ResourceSKU.

func (*ResourceSKU) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceSKU.

type SKUDetailsForExistingResource 

type SKUDetailsForExistingResource struct {
	// The resource type.
	ResourceType *string

	// The SKU in SKU details for existing resources.
	SKU *ResourceSKU
}

SKUDetailsForExistingResource - An object that represents SKU details for existing resources.

func (SKUDetailsForExistingResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SKUDetailsForExistingResource.

func (*SKUDetailsForExistingResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SKUDetailsForExistingResource.

type SKUEnumerationForExistingResourceResult 

type SKUEnumerationForExistingResourceResult struct {
	// The collection of available SKUs for existing resources.
	Value []*SKUDetailsForExistingResource
}

SKUEnumerationForExistingResourceResult - An object that represents enumerating SKUs for existing resources.

func (SKUEnumerationForExistingResourceResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SKUEnumerationForExistingResourceResult.

func (*SKUEnumerationForExistingResourceResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SKUEnumerationForExistingResourceResult.

type SKUEnumerationForNewResourceResult 

type SKUEnumerationForNewResourceResult struct {
	// The collection of available SKUs for new resources.
	Value []*ResourceSKU
}

SKUEnumerationForNewResourceResult - An object that represents enumerating SKUs for new resources.

func (SKUEnumerationForNewResourceResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SKUEnumerationForNewResourceResult.

func (*SKUEnumerationForNewResourceResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SKUEnumerationForNewResourceResult.

type SKUTier 

type SKUTier string

SKUTier - The name of the Azure pricing tier to which the SKU applies. 

const (
	SKUTierBasic       SKUTier = "Basic"
	SKUTierDevelopment SKUTier = "Development"
	SKUTierStandard    SKUTier = "Standard"
)

func PossibleSKUTierValues 

func PossibleSKUTierValues() []SKUTier

PossibleSKUTierValues returns the possible values for the SKUTier const type.

type Server 

type Server struct {
	// REQUIRED; Location of the Analysis Services resource.
	Location *string

	// REQUIRED; The SKU of the Analysis Services resource.
	SKU *ResourceSKU

	// Properties of the provision operation request.
	Properties *ServerProperties

	// Key-value pairs of additional resource provisioning properties.
	Tags map[string]*string

	// READ-ONLY; An identifier that represents the Analysis Services resource.
	ID *string

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

	// READ-ONLY; The type of the Analysis Services resource.
	Type *string
}

Server - Represents an instance of an Analysis Services resource.

func (Server) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Server.

func (*Server) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Server.

type ServerAdministrators 

type ServerAdministrators struct {
	// An array of administrator user identities.
	Members []*string
}

ServerAdministrators - An array of administrator user identities.

func (ServerAdministrators) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServerAdministrators.

func (*ServerAdministrators) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServerAdministrators.

type ServerMonitorMode 

type ServerMonitorMode int32

ServerMonitorMode - The server monitor mode for AS server 

const (
	ServerMonitorModeOne  ServerMonitorMode = 1
	ServerMonitorModeZero ServerMonitorMode = 0
)

func PossibleServerMonitorModeValues 

func PossibleServerMonitorModeValues() []ServerMonitorMode

PossibleServerMonitorModeValues returns the possible values for the ServerMonitorMode const type.

type ServerMutableProperties 

type ServerMutableProperties struct {
	// A collection of AS server administrators
	AsAdministrators *ServerAdministrators

	// The SAS container URI to the backup container.
	BackupBlobContainerURI *string

	// The gateway details configured for the AS server.
	GatewayDetails *GatewayDetails

	// The firewall settings for the AS server.
	IPV4FirewallSettings *IPv4FirewallSettings

	// The managed mode of the server (0 = not managed, 1 = managed).
	ManagedMode *ManagedMode

	// How the read-write server's participation in the query pool is controlled.
	// It can have the following values: * readOnly - indicates that the read-write server is intended not to participate in query
	// operations
	// * all - indicates that the read-write server can participate in query operations
	// Specifying readOnly when capacity is 1 results in error.
	QuerypoolConnectionMode *ConnectionMode

	// The server monitor mode for AS server
	ServerMonitorMode *ServerMonitorMode
}

ServerMutableProperties - An object that represents a set of mutable Analysis Services resource properties.

func (ServerMutableProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServerMutableProperties.

func (*ServerMutableProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServerMutableProperties.

type ServerProperties 

type ServerProperties struct {
	// A collection of AS server administrators
	AsAdministrators *ServerAdministrators

	// The SAS container URI to the backup container.
	BackupBlobContainerURI *string

	// The gateway details configured for the AS server.
	GatewayDetails *GatewayDetails

	// The firewall settings for the AS server.
	IPV4FirewallSettings *IPv4FirewallSettings

	// The managed mode of the server (0 = not managed, 1 = managed).
	ManagedMode *ManagedMode

	// How the read-write server's participation in the query pool is controlled.
	// It can have the following values: * readOnly - indicates that the read-write server is intended not to participate in query
	// operations
	// * all - indicates that the read-write server can participate in query operations
	// Specifying readOnly when capacity is 1 results in error.
	QuerypoolConnectionMode *ConnectionMode

	// The SKU of the Analysis Services resource.
	SKU *ResourceSKU

	// The server monitor mode for AS server
	ServerMonitorMode *ServerMonitorMode

	// READ-ONLY; The current deployment state of Analysis Services resource. The provisioningState is to indicate states for
	// resource provisioning.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The full name of the Analysis Services resource.
	ServerFullName *string

	// READ-ONLY; The current state of Analysis Services resource. The state is to indicate more states outside of resource provisioning.
	State *State
}

ServerProperties - Properties of Analysis Services resource.

func (ServerProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServerProperties.

func (*ServerProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServerProperties.

type ServerUpdateParameters 

type ServerUpdateParameters struct {
	// Properties of the provision operation request.
	Properties *ServerMutableProperties

	// The SKU of the Analysis Services resource.
	SKU *ResourceSKU

	// Key-value pairs of additional provisioning properties.
	Tags map[string]*string
}

ServerUpdateParameters - Provision request specification

func (ServerUpdateParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServerUpdateParameters.

func (*ServerUpdateParameters) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServerUpdateParameters.

type Servers 

type Servers struct {
	// REQUIRED; An array of Analysis Services resources.
	Value []*Server
}

Servers - An array of Analysis Services resources.

func (Servers) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Servers.

func (*Servers) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Servers.

type ServersClient 

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

ServersClient contains the methods for the Servers group. Don't use this type directly, use NewServersClient() instead.

func NewServersClient 

func NewServersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ServersClient, error)

NewServersClient creates a new instance of ServersClient with the specified values.

  • subscriptionID - A unique identifier for a Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ServersClient) BeginCreate 

func (client *ServersClient) BeginCreate(ctx context.Context, resourceGroupName string, serverName string, serverParameters Server, options *ServersClientBeginCreateOptions) (*runtime.Poller[ServersClientCreateResponse], error)

BeginCreate - Provisions the specified Analysis Services server based on the configuration specified in the request. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-08-01

  • resourceGroupName - The name of the Azure Resource group of which a given Analysis Services server is part. This name must be at least 1 character in length, and no more than 90.
  • serverName - The name of the Analysis Services server. It must be a minimum of 3 characters, and a maximum of 63.
  • serverParameters - Contains the information used to provision the Analysis Services server.
  • options - ServersClientBeginCreateOptions contains the optional parameters for the ServersClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/createServer.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginCreate(ctx, "TestRG", "azsdktest", armanalysisservices.Server{
		Location: to.Ptr("West US"),
		SKU: &armanalysisservices.ResourceSKU{
			Name:     to.Ptr("S1"),
			Capacity: to.Ptr[int32](1),
			Tier:     to.Ptr(armanalysisservices.SKUTierStandard),
		},
		Tags: map[string]*string{
			"testKey": to.Ptr("testValue"),
		},
		Properties: &armanalysisservices.ServerProperties{
			AsAdministrators: &armanalysisservices.ServerAdministrators{
				Members: []*string{
					to.Ptr("azsdktest@microsoft.com"),
					to.Ptr("azsdktest2@microsoft.com")},
			},
		},
	}, 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.Server = armanalysisservices.Server{
	// 	Name: to.Ptr("azsdktest"),
	// 	ID: to.Ptr("/subscriptions/613192d7-503f-477a-9cfe-4efc3ee2bd60/resourceGroups/TestRG/providers/Microsoft.AnalysisServices/servers/azsdktest"),
	// 	Location: to.Ptr("West US"),
	// 	SKU: &armanalysisservices.ResourceSKU{
	// 		Name: to.Ptr("S1"),
	// 		Capacity: to.Ptr[int32](1),
	// 		Tier: to.Ptr(armanalysisservices.SKUTierStandard),
	// 	},
	// 	Tags: map[string]*string{
	// 		"testKey": to.Ptr("testValue"),
	// 	},
	// 	Properties: &armanalysisservices.ServerProperties{
	// 		AsAdministrators: &armanalysisservices.ServerAdministrators{
	// 			Members: []*string{
	// 				to.Ptr("azsdktest@microsoft.com"),
	// 				to.Ptr("azsdktest2@microsoft.com")},
	// 			},
	// 			ProvisioningState: to.Ptr(armanalysisservices.ProvisioningStateSucceeded),
	// 			ServerFullName: to.Ptr("asazure://nightly1.asazure-int.windows.net/azsdktest"),
	// 			State: to.Ptr(armanalysisservices.StateProvisioning),
	// 		},
	// 	}
}

Output:

func (*ServersClient) BeginDelete 

func (client *ServersClient) BeginDelete(ctx context.Context, resourceGroupName string, serverName string, options *ServersClientBeginDeleteOptions) (*runtime.Poller[ServersClientDeleteResponse], error)

BeginDelete - Deletes the specified Analysis Services server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-08-01

  • resourceGroupName - The name of the Azure Resource group of which a given Analysis Services server is part. This name must be at least 1 character in length, and no more than 90.
  • serverName - The name of the Analysis Services server. It must be at least 3 characters in length, and no more than 63.
  • options - ServersClientBeginDeleteOptions contains the optional parameters for the ServersClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/deleteServer.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginDelete(ctx, "TestRG", "azsdktest", 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 (*ServersClient) BeginResume 

func (client *ServersClient) BeginResume(ctx context.Context, resourceGroupName string, serverName string, options *ServersClientBeginResumeOptions) (*runtime.Poller[ServersClientResumeResponse], error)

BeginResume - Resumes operation of the specified Analysis Services server instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-08-01

  • resourceGroupName - The name of the Azure Resource group of which a given Analysis Services server is part. This name must be at least 1 character in length, and no more than 90.
  • serverName - The name of the Analysis Services server. It must be at least 3 characters in length, and no more than 63.
  • options - ServersClientBeginResumeOptions contains the optional parameters for the ServersClient.BeginResume method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/resumeServer.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginResume(ctx, "TestRG", "azsdktest", 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 (*ServersClient) BeginSuspend 

func (client *ServersClient) BeginSuspend(ctx context.Context, resourceGroupName string, serverName string, options *ServersClientBeginSuspendOptions) (*runtime.Poller[ServersClientSuspendResponse], error)

BeginSuspend - Suspends operation of the specified Analysis Services server instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-08-01

  • resourceGroupName - The name of the Azure Resource group of which a given Analysis Services server is part. This name must be at least 1 character in length, and no more than 90.
  • serverName - The name of the Analysis Services server. It must be at least 3 characters in length, and no more than 63.
  • options - ServersClientBeginSuspendOptions contains the optional parameters for the ServersClient.BeginSuspend method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/suspendServer.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginSuspend(ctx, "TestRG", "azsdktest", 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 (*ServersClient) BeginUpdate 

func (client *ServersClient) BeginUpdate(ctx context.Context, resourceGroupName string, serverName string, serverUpdateParameters ServerUpdateParameters, options *ServersClientBeginUpdateOptions) (*runtime.Poller[ServersClientUpdateResponse], error)

BeginUpdate - Updates the current state of the specified Analysis Services server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-08-01

  • resourceGroupName - The name of the Azure Resource group of which a given Analysis Services server is part. This name must be at least 1 character in length, and no more than 90.
  • serverName - The name of the Analysis Services server. It must be at least 3 characters in length, and no more than 63.
  • serverUpdateParameters - Request object that contains the updated information for the server.
  • options - ServersClientBeginUpdateOptions contains the optional parameters for the ServersClient.BeginUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/updateServer.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "TestRG", "azsdktest", armanalysisservices.ServerUpdateParameters{
		Properties: &armanalysisservices.ServerMutableProperties{
			AsAdministrators: &armanalysisservices.ServerAdministrators{
				Members: []*string{
					to.Ptr("azsdktest@microsoft.com"),
					to.Ptr("azsdktest2@microsoft.com")},
			},
		},
		SKU: &armanalysisservices.ResourceSKU{
			Name:     to.Ptr("S1"),
			Capacity: to.Ptr[int32](1),
			Tier:     to.Ptr(armanalysisservices.SKUTierStandard),
		},
		Tags: map[string]*string{
			"testKey": to.Ptr("testValue"),
		},
	}, 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.Server = armanalysisservices.Server{
	// 	Name: to.Ptr("azsdktest"),
	// 	ID: to.Ptr("/subscriptions/613192d7-503f-477a-9cfe-4efc3ee2bd60/resourceGroups/TestRG/providers/Microsoft.AnalysisServices/servers/azsdktest"),
	// 	Location: to.Ptr("West US"),
	// 	SKU: &armanalysisservices.ResourceSKU{
	// 		Name: to.Ptr("S1"),
	// 		Capacity: to.Ptr[int32](1),
	// 		Tier: to.Ptr(armanalysisservices.SKUTierStandard),
	// 	},
	// 	Tags: map[string]*string{
	// 		"testKey": to.Ptr("testValue"),
	// 	},
	// 	Properties: &armanalysisservices.ServerProperties{
	// 		AsAdministrators: &armanalysisservices.ServerAdministrators{
	// 			Members: []*string{
	// 				to.Ptr("azsdktest@microsoft.com"),
	// 				to.Ptr("azsdktest2@microsoft.com")},
	// 			},
	// 			ProvisioningState: to.Ptr(armanalysisservices.ProvisioningStateSucceeded),
	// 			ServerFullName: to.Ptr("asazure://nightly1.asazure-int.windows.net/azsdktest"),
	// 			State: to.Ptr(armanalysisservices.StateProvisioning),
	// 		},
	// 	}
}

Output:

func (*ServersClient) CheckNameAvailability 

func (client *ServersClient) CheckNameAvailability(ctx context.Context, location string, serverParameters CheckServerNameAvailabilityParameters, options *ServersClientCheckNameAvailabilityOptions) (ServersClientCheckNameAvailabilityResponse, error)

CheckNameAvailability - Check the name availability in the target location. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-08-01

  • location - The region name which the operation will lookup into.
  • serverParameters - Contains the information used to provision the Analysis Services server.
  • options - ServersClientCheckNameAvailabilityOptions contains the optional parameters for the ServersClient.CheckNameAvailability method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/checkNameAvailability.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewServersClient().CheckNameAvailability(ctx, "West US", armanalysisservices.CheckServerNameAvailabilityParameters{
		Name: to.Ptr("azsdktest"),
		Type: to.Ptr("Microsoft.AnalysisServices/servers"),
	}, 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.CheckServerNameAvailabilityResult = armanalysisservices.CheckServerNameAvailabilityResult{
	// 	NameAvailable: to.Ptr(true),
	// }
}

Output:

func (*ServersClient) DissociateGateway 

func (client *ServersClient) DissociateGateway(ctx context.Context, resourceGroupName string, serverName string, options *ServersClientDissociateGatewayOptions) (ServersClientDissociateGatewayResponse, error)

DissociateGateway - Dissociates a Unified Gateway associated with the server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-08-01

  • resourceGroupName - The name of the Azure Resource group of which a given Analysis Services server is part. This name must be at least 1 character in length, and no more than 90.
  • serverName - The name of the Analysis Services server. It must be at least 3 characters in length, and no more than 63.
  • options - ServersClientDissociateGatewayOptions contains the optional parameters for the ServersClient.DissociateGateway method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/dissociateGateway.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewServersClient().DissociateGateway(ctx, "TestRG", "azsdktest", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*ServersClient) GetDetails 

func (client *ServersClient) GetDetails(ctx context.Context, resourceGroupName string, serverName string, options *ServersClientGetDetailsOptions) (ServersClientGetDetailsResponse, error)

GetDetails - Gets details about the specified Analysis Services server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-08-01

  • resourceGroupName - The name of the Azure Resource group of which a given Analysis Services server is part. This name must be at least 1 character in length, and no more than 90.
  • serverName - The name of the Analysis Services server. It must be a minimum of 3 characters, and a maximum of 63.
  • options - ServersClientGetDetailsOptions contains the optional parameters for the ServersClient.GetDetails method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/getServer.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewServersClient().GetDetails(ctx, "TestRG", "azsdktest", 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.Server = armanalysisservices.Server{
	// 	Name: to.Ptr("azsdktest"),
	// 	ID: to.Ptr("/subscriptions/613192d7-503f-477a-9cfe-4efc3ee2bd60/resourceGroups/TestRG/providers/Microsoft.AnalysisServices/servers/azsdktest"),
	// 	Location: to.Ptr("West US"),
	// 	SKU: &armanalysisservices.ResourceSKU{
	// 		Name: to.Ptr("S1"),
	// 		Capacity: to.Ptr[int32](1),
	// 		Tier: to.Ptr(armanalysisservices.SKUTierStandard),
	// 	},
	// 	Tags: map[string]*string{
	// 		"testKey": to.Ptr("testValue"),
	// 	},
	// 	Properties: &armanalysisservices.ServerProperties{
	// 		AsAdministrators: &armanalysisservices.ServerAdministrators{
	// 			Members: []*string{
	// 				to.Ptr("azsdktest@microsoft.com")},
	// 			},
	// 			ProvisioningState: to.Ptr(armanalysisservices.ProvisioningStateSucceeded),
	// 			ServerFullName: to.Ptr("asazure://nightly1.asazure-int.windows.net/azsdktest"),
	// 			State: to.Ptr(armanalysisservices.StateProvisioning),
	// 		},
	// 	}
}

Output:

func (*ServersClient) ListGatewayStatus 

func (client *ServersClient) ListGatewayStatus(ctx context.Context, resourceGroupName string, serverName string, options *ServersClientListGatewayStatusOptions) (ServersClientListGatewayStatusResponse, error)

ListGatewayStatus - Return the gateway status of the specified Analysis Services server instance. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-08-01

  • resourceGroupName - The name of the Azure Resource group of which a given Analysis Services server is part. This name must be at least 1 character in length, and no more than 90.
  • serverName - The name of the Analysis Services server.
  • options - ServersClientListGatewayStatusOptions contains the optional parameters for the ServersClient.ListGatewayStatus method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/listGatewayStatus.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewServersClient().ListGatewayStatus(ctx, "TestRG", "azsdktest", 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.GatewayListStatusLive = armanalysisservices.GatewayListStatusLive{
	// 	Status: to.Ptr[int32](0),
	// }
}

Output:

func (*ServersClient) ListOperationResults 

func (client *ServersClient) ListOperationResults(ctx context.Context, location string, operationID string, options *ServersClientListOperationResultsOptions) (ServersClientListOperationResultsResponse, error)

ListOperationResults - List the result of the specified operation. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-08-01

  • location - The region name which the operation will lookup into.
  • operationID - The target operation Id.
  • options - ServersClientListOperationResultsOptions contains the optional parameters for the ServersClient.ListOperationResults method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/operationResults.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewServersClient().ListOperationResults(ctx, "West US", "00000000000000000000000000000000", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*ServersClient) ListOperationStatuses 

func (client *ServersClient) ListOperationStatuses(ctx context.Context, location string, operationID string, options *ServersClientListOperationStatusesOptions) (ServersClientListOperationStatusesResponse, error)

ListOperationStatuses - List the status of operation. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-08-01

  • location - The region name which the operation will lookup into.
  • operationID - The target operation Id.
  • options - ServersClientListOperationStatusesOptions contains the optional parameters for the ServersClient.ListOperationStatuses method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/operationStatuses.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewServersClient().ListOperationStatuses(ctx, "West US", "testoperationid", 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.OperationStatus = armanalysisservices.OperationStatus{
	// 	Name: to.Ptr("testoperationid"),
	// 	EndTime: to.Ptr("2017-01-01T16:13:13.933Z"),
	// 	ID: to.Ptr("/subscriptions/id/locations/westus/operationstatuses/testoperationid"),
	// 	StartTime: to.Ptr("2017-01-01T13:13:13.933Z"),
	// 	Status: to.Ptr("Succeeded"),
	// }
}

Output:

func (*ServersClient) ListSKUsForExisting 

func (client *ServersClient) ListSKUsForExisting(ctx context.Context, resourceGroupName string, serverName string, options *ServersClientListSKUsForExistingOptions) (ServersClientListSKUsForExistingResponse, error)

ListSKUsForExisting - Lists eligible SKUs for an Analysis Services resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-08-01

  • resourceGroupName - The name of the Azure Resource group of which a given Analysis Services server is part. This name must be at least 1 character in length, and no more than 90.
  • serverName - The name of the Analysis Services server. It must be at least 3 characters in length, and no more than 63.
  • options - ServersClientListSKUsForExistingOptions contains the optional parameters for the ServersClient.ListSKUsForExisting method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/listSkusForExisting.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewServersClient().ListSKUsForExisting(ctx, "TestRG", "azsdktest", 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.SKUEnumerationForExistingResourceResult = armanalysisservices.SKUEnumerationForExistingResourceResult{
	// 	Value: []*armanalysisservices.SKUDetailsForExistingResource{
	// 		{
	// 			SKU: &armanalysisservices.ResourceSKU{
	// 				Name: to.Ptr("B1"),
	// 				Tier: to.Ptr(armanalysisservices.SKUTierBasic),
	// 			},
	// 		},
	// 		{
	// 			SKU: &armanalysisservices.ResourceSKU{
	// 				Name: to.Ptr("B2"),
	// 				Tier: to.Ptr(armanalysisservices.SKUTierBasic),
	// 			},
	// 		},
	// 		{
	// 			SKU: &armanalysisservices.ResourceSKU{
	// 				Name: to.Ptr("S0"),
	// 				Tier: to.Ptr(armanalysisservices.SKUTierStandard),
	// 			},
	// 		},
	// 		{
	// 			SKU: &armanalysisservices.ResourceSKU{
	// 				Name: to.Ptr("S1"),
	// 				Tier: to.Ptr(armanalysisservices.SKUTierStandard),
	// 			},
	// 		},
	// 		{
	// 			SKU: &armanalysisservices.ResourceSKU{
	// 				Name: to.Ptr("S2"),
	// 				Tier: to.Ptr(armanalysisservices.SKUTierStandard),
	// 			},
	// 		},
	// 		{
	// 			SKU: &armanalysisservices.ResourceSKU{
	// 				Name: to.Ptr("S3"),
	// 				Tier: to.Ptr(armanalysisservices.SKUTierStandard),
	// 			},
	// 		},
	// 		{
	// 			SKU: &armanalysisservices.ResourceSKU{
	// 				Name: to.Ptr("S4"),
	// 				Tier: to.Ptr(armanalysisservices.SKUTierStandard),
	// 			},
	// 	}},
	// }
}

Output:

func (*ServersClient) ListSKUsForNew 

func (client *ServersClient) ListSKUsForNew(ctx context.Context, options *ServersClientListSKUsForNewOptions) (ServersClientListSKUsForNewResponse, error)

ListSKUsForNew - Lists eligible SKUs for Analysis Services resource provider. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2017-08-01

  • options - ServersClientListSKUsForNewOptions contains the optional parameters for the ServersClient.ListSKUsForNew method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/listSkusForNew.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewServersClient().ListSKUsForNew(ctx, 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.SKUEnumerationForNewResourceResult = armanalysisservices.SKUEnumerationForNewResourceResult{
	// 	Value: []*armanalysisservices.ResourceSKU{
	// 		{
	// 			Name: to.Ptr("B1"),
	// 		},
	// 		{
	// 			Name: to.Ptr("B2"),
	// 		},
	// 		{
	// 			Name: to.Ptr("D1"),
	// 		},
	// 		{
	// 			Name: to.Ptr("S0"),
	// 		},
	// 		{
	// 			Name: to.Ptr("S1"),
	// 		},
	// 		{
	// 			Name: to.Ptr("S2"),
	// 		},
	// 		{
	// 			Name: to.Ptr("S3"),
	// 		},
	// 		{
	// 			Name: to.Ptr("S4"),
	// 	}},
	// }
}

Output:

func (*ServersClient) NewListByResourceGroupPager 

func (client *ServersClient) NewListByResourceGroupPager(resourceGroupName string, options *ServersClientListByResourceGroupOptions) *runtime.Pager[ServersClientListByResourceGroupResponse]

NewListByResourceGroupPager - Gets all the Analysis Services servers for the given resource group.

Generated from API version 2017-08-01

  • resourceGroupName - The name of the Azure Resource group of which a given Analysis Services server is part. This name must be at least 1 character in length, and no more than 90.
  • options - ServersClientListByResourceGroupOptions contains the optional parameters for the ServersClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/listServersInResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewServersClient().NewListByResourceGroupPager("TestRG", 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.Servers = armanalysisservices.Servers{
		// 	Value: []*armanalysisservices.Server{
		// 		{
		// 			Name: to.Ptr("azsdktest"),
		// 			ID: to.Ptr("/subscriptions/613192d7-503f-477a-9cfe-4efc3ee2bd60/resourceGroups/TestRG/providers/Microsoft.AnalysisServices/servers/azsdktest"),
		// 			Location: to.Ptr("West US"),
		// 			SKU: &armanalysisservices.ResourceSKU{
		// 				Name: to.Ptr("S1"),
		// 				Capacity: to.Ptr[int32](1),
		// 				Tier: to.Ptr(armanalysisservices.SKUTierStandard),
		// 			},
		// 			Tags: map[string]*string{
		// 				"testKey": to.Ptr("testValue"),
		// 			},
		// 			Properties: &armanalysisservices.ServerProperties{
		// 				AsAdministrators: &armanalysisservices.ServerAdministrators{
		// 					Members: []*string{
		// 						to.Ptr("azsdktest@microsoft.com")},
		// 					},
		// 					ProvisioningState: to.Ptr(armanalysisservices.ProvisioningStateSucceeded),
		// 					ServerFullName: to.Ptr("asazure://nightly1.asazure-int.windows.net/azsdktest"),
		// 					State: to.Ptr(armanalysisservices.StateProvisioning),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("azsdktest2"),
		// 				ID: to.Ptr("/subscriptions/613192d7-503f-477a-9cfe-4efc3ee2bd60/resourceGroups/TestRG/providers/Microsoft.AnalysisServices/servers/azsdktest"),
		// 				Location: to.Ptr("West US"),
		// 				SKU: &armanalysisservices.ResourceSKU{
		// 					Name: to.Ptr("S0"),
		// 					Capacity: to.Ptr[int32](1),
		// 					Tier: to.Ptr(armanalysisservices.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 					"testKey": to.Ptr("testValue"),
		// 				},
		// 				Properties: &armanalysisservices.ServerProperties{
		// 					AsAdministrators: &armanalysisservices.ServerAdministrators{
		// 						Members: []*string{
		// 							to.Ptr("azsdktest@microsoft.com")},
		// 						},
		// 						ProvisioningState: to.Ptr(armanalysisservices.ProvisioningStateSucceeded),
		// 						ServerFullName: to.Ptr("asazure://nightly1.asazure-int.windows.net/azsdktest"),
		// 						State: to.Ptr(armanalysisservices.StateProvisioning),
		// 					},
		// 			}},
		// 		}
	}
}

Output:

func (*ServersClient) NewListPager 

func (client *ServersClient) NewListPager(options *ServersClientListOptions) *runtime.Pager[ServersClientListResponse]

NewListPager - Lists all the Analysis Services servers for the given subscription.

Generated from API version 2017-08-01

  • options - ServersClientListOptions contains the optional parameters for the ServersClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/7a2ac91de424f271cf91cc8009f3fe9ee8249086/specification/analysisservices/resource-manager/Microsoft.AnalysisServices/stable/2017-08-01/examples/listServers.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/analysisservices/armanalysisservices"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armanalysisservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewServersClient().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.Servers = armanalysisservices.Servers{
		// 	Value: []*armanalysisservices.Server{
		// 		{
		// 			Name: to.Ptr("azsdktest"),
		// 			ID: to.Ptr("/subscriptions/613192d7-503f-477a-9cfe-4efc3ee2bd60/resourceGroups/TestRG/providers/Microsoft.AnalysisServices/servers/azsdktest"),
		// 			Location: to.Ptr("West US"),
		// 			SKU: &armanalysisservices.ResourceSKU{
		// 				Name: to.Ptr("S1"),
		// 				Capacity: to.Ptr[int32](1),
		// 				Tier: to.Ptr(armanalysisservices.SKUTierStandard),
		// 			},
		// 			Tags: map[string]*string{
		// 				"testKey": to.Ptr("testValue"),
		// 			},
		// 			Properties: &armanalysisservices.ServerProperties{
		// 				AsAdministrators: &armanalysisservices.ServerAdministrators{
		// 					Members: []*string{
		// 						to.Ptr("azsdktest@microsoft.com")},
		// 					},
		// 					ProvisioningState: to.Ptr(armanalysisservices.ProvisioningStateSucceeded),
		// 					ServerFullName: to.Ptr("asazure://nightly1.asazure-int.windows.net/azsdktest"),
		// 					State: to.Ptr(armanalysisservices.StateProvisioning),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("azsdktest2"),
		// 				ID: to.Ptr("/subscriptions/613192d7-503f-477a-9cfe-4efc3ee2bd60/resourceGroups/TestRG2/providers/Microsoft.AnalysisServices/servers/azsdktest"),
		// 				Location: to.Ptr("West US"),
		// 				SKU: &armanalysisservices.ResourceSKU{
		// 					Name: to.Ptr("S0"),
		// 					Capacity: to.Ptr[int32](1),
		// 					Tier: to.Ptr(armanalysisservices.SKUTierStandard),
		// 				},
		// 				Tags: map[string]*string{
		// 					"testKey": to.Ptr("testValue"),
		// 				},
		// 				Properties: &armanalysisservices.ServerProperties{
		// 					AsAdministrators: &armanalysisservices.ServerAdministrators{
		// 						Members: []*string{
		// 							to.Ptr("azsdktest@microsoft.com")},
		// 						},
		// 						ProvisioningState: to.Ptr(armanalysisservices.ProvisioningStateSucceeded),
		// 						ServerFullName: to.Ptr("asazure://nightly1.asazure-int.windows.net/azsdktest"),
		// 						State: to.Ptr(armanalysisservices.StateProvisioning),
		// 					},
		// 			}},
		// 		}
	}
}

Output:

type ServersClientBeginCreateOptions 

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

ServersClientBeginCreateOptions contains the optional parameters for the ServersClient.BeginCreate method.

type ServersClientBeginDeleteOptions 

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

ServersClientBeginDeleteOptions contains the optional parameters for the ServersClient.BeginDelete method.

type ServersClientBeginResumeOptions 

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

ServersClientBeginResumeOptions contains the optional parameters for the ServersClient.BeginResume method.

type ServersClientBeginSuspendOptions 

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

ServersClientBeginSuspendOptions contains the optional parameters for the ServersClient.BeginSuspend method.

type ServersClientBeginUpdateOptions 

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

ServersClientBeginUpdateOptions contains the optional parameters for the ServersClient.BeginUpdate method.

type ServersClientCheckNameAvailabilityOptions 

type ServersClientCheckNameAvailabilityOptions struct {
}

ServersClientCheckNameAvailabilityOptions contains the optional parameters for the ServersClient.CheckNameAvailability method.

type ServersClientCheckNameAvailabilityResponse 

type ServersClientCheckNameAvailabilityResponse struct {
	// The checking result of server name availability.
	CheckServerNameAvailabilityResult
}

ServersClientCheckNameAvailabilityResponse contains the response from method ServersClient.CheckNameAvailability.

type ServersClientCreateResponse 

type ServersClientCreateResponse struct {
	// Represents an instance of an Analysis Services resource.
	Server
}

ServersClientCreateResponse contains the response from method ServersClient.BeginCreate.

type ServersClientDeleteResponse 

type ServersClientDeleteResponse struct {
}

ServersClientDeleteResponse contains the response from method ServersClient.BeginDelete.

type ServersClientDissociateGatewayOptions 

type ServersClientDissociateGatewayOptions struct {
}

ServersClientDissociateGatewayOptions contains the optional parameters for the ServersClient.DissociateGateway method.

type ServersClientDissociateGatewayResponse 

type ServersClientDissociateGatewayResponse struct {
}

ServersClientDissociateGatewayResponse contains the response from method ServersClient.DissociateGateway.

type ServersClientGetDetailsOptions 

type ServersClientGetDetailsOptions struct {
}

ServersClientGetDetailsOptions contains the optional parameters for the ServersClient.GetDetails method.

type ServersClientGetDetailsResponse 

type ServersClientGetDetailsResponse struct {
	// Represents an instance of an Analysis Services resource.
	Server
}

ServersClientGetDetailsResponse contains the response from method ServersClient.GetDetails.

type ServersClientListByResourceGroupOptions 

type ServersClientListByResourceGroupOptions struct {
}

ServersClientListByResourceGroupOptions contains the optional parameters for the ServersClient.NewListByResourceGroupPager method.

type ServersClientListByResourceGroupResponse 

type ServersClientListByResourceGroupResponse struct {
	// An array of Analysis Services resources.
	Servers
}

ServersClientListByResourceGroupResponse contains the response from method ServersClient.NewListByResourceGroupPager.

type ServersClientListGatewayStatusOptions 

type ServersClientListGatewayStatusOptions struct {
}

ServersClientListGatewayStatusOptions contains the optional parameters for the ServersClient.ListGatewayStatus method.

type ServersClientListGatewayStatusResponse 

type ServersClientListGatewayStatusResponse struct {
	// Status of gateway is live.
	GatewayListStatusLive
}

ServersClientListGatewayStatusResponse contains the response from method ServersClient.ListGatewayStatus.

type ServersClientListOperationResultsOptions 

type ServersClientListOperationResultsOptions struct {
}

ServersClientListOperationResultsOptions contains the optional parameters for the ServersClient.ListOperationResults method.

type ServersClientListOperationResultsResponse 

type ServersClientListOperationResultsResponse struct {
}

ServersClientListOperationResultsResponse contains the response from method ServersClient.ListOperationResults.

type ServersClientListOperationStatusesOptions 

type ServersClientListOperationStatusesOptions struct {
}

ServersClientListOperationStatusesOptions contains the optional parameters for the ServersClient.ListOperationStatuses method.

type ServersClientListOperationStatusesResponse 

type ServersClientListOperationStatusesResponse struct {
	// The status of operation.
	OperationStatus
}

ServersClientListOperationStatusesResponse contains the response from method ServersClient.ListOperationStatuses.

type ServersClientListOptions 

type ServersClientListOptions struct {
}

ServersClientListOptions contains the optional parameters for the ServersClient.NewListPager method.

type ServersClientListResponse 

type ServersClientListResponse struct {
	// An array of Analysis Services resources.
	Servers
}

ServersClientListResponse contains the response from method ServersClient.NewListPager.

type ServersClientListSKUsForExistingOptions 

type ServersClientListSKUsForExistingOptions struct {
}

ServersClientListSKUsForExistingOptions contains the optional parameters for the ServersClient.ListSKUsForExisting method.

type ServersClientListSKUsForExistingResponse 

type ServersClientListSKUsForExistingResponse struct {
	// An object that represents enumerating SKUs for existing resources.
	SKUEnumerationForExistingResourceResult
}

ServersClientListSKUsForExistingResponse contains the response from method ServersClient.ListSKUsForExisting.

type ServersClientListSKUsForNewOptions 

type ServersClientListSKUsForNewOptions struct {
}

ServersClientListSKUsForNewOptions contains the optional parameters for the ServersClient.ListSKUsForNew method.

type ServersClientListSKUsForNewResponse 

type ServersClientListSKUsForNewResponse struct {
	// An object that represents enumerating SKUs for new resources.
	SKUEnumerationForNewResourceResult
}

ServersClientListSKUsForNewResponse contains the response from method ServersClient.ListSKUsForNew.

type ServersClientResumeResponse 

type ServersClientResumeResponse struct {
}

ServersClientResumeResponse contains the response from method ServersClient.BeginResume.

type ServersClientSuspendResponse 

type ServersClientSuspendResponse struct {
}

ServersClientSuspendResponse contains the response from method ServersClient.BeginSuspend.

type ServersClientUpdateResponse 

type ServersClientUpdateResponse struct {
	// Represents an instance of an Analysis Services resource.
	Server
}

ServersClientUpdateResponse contains the response from method ServersClient.BeginUpdate.

type State 

type State string

State - The current state of Analysis Services resource. The state is to indicate more states outside of resource provisioning. 

const (
	StateDeleting     State = "Deleting"
	StateFailed       State = "Failed"
	StatePaused       State = "Paused"
	StatePausing      State = "Pausing"
	StatePreparing    State = "Preparing"
	StateProvisioning State = "Provisioning"
	StateResuming     State = "Resuming"
	StateScaling      State = "Scaling"
	StateSucceeded    State = "Succeeded"
	StateSuspended    State = "Suspended"
	StateSuspending   State = "Suspending"
	StateUpdating     State = "Updating"
)

func PossibleStateValues 

func PossibleStateValues() []State

PossibleStateValues returns the possible values for the State const type.

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.