diagnostics

package
v0.20230725.1160316 Latest Latest
Warning

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

 Go to latest Published: Jul 25, 2023 License: MPL-2.0 Imports: 10 Imported by: 1

README

github.com/hashicorp/go-azure-sdk/resource-manager/web/2022-09-01/diagnostics Documentation

The diagnostics SDK allows for interaction with the Azure Resource Manager Service web (API Version 2022-09-01).

This readme covers example usages, but further information on using this SDK can be found in the project root.

Import Path

import "github.com/hashicorp/go-azure-sdk/resource-manager/web/2022-09-01/diagnostics"

Client Initialization

client := diagnostics.NewDiagnosticsClientWithBaseURI("https://management.azure.com")
client.Client.Authorizer = authorizer

Example Usage: DiagnosticsClient.ExecuteSiteAnalysis

ctx := context.TODO()
id := diagnostics.NewAnalysisID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "diagnosticValue", "analysisValue")

read, err := client.ExecuteSiteAnalysis(ctx, id, diagnostics.DefaultExecuteSiteAnalysisOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DiagnosticsClient.ExecuteSiteAnalysisSlot

ctx := context.TODO()
id := diagnostics.NewDiagnosticAnalysisID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "diagnosticValue", "analysisValue")

read, err := client.ExecuteSiteAnalysisSlot(ctx, id, diagnostics.DefaultExecuteSiteAnalysisSlotOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DiagnosticsClient.ExecuteSiteDetector

ctx := context.TODO()
id := diagnostics.NewDiagnosticDetectorID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "diagnosticValue", "detectorValue")

read, err := client.ExecuteSiteDetector(ctx, id, diagnostics.DefaultExecuteSiteDetectorOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DiagnosticsClient.ExecuteSiteDetectorSlot

ctx := context.TODO()
id := diagnostics.NewSlotDiagnosticDetectorID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "diagnosticValue", "detectorValue")

read, err := client.ExecuteSiteDetectorSlot(ctx, id, diagnostics.DefaultExecuteSiteDetectorSlotOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DiagnosticsClient.GetHostingEnvironmentDetectorResponse

ctx := context.TODO()
id := diagnostics.NewHostingEnvironmentDetectorID("12345678-1234-9876-4563-123456789012", "example-resource-group", "hostingEnvironmentValue", "detectorValue")

read, err := client.GetHostingEnvironmentDetectorResponse(ctx, id, diagnostics.DefaultGetHostingEnvironmentDetectorResponseOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DiagnosticsClient.GetSiteAnalysis

ctx := context.TODO()
id := diagnostics.NewAnalysisID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "diagnosticValue", "analysisValue")

read, err := client.GetSiteAnalysis(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DiagnosticsClient.GetSiteAnalysisSlot

ctx := context.TODO()
id := diagnostics.NewDiagnosticAnalysisID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "diagnosticValue", "analysisValue")

read, err := client.GetSiteAnalysisSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DiagnosticsClient.GetSiteDetector

ctx := context.TODO()
id := diagnostics.NewDiagnosticDetectorID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "diagnosticValue", "detectorValue")

read, err := client.GetSiteDetector(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DiagnosticsClient.GetSiteDetectorResponse

ctx := context.TODO()
id := diagnostics.NewDetectorID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "detectorValue")

read, err := client.GetSiteDetectorResponse(ctx, id, diagnostics.DefaultGetSiteDetectorResponseOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DiagnosticsClient.GetSiteDetectorResponseSlot

ctx := context.TODO()
id := diagnostics.NewSlotDetectorID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "detectorValue")

read, err := client.GetSiteDetectorResponseSlot(ctx, id, diagnostics.DefaultGetSiteDetectorResponseSlotOperationOptions())
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DiagnosticsClient.GetSiteDetectorSlot

ctx := context.TODO()
id := diagnostics.NewSlotDiagnosticDetectorID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "diagnosticValue", "detectorValue")

read, err := client.GetSiteDetectorSlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DiagnosticsClient.GetSiteDiagnosticCategory

ctx := context.TODO()
id := diagnostics.NewDiagnosticID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "diagnosticValue")

read, err := client.GetSiteDiagnosticCategory(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DiagnosticsClient.GetSiteDiagnosticCategorySlot

ctx := context.TODO()
id := diagnostics.NewSlotDiagnosticID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "diagnosticValue")

read, err := client.GetSiteDiagnosticCategorySlot(ctx, id)
if err != nil {
	// handle the error
}
if model := read.Model; model != nil {
	// do something with the model/response object
}

Example Usage: DiagnosticsClient.ListHostingEnvironmentDetectorResponses

ctx := context.TODO()
id := diagnostics.NewHostingEnvironmentID("12345678-1234-9876-4563-123456789012", "example-resource-group", "hostingEnvironmentValue")

// alternatively `client.ListHostingEnvironmentDetectorResponses(ctx, id)` can be used to do batched pagination
items, err := client.ListHostingEnvironmentDetectorResponsesComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: DiagnosticsClient.ListSiteAnalyses

ctx := context.TODO()
id := diagnostics.NewDiagnosticID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "diagnosticValue")

// alternatively `client.ListSiteAnalyses(ctx, id)` can be used to do batched pagination
items, err := client.ListSiteAnalysesComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: DiagnosticsClient.ListSiteAnalysesSlot

ctx := context.TODO()
id := diagnostics.NewSlotDiagnosticID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "diagnosticValue")

// alternatively `client.ListSiteAnalysesSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListSiteAnalysesSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: DiagnosticsClient.ListSiteDetectorResponses

ctx := context.TODO()
id := diagnostics.NewSiteID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListSiteDetectorResponses(ctx, id)` can be used to do batched pagination
items, err := client.ListSiteDetectorResponsesComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: DiagnosticsClient.ListSiteDetectorResponsesSlot

ctx := context.TODO()
id := diagnostics.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListSiteDetectorResponsesSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListSiteDetectorResponsesSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: DiagnosticsClient.ListSiteDetectors

ctx := context.TODO()
id := diagnostics.NewDiagnosticID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "diagnosticValue")

// alternatively `client.ListSiteDetectors(ctx, id)` can be used to do batched pagination
items, err := client.ListSiteDetectorsComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: DiagnosticsClient.ListSiteDetectorsSlot

ctx := context.TODO()
id := diagnostics.NewSlotDiagnosticID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue", "diagnosticValue")

// alternatively `client.ListSiteDetectorsSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListSiteDetectorsSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: DiagnosticsClient.ListSiteDiagnosticCategories

ctx := context.TODO()
id := diagnostics.NewSiteID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue")

// alternatively `client.ListSiteDiagnosticCategories(ctx, id)` can be used to do batched pagination
items, err := client.ListSiteDiagnosticCategoriesComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Example Usage: DiagnosticsClient.ListSiteDiagnosticCategoriesSlot

ctx := context.TODO()
id := diagnostics.NewSlotID("12345678-1234-9876-4563-123456789012", "example-resource-group", "siteValue", "slotValue")

// alternatively `client.ListSiteDiagnosticCategoriesSlot(ctx, id)` can be used to do batched pagination
items, err := client.ListSiteDiagnosticCategoriesSlotComplete(ctx, id)
if err != nil {
	// handle the error
}
for _, item := range items {
	// do something
}

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func PossibleValuesForDetectorType 

func PossibleValuesForDetectorType() []string

func PossibleValuesForInsightStatus 

func PossibleValuesForInsightStatus() []string

func PossibleValuesForIssueType 

func PossibleValuesForIssueType() []string

func PossibleValuesForRenderingType 

func PossibleValuesForRenderingType() []string

func PossibleValuesForSolutionType 

func PossibleValuesForSolutionType() []string

func ValidateAnalysisID 

func ValidateAnalysisID(input interface{}, key string) (warnings []string, errors []error)

ValidateAnalysisID checks that 'input' can be parsed as a Analysis ID

func ValidateDetectorID 

func ValidateDetectorID(input interface{}, key string) (warnings []string, errors []error)

ValidateDetectorID checks that 'input' can be parsed as a Detector ID

func ValidateDiagnosticAnalysisID 

func ValidateDiagnosticAnalysisID(input interface{}, key string) (warnings []string, errors []error)

ValidateDiagnosticAnalysisID checks that 'input' can be parsed as a Diagnostic Analysis ID

func ValidateDiagnosticDetectorID 

func ValidateDiagnosticDetectorID(input interface{}, key string) (warnings []string, errors []error)

ValidateDiagnosticDetectorID checks that 'input' can be parsed as a Diagnostic Detector ID

func ValidateDiagnosticID 

func ValidateDiagnosticID(input interface{}, key string) (warnings []string, errors []error)

ValidateDiagnosticID checks that 'input' can be parsed as a Diagnostic ID

func ValidateHostingEnvironmentDetectorID 

func ValidateHostingEnvironmentDetectorID(input interface{}, key string) (warnings []string, errors []error)

ValidateHostingEnvironmentDetectorID checks that 'input' can be parsed as a Hosting Environment Detector ID

func ValidateHostingEnvironmentID 

func ValidateHostingEnvironmentID(input interface{}, key string) (warnings []string, errors []error)

ValidateHostingEnvironmentID checks that 'input' can be parsed as a Hosting Environment ID

func ValidateSiteID 

func ValidateSiteID(input interface{}, key string) (warnings []string, errors []error)

ValidateSiteID checks that 'input' can be parsed as a Site ID

func ValidateSlotDetectorID 

func ValidateSlotDetectorID(input interface{}, key string) (warnings []string, errors []error)

ValidateSlotDetectorID checks that 'input' can be parsed as a Slot Detector ID

func ValidateSlotDiagnosticDetectorID 

func ValidateSlotDiagnosticDetectorID(input interface{}, key string) (warnings []string, errors []error)

ValidateSlotDiagnosticDetectorID checks that 'input' can be parsed as a Slot Diagnostic Detector ID

func ValidateSlotDiagnosticID 

func ValidateSlotDiagnosticID(input interface{}, key string) (warnings []string, errors []error)

ValidateSlotDiagnosticID checks that 'input' can be parsed as a Slot Diagnostic ID

func ValidateSlotID 

func ValidateSlotID(input interface{}, key string) (warnings []string, errors []error)

ValidateSlotID checks that 'input' can be parsed as a Slot ID

Types

type AbnormalTimePeriod 

type AbnormalTimePeriod struct {
	EndTime   *string                       `json:"endTime,omitempty"`
	Events    *[]DetectorAbnormalTimePeriod `json:"events,omitempty"`
	Solutions *[]Solution                   `json:"solutions,omitempty"`
	StartTime *string                       `json:"startTime,omitempty"`
}

func (*AbnormalTimePeriod) GetEndTimeAsTime 

func (o *AbnormalTimePeriod) GetEndTimeAsTime() (*time.Time, error)

func (*AbnormalTimePeriod) GetStartTimeAsTime 

func (o *AbnormalTimePeriod) GetStartTimeAsTime() (*time.Time, error)

func (*AbnormalTimePeriod) SetEndTimeAsTime 

func (o *AbnormalTimePeriod) SetEndTimeAsTime(input time.Time)

func (*AbnormalTimePeriod) SetStartTimeAsTime 

func (o *AbnormalTimePeriod) SetStartTimeAsTime(input time.Time)

type AnalysisData 

type AnalysisData struct {
	Data               *[][]NameValuePair     `json:"data,omitempty"`
	DetectorDefinition *DetectorDefinition    `json:"detectorDefinition,omitempty"`
	DetectorMetaData   *ResponseMetaData      `json:"detectorMetaData,omitempty"`
	Metrics            *[]DiagnosticMetricSet `json:"metrics,omitempty"`
	Source             *string                `json:"source,omitempty"`
}

type AnalysisDefinition 

type AnalysisDefinition struct {
	Id         *string                       `json:"id,omitempty"`
	Kind       *string                       `json:"kind,omitempty"`
	Name       *string                       `json:"name,omitempty"`
	Properties *AnalysisDefinitionProperties `json:"properties,omitempty"`
	Type       *string                       `json:"type,omitempty"`
}

type AnalysisDefinitionOperationPredicate 

type AnalysisDefinitionOperationPredicate struct {
	Id   *string
	Kind *string
	Name *string
	Type *string
}

func (AnalysisDefinitionOperationPredicate) Matches 

func (p AnalysisDefinitionOperationPredicate) Matches(input AnalysisDefinition) bool

type AnalysisDefinitionProperties 

type AnalysisDefinitionProperties struct {
	Description *string `json:"description,omitempty"`
}

type AnalysisId 

type AnalysisId struct {
	SubscriptionId    string
	ResourceGroupName string
	SiteName          string
	DiagnosticName    string
	AnalysisName      string
}

AnalysisId is a struct representing the Resource ID for a Analysis

func NewAnalysisID 

func NewAnalysisID(subscriptionId string, resourceGroupName string, siteName string, diagnosticName string, analysisName string) AnalysisId

NewAnalysisID returns a new AnalysisId struct

func ParseAnalysisID 

func ParseAnalysisID(input string) (*AnalysisId, error)

ParseAnalysisID parses 'input' into a AnalysisId

func ParseAnalysisIDInsensitively 

func ParseAnalysisIDInsensitively(input string) (*AnalysisId, error)

ParseAnalysisIDInsensitively parses 'input' case-insensitively into a AnalysisId note: this method should only be used for API response data and not user input

func (AnalysisId) ID 

func (id AnalysisId) ID() string

ID returns the formatted Analysis ID

func (AnalysisId) Segments 

func (id AnalysisId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Analysis ID

func (AnalysisId) String 

func (id AnalysisId) String() string

String returns a human-readable description of this Analysis ID

type DataProviderMetadata 

type DataProviderMetadata struct {
	PropertyBag  *[]KeyValuePairStringObject `json:"propertyBag,omitempty"`
	ProviderName *string                     `json:"providerName,omitempty"`
}

type DataSource 

type DataSource struct {
	DataSourceUri *[]NameValuePair `json:"dataSourceUri,omitempty"`
	Instructions  *[]string        `json:"instructions,omitempty"`
}

type DataTableResponseColumn 

type DataTableResponseColumn struct {
	ColumnName *string `json:"columnName,omitempty"`
	ColumnType *string `json:"columnType,omitempty"`
	DataType   *string `json:"dataType,omitempty"`
}

type DataTableResponseObject 

type DataTableResponseObject struct {
	Columns   *[]DataTableResponseColumn `json:"columns,omitempty"`
	Rows      *[][]string                `json:"rows,omitempty"`
	TableName *string                    `json:"tableName,omitempty"`
}

type DetectorAbnormalTimePeriod 

type DetectorAbnormalTimePeriod struct {
	EndTime   *string            `json:"endTime,omitempty"`
	Message   *string            `json:"message,omitempty"`
	MetaData  *[][]NameValuePair `json:"metaData,omitempty"`
	Priority  *float64           `json:"priority,omitempty"`
	Solutions *[]Solution        `json:"solutions,omitempty"`
	Source    *string            `json:"source,omitempty"`
	StartTime *string            `json:"startTime,omitempty"`
	Type      *IssueType         `json:"type,omitempty"`
}

func (*DetectorAbnormalTimePeriod) GetEndTimeAsTime 

func (o *DetectorAbnormalTimePeriod) GetEndTimeAsTime() (*time.Time, error)

func (*DetectorAbnormalTimePeriod) GetStartTimeAsTime 

func (o *DetectorAbnormalTimePeriod) GetStartTimeAsTime() (*time.Time, error)

func (*DetectorAbnormalTimePeriod) SetEndTimeAsTime 

func (o *DetectorAbnormalTimePeriod) SetEndTimeAsTime(input time.Time)

func (*DetectorAbnormalTimePeriod) SetStartTimeAsTime 

func (o *DetectorAbnormalTimePeriod) SetStartTimeAsTime(input time.Time)

type DetectorDefinition 

type DetectorDefinition struct {
	Description *string  `json:"description,omitempty"`
	DisplayName *string  `json:"displayName,omitempty"`
	IsEnabled   *bool    `json:"isEnabled,omitempty"`
	Rank        *float64 `json:"rank,omitempty"`
}

type DetectorDefinitionResource 

type DetectorDefinitionResource struct {
	Id         *string             `json:"id,omitempty"`
	Kind       *string             `json:"kind,omitempty"`
	Name       *string             `json:"name,omitempty"`
	Properties *DetectorDefinition `json:"properties,omitempty"`
	Type       *string             `json:"type,omitempty"`
}

type DetectorDefinitionResourceOperationPredicate 

type DetectorDefinitionResourceOperationPredicate struct {
	Id   *string
	Kind *string
	Name *string
	Type *string
}

func (DetectorDefinitionResourceOperationPredicate) Matches 

func (p DetectorDefinitionResourceOperationPredicate) Matches(input DetectorDefinitionResource) bool

type DetectorId 

type DetectorId struct {
	SubscriptionId    string
	ResourceGroupName string
	SiteName          string
	DetectorName      string
}

DetectorId is a struct representing the Resource ID for a Detector

func NewDetectorID 

func NewDetectorID(subscriptionId string, resourceGroupName string, siteName string, detectorName string) DetectorId

NewDetectorID returns a new DetectorId struct

func ParseDetectorID 

func ParseDetectorID(input string) (*DetectorId, error)

ParseDetectorID parses 'input' into a DetectorId

func ParseDetectorIDInsensitively 

func ParseDetectorIDInsensitively(input string) (*DetectorId, error)

ParseDetectorIDInsensitively parses 'input' case-insensitively into a DetectorId note: this method should only be used for API response data and not user input

func (DetectorId) ID 

func (id DetectorId) ID() string

ID returns the formatted Detector ID

func (DetectorId) Segments 

func (id DetectorId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Detector ID

func (DetectorId) String 

func (id DetectorId) String() string

String returns a human-readable description of this Detector ID

type DetectorInfo 

type DetectorInfo struct {
	AnalysisType     *[]string       `json:"analysisType,omitempty"`
	Author           *string         `json:"author,omitempty"`
	Category         *string         `json:"category,omitempty"`
	Description      *string         `json:"description,omitempty"`
	Id               *string         `json:"id,omitempty"`
	Name             *string         `json:"name,omitempty"`
	Score            *float64        `json:"score,omitempty"`
	SupportTopicList *[]SupportTopic `json:"supportTopicList,omitempty"`
	Type             *DetectorType   `json:"type,omitempty"`
}

type DetectorResponse 

type DetectorResponse struct {
	Id         *string                     `json:"id,omitempty"`
	Kind       *string                     `json:"kind,omitempty"`
	Name       *string                     `json:"name,omitempty"`
	Properties *DetectorResponseProperties `json:"properties,omitempty"`
	Type       *string                     `json:"type,omitempty"`
}

type DetectorResponseOperationPredicate 

type DetectorResponseOperationPredicate struct {
	Id   *string
	Kind *string
	Name *string
	Type *string
}

func (DetectorResponseOperationPredicate) Matches 

func (p DetectorResponseOperationPredicate) Matches(input DetectorResponse) bool

type DetectorResponseProperties 

type DetectorResponseProperties struct {
	DataProvidersMetadata *[]DataProviderMetadata `json:"dataProvidersMetadata,omitempty"`
	Dataset               *[]DiagnosticData       `json:"dataset,omitempty"`
	Metadata              *DetectorInfo           `json:"metadata,omitempty"`
	Status                *Status                 `json:"status,omitempty"`
	SuggestedUtterances   *QueryUtterancesResults `json:"suggestedUtterances,omitempty"`
}

type DetectorType 

type DetectorType string
const (
	DetectorTypeAnalysis         DetectorType = "Analysis"
	DetectorTypeCategoryOverview DetectorType = "CategoryOverview"
	DetectorTypeDetector         DetectorType = "Detector"
)

type DiagnosticAnalysis 

type DiagnosticAnalysis struct {
	Id         *string                       `json:"id,omitempty"`
	Kind       *string                       `json:"kind,omitempty"`
	Name       *string                       `json:"name,omitempty"`
	Properties *DiagnosticAnalysisProperties `json:"properties,omitempty"`
	Type       *string                       `json:"type,omitempty"`
}

type DiagnosticAnalysisId 

type DiagnosticAnalysisId struct {
	SubscriptionId    string
	ResourceGroupName string
	SiteName          string
	SlotName          string
	DiagnosticName    string
	AnalysisName      string
}

DiagnosticAnalysisId is a struct representing the Resource ID for a Diagnostic Analysis

func NewDiagnosticAnalysisID 

func NewDiagnosticAnalysisID(subscriptionId string, resourceGroupName string, siteName string, slotName string, diagnosticName string, analysisName string) DiagnosticAnalysisId

NewDiagnosticAnalysisID returns a new DiagnosticAnalysisId struct

func ParseDiagnosticAnalysisID 

func ParseDiagnosticAnalysisID(input string) (*DiagnosticAnalysisId, error)

ParseDiagnosticAnalysisID parses 'input' into a DiagnosticAnalysisId

func ParseDiagnosticAnalysisIDInsensitively 

func ParseDiagnosticAnalysisIDInsensitively(input string) (*DiagnosticAnalysisId, error)

ParseDiagnosticAnalysisIDInsensitively parses 'input' case-insensitively into a DiagnosticAnalysisId note: this method should only be used for API response data and not user input

func (DiagnosticAnalysisId) ID 

func (id DiagnosticAnalysisId) ID() string

ID returns the formatted Diagnostic Analysis ID

func (DiagnosticAnalysisId) Segments 

func (id DiagnosticAnalysisId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Diagnostic Analysis ID

func (DiagnosticAnalysisId) String 

func (id DiagnosticAnalysisId) String() string

String returns a human-readable description of this Diagnostic Analysis ID

type DiagnosticAnalysisProperties 

type DiagnosticAnalysisProperties struct {
	AbnormalTimePeriods    *[]AbnormalTimePeriod `json:"abnormalTimePeriods,omitempty"`
	EndTime                *string               `json:"endTime,omitempty"`
	NonCorrelatedDetectors *[]DetectorDefinition `json:"nonCorrelatedDetectors,omitempty"`
	Payload                *[]AnalysisData       `json:"payload,omitempty"`
	StartTime              *string               `json:"startTime,omitempty"`
}

func (*DiagnosticAnalysisProperties) GetEndTimeAsTime 

func (o *DiagnosticAnalysisProperties) GetEndTimeAsTime() (*time.Time, error)

func (*DiagnosticAnalysisProperties) GetStartTimeAsTime 

func (o *DiagnosticAnalysisProperties) GetStartTimeAsTime() (*time.Time, error)

func (*DiagnosticAnalysisProperties) SetEndTimeAsTime 

func (o *DiagnosticAnalysisProperties) SetEndTimeAsTime(input time.Time)

func (*DiagnosticAnalysisProperties) SetStartTimeAsTime 

func (o *DiagnosticAnalysisProperties) SetStartTimeAsTime(input time.Time)

type DiagnosticCategory 

type DiagnosticCategory struct {
	Id         *string                       `json:"id,omitempty"`
	Kind       *string                       `json:"kind,omitempty"`
	Name       *string                       `json:"name,omitempty"`
	Properties *DiagnosticCategoryProperties `json:"properties,omitempty"`
	Type       *string                       `json:"type,omitempty"`
}

type DiagnosticCategoryOperationPredicate 

type DiagnosticCategoryOperationPredicate struct {
	Id   *string
	Kind *string
	Name *string
	Type *string
}

func (DiagnosticCategoryOperationPredicate) Matches 

func (p DiagnosticCategoryOperationPredicate) Matches(input DiagnosticCategory) bool

type DiagnosticCategoryProperties 

type DiagnosticCategoryProperties struct {
	Description *string `json:"description,omitempty"`
}

type DiagnosticData 

type DiagnosticData struct {
	RenderingProperties *Rendering               `json:"renderingProperties,omitempty"`
	Table               *DataTableResponseObject `json:"table,omitempty"`
}

type DiagnosticDetectorId 

type DiagnosticDetectorId struct {
	SubscriptionId    string
	ResourceGroupName string
	SiteName          string
	DiagnosticName    string
	DetectorName      string
}

DiagnosticDetectorId is a struct representing the Resource ID for a Diagnostic Detector

func NewDiagnosticDetectorID 

func NewDiagnosticDetectorID(subscriptionId string, resourceGroupName string, siteName string, diagnosticName string, detectorName string) DiagnosticDetectorId

NewDiagnosticDetectorID returns a new DiagnosticDetectorId struct

func ParseDiagnosticDetectorID 

func ParseDiagnosticDetectorID(input string) (*DiagnosticDetectorId, error)

ParseDiagnosticDetectorID parses 'input' into a DiagnosticDetectorId

func ParseDiagnosticDetectorIDInsensitively 

func ParseDiagnosticDetectorIDInsensitively(input string) (*DiagnosticDetectorId, error)

ParseDiagnosticDetectorIDInsensitively parses 'input' case-insensitively into a DiagnosticDetectorId note: this method should only be used for API response data and not user input

func (DiagnosticDetectorId) ID 

func (id DiagnosticDetectorId) ID() string

ID returns the formatted Diagnostic Detector ID

func (DiagnosticDetectorId) Segments 

func (id DiagnosticDetectorId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Diagnostic Detector ID

func (DiagnosticDetectorId) String 

func (id DiagnosticDetectorId) String() string

String returns a human-readable description of this Diagnostic Detector ID

type DiagnosticDetectorResponse 

type DiagnosticDetectorResponse struct {
	Id         *string                               `json:"id,omitempty"`
	Kind       *string                               `json:"kind,omitempty"`
	Name       *string                               `json:"name,omitempty"`
	Properties *DiagnosticDetectorResponseProperties `json:"properties,omitempty"`
	Type       *string                               `json:"type,omitempty"`
}

type DiagnosticDetectorResponseProperties 

type DiagnosticDetectorResponseProperties struct {
	AbnormalTimePeriods *[]DetectorAbnormalTimePeriod `json:"abnormalTimePeriods,omitempty"`
	Data                *[][]NameValuePair            `json:"data,omitempty"`
	DetectorDefinition  *DetectorDefinition           `json:"detectorDefinition,omitempty"`
	EndTime             *string                       `json:"endTime,omitempty"`
	IssueDetected       *bool                         `json:"issueDetected,omitempty"`
	Metrics             *[]DiagnosticMetricSet        `json:"metrics,omitempty"`
	ResponseMetaData    *ResponseMetaData             `json:"responseMetaData,omitempty"`
	StartTime           *string                       `json:"startTime,omitempty"`
}

func (*DiagnosticDetectorResponseProperties) GetEndTimeAsTime 

func (o *DiagnosticDetectorResponseProperties) GetEndTimeAsTime() (*time.Time, error)

func (*DiagnosticDetectorResponseProperties) GetStartTimeAsTime 

func (o *DiagnosticDetectorResponseProperties) GetStartTimeAsTime() (*time.Time, error)

func (*DiagnosticDetectorResponseProperties) SetEndTimeAsTime 

func (o *DiagnosticDetectorResponseProperties) SetEndTimeAsTime(input time.Time)

func (*DiagnosticDetectorResponseProperties) SetStartTimeAsTime 

func (o *DiagnosticDetectorResponseProperties) SetStartTimeAsTime(input time.Time)

type DiagnosticId 

type DiagnosticId struct {
	SubscriptionId    string
	ResourceGroupName string
	SiteName          string
	DiagnosticName    string
}

DiagnosticId is a struct representing the Resource ID for a Diagnostic

func NewDiagnosticID 

func NewDiagnosticID(subscriptionId string, resourceGroupName string, siteName string, diagnosticName string) DiagnosticId

NewDiagnosticID returns a new DiagnosticId struct

func ParseDiagnosticID 

func ParseDiagnosticID(input string) (*DiagnosticId, error)

ParseDiagnosticID parses 'input' into a DiagnosticId

func ParseDiagnosticIDInsensitively 

func ParseDiagnosticIDInsensitively(input string) (*DiagnosticId, error)

ParseDiagnosticIDInsensitively parses 'input' case-insensitively into a DiagnosticId note: this method should only be used for API response data and not user input

func (DiagnosticId) ID 

func (id DiagnosticId) ID() string

ID returns the formatted Diagnostic ID

func (DiagnosticId) Segments 

func (id DiagnosticId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Diagnostic ID

func (DiagnosticId) String 

func (id DiagnosticId) String() string

String returns a human-readable description of this Diagnostic ID

type DiagnosticMetricSample 

type DiagnosticMetricSample struct {
	IsAggregated *bool    `json:"isAggregated,omitempty"`
	Maximum      *float64 `json:"maximum,omitempty"`
	Minimum      *float64 `json:"minimum,omitempty"`
	RoleInstance *string  `json:"roleInstance,omitempty"`
	Timestamp    *string  `json:"timestamp,omitempty"`
	Total        *float64 `json:"total,omitempty"`
}

func (*DiagnosticMetricSample) GetTimestampAsTime 

func (o *DiagnosticMetricSample) GetTimestampAsTime() (*time.Time, error)

func (*DiagnosticMetricSample) SetTimestampAsTime 

func (o *DiagnosticMetricSample) SetTimestampAsTime(input time.Time)

type DiagnosticMetricSet 

type DiagnosticMetricSet struct {
	EndTime   *string                   `json:"endTime,omitempty"`
	Name      *string                   `json:"name,omitempty"`
	StartTime *string                   `json:"startTime,omitempty"`
	TimeGrain *string                   `json:"timeGrain,omitempty"`
	Unit      *string                   `json:"unit,omitempty"`
	Values    *[]DiagnosticMetricSample `json:"values,omitempty"`
}

func (*DiagnosticMetricSet) GetEndTimeAsTime 

func (o *DiagnosticMetricSet) GetEndTimeAsTime() (*time.Time, error)

func (*DiagnosticMetricSet) GetStartTimeAsTime 

func (o *DiagnosticMetricSet) GetStartTimeAsTime() (*time.Time, error)

func (*DiagnosticMetricSet) SetEndTimeAsTime 

func (o *DiagnosticMetricSet) SetEndTimeAsTime(input time.Time)

func (*DiagnosticMetricSet) SetStartTimeAsTime 

func (o *DiagnosticMetricSet) SetStartTimeAsTime(input time.Time)

type DiagnosticsClient 

type DiagnosticsClient struct {
	Client autorest.Client
	// contains filtered or unexported fields
}

func NewDiagnosticsClientWithBaseURI 

func NewDiagnosticsClientWithBaseURI(endpoint string) DiagnosticsClient

func (DiagnosticsClient) ExecuteSiteAnalysis 

func (c DiagnosticsClient) ExecuteSiteAnalysis(ctx context.Context, id AnalysisId, options ExecuteSiteAnalysisOperationOptions) (result ExecuteSiteAnalysisOperationResponse, err error)

ExecuteSiteAnalysis ...

func (DiagnosticsClient) ExecuteSiteAnalysisSlot 

func (c DiagnosticsClient) ExecuteSiteAnalysisSlot(ctx context.Context, id DiagnosticAnalysisId, options ExecuteSiteAnalysisSlotOperationOptions) (result ExecuteSiteAnalysisSlotOperationResponse, err error)

ExecuteSiteAnalysisSlot ...

func (DiagnosticsClient) ExecuteSiteDetector 

func (c DiagnosticsClient) ExecuteSiteDetector(ctx context.Context, id DiagnosticDetectorId, options ExecuteSiteDetectorOperationOptions) (result ExecuteSiteDetectorOperationResponse, err error)

ExecuteSiteDetector ...

func (DiagnosticsClient) ExecuteSiteDetectorSlot 

func (c DiagnosticsClient) ExecuteSiteDetectorSlot(ctx context.Context, id SlotDiagnosticDetectorId, options ExecuteSiteDetectorSlotOperationOptions) (result ExecuteSiteDetectorSlotOperationResponse, err error)

ExecuteSiteDetectorSlot ...

func (DiagnosticsClient) GetHostingEnvironmentDetectorResponse 

func (c DiagnosticsClient) GetHostingEnvironmentDetectorResponse(ctx context.Context, id HostingEnvironmentDetectorId, options GetHostingEnvironmentDetectorResponseOperationOptions) (result GetHostingEnvironmentDetectorResponseOperationResponse, err error)

GetHostingEnvironmentDetectorResponse ...

func (DiagnosticsClient) GetSiteAnalysis 

func (c DiagnosticsClient) GetSiteAnalysis(ctx context.Context, id AnalysisId) (result GetSiteAnalysisOperationResponse, err error)

GetSiteAnalysis ...

func (DiagnosticsClient) GetSiteAnalysisSlot 

func (c DiagnosticsClient) GetSiteAnalysisSlot(ctx context.Context, id DiagnosticAnalysisId) (result GetSiteAnalysisSlotOperationResponse, err error)

GetSiteAnalysisSlot ...

func (DiagnosticsClient) GetSiteDetector 

func (c DiagnosticsClient) GetSiteDetector(ctx context.Context, id DiagnosticDetectorId) (result GetSiteDetectorOperationResponse, err error)

GetSiteDetector ...

func (DiagnosticsClient) GetSiteDetectorResponse 

func (c DiagnosticsClient) GetSiteDetectorResponse(ctx context.Context, id DetectorId, options GetSiteDetectorResponseOperationOptions) (result GetSiteDetectorResponseOperationResponse, err error)

GetSiteDetectorResponse ...

func (DiagnosticsClient) GetSiteDetectorResponseSlot 

func (c DiagnosticsClient) GetSiteDetectorResponseSlot(ctx context.Context, id SlotDetectorId, options GetSiteDetectorResponseSlotOperationOptions) (result GetSiteDetectorResponseSlotOperationResponse, err error)

GetSiteDetectorResponseSlot ...

func (DiagnosticsClient) GetSiteDetectorSlot 

func (c DiagnosticsClient) GetSiteDetectorSlot(ctx context.Context, id SlotDiagnosticDetectorId) (result GetSiteDetectorSlotOperationResponse, err error)

GetSiteDetectorSlot ...

func (DiagnosticsClient) GetSiteDiagnosticCategory 

func (c DiagnosticsClient) GetSiteDiagnosticCategory(ctx context.Context, id DiagnosticId) (result GetSiteDiagnosticCategoryOperationResponse, err error)

GetSiteDiagnosticCategory ...

func (DiagnosticsClient) GetSiteDiagnosticCategorySlot 

func (c DiagnosticsClient) GetSiteDiagnosticCategorySlot(ctx context.Context, id SlotDiagnosticId) (result GetSiteDiagnosticCategorySlotOperationResponse, err error)

GetSiteDiagnosticCategorySlot ...

func (DiagnosticsClient) ListHostingEnvironmentDetectorResponses 

func (c DiagnosticsClient) ListHostingEnvironmentDetectorResponses(ctx context.Context, id HostingEnvironmentId) (resp ListHostingEnvironmentDetectorResponsesOperationResponse, err error)

ListHostingEnvironmentDetectorResponses ...

func (DiagnosticsClient) ListHostingEnvironmentDetectorResponsesComplete 

func (c DiagnosticsClient) ListHostingEnvironmentDetectorResponsesComplete(ctx context.Context, id HostingEnvironmentId) (ListHostingEnvironmentDetectorResponsesCompleteResult, error)

ListHostingEnvironmentDetectorResponsesComplete retrieves all of the results into a single object

func (DiagnosticsClient) ListHostingEnvironmentDetectorResponsesCompleteMatchingPredicate 

func (c DiagnosticsClient) ListHostingEnvironmentDetectorResponsesCompleteMatchingPredicate(ctx context.Context, id HostingEnvironmentId, predicate DetectorResponseOperationPredicate) (resp ListHostingEnvironmentDetectorResponsesCompleteResult, err error)

ListHostingEnvironmentDetectorResponsesCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (DiagnosticsClient) ListSiteAnalyses 

func (c DiagnosticsClient) ListSiteAnalyses(ctx context.Context, id DiagnosticId) (resp ListSiteAnalysesOperationResponse, err error)

ListSiteAnalyses ...

func (DiagnosticsClient) ListSiteAnalysesComplete 

func (c DiagnosticsClient) ListSiteAnalysesComplete(ctx context.Context, id DiagnosticId) (ListSiteAnalysesCompleteResult, error)

ListSiteAnalysesComplete retrieves all of the results into a single object

func (DiagnosticsClient) ListSiteAnalysesCompleteMatchingPredicate 

func (c DiagnosticsClient) ListSiteAnalysesCompleteMatchingPredicate(ctx context.Context, id DiagnosticId, predicate AnalysisDefinitionOperationPredicate) (resp ListSiteAnalysesCompleteResult, err error)

ListSiteAnalysesCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (DiagnosticsClient) ListSiteAnalysesSlot 

func (c DiagnosticsClient) ListSiteAnalysesSlot(ctx context.Context, id SlotDiagnosticId) (resp ListSiteAnalysesSlotOperationResponse, err error)

ListSiteAnalysesSlot ...

func (DiagnosticsClient) ListSiteAnalysesSlotComplete 

func (c DiagnosticsClient) ListSiteAnalysesSlotComplete(ctx context.Context, id SlotDiagnosticId) (ListSiteAnalysesSlotCompleteResult, error)

ListSiteAnalysesSlotComplete retrieves all of the results into a single object

func (DiagnosticsClient) ListSiteAnalysesSlotCompleteMatchingPredicate 

func (c DiagnosticsClient) ListSiteAnalysesSlotCompleteMatchingPredicate(ctx context.Context, id SlotDiagnosticId, predicate AnalysisDefinitionOperationPredicate) (resp ListSiteAnalysesSlotCompleteResult, err error)

ListSiteAnalysesSlotCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (DiagnosticsClient) ListSiteDetectorResponses 

func (c DiagnosticsClient) ListSiteDetectorResponses(ctx context.Context, id SiteId) (resp ListSiteDetectorResponsesOperationResponse, err error)

ListSiteDetectorResponses ...

func (DiagnosticsClient) ListSiteDetectorResponsesComplete 

func (c DiagnosticsClient) ListSiteDetectorResponsesComplete(ctx context.Context, id SiteId) (ListSiteDetectorResponsesCompleteResult, error)

ListSiteDetectorResponsesComplete retrieves all of the results into a single object

func (DiagnosticsClient) ListSiteDetectorResponsesCompleteMatchingPredicate 

func (c DiagnosticsClient) ListSiteDetectorResponsesCompleteMatchingPredicate(ctx context.Context, id SiteId, predicate DetectorResponseOperationPredicate) (resp ListSiteDetectorResponsesCompleteResult, err error)

ListSiteDetectorResponsesCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (DiagnosticsClient) ListSiteDetectorResponsesSlot 

func (c DiagnosticsClient) ListSiteDetectorResponsesSlot(ctx context.Context, id SlotId) (resp ListSiteDetectorResponsesSlotOperationResponse, err error)

ListSiteDetectorResponsesSlot ...

func (DiagnosticsClient) ListSiteDetectorResponsesSlotComplete 

func (c DiagnosticsClient) ListSiteDetectorResponsesSlotComplete(ctx context.Context, id SlotId) (ListSiteDetectorResponsesSlotCompleteResult, error)

ListSiteDetectorResponsesSlotComplete retrieves all of the results into a single object

func (DiagnosticsClient) ListSiteDetectorResponsesSlotCompleteMatchingPredicate 

func (c DiagnosticsClient) ListSiteDetectorResponsesSlotCompleteMatchingPredicate(ctx context.Context, id SlotId, predicate DetectorResponseOperationPredicate) (resp ListSiteDetectorResponsesSlotCompleteResult, err error)

ListSiteDetectorResponsesSlotCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (DiagnosticsClient) ListSiteDetectors 

func (c DiagnosticsClient) ListSiteDetectors(ctx context.Context, id DiagnosticId) (resp ListSiteDetectorsOperationResponse, err error)

ListSiteDetectors ...

func (DiagnosticsClient) ListSiteDetectorsComplete 

func (c DiagnosticsClient) ListSiteDetectorsComplete(ctx context.Context, id DiagnosticId) (ListSiteDetectorsCompleteResult, error)

ListSiteDetectorsComplete retrieves all of the results into a single object

func (DiagnosticsClient) ListSiteDetectorsCompleteMatchingPredicate 

func (c DiagnosticsClient) ListSiteDetectorsCompleteMatchingPredicate(ctx context.Context, id DiagnosticId, predicate DetectorDefinitionResourceOperationPredicate) (resp ListSiteDetectorsCompleteResult, err error)

ListSiteDetectorsCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (DiagnosticsClient) ListSiteDetectorsSlot 

func (c DiagnosticsClient) ListSiteDetectorsSlot(ctx context.Context, id SlotDiagnosticId) (resp ListSiteDetectorsSlotOperationResponse, err error)

ListSiteDetectorsSlot ...

func (DiagnosticsClient) ListSiteDetectorsSlotComplete 

func (c DiagnosticsClient) ListSiteDetectorsSlotComplete(ctx context.Context, id SlotDiagnosticId) (ListSiteDetectorsSlotCompleteResult, error)

ListSiteDetectorsSlotComplete retrieves all of the results into a single object

func (DiagnosticsClient) ListSiteDetectorsSlotCompleteMatchingPredicate 

func (c DiagnosticsClient) ListSiteDetectorsSlotCompleteMatchingPredicate(ctx context.Context, id SlotDiagnosticId, predicate DetectorDefinitionResourceOperationPredicate) (resp ListSiteDetectorsSlotCompleteResult, err error)

ListSiteDetectorsSlotCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (DiagnosticsClient) ListSiteDiagnosticCategories 

func (c DiagnosticsClient) ListSiteDiagnosticCategories(ctx context.Context, id SiteId) (resp ListSiteDiagnosticCategoriesOperationResponse, err error)

ListSiteDiagnosticCategories ...

func (DiagnosticsClient) ListSiteDiagnosticCategoriesComplete 

func (c DiagnosticsClient) ListSiteDiagnosticCategoriesComplete(ctx context.Context, id SiteId) (ListSiteDiagnosticCategoriesCompleteResult, error)

ListSiteDiagnosticCategoriesComplete retrieves all of the results into a single object

func (DiagnosticsClient) ListSiteDiagnosticCategoriesCompleteMatchingPredicate 

func (c DiagnosticsClient) ListSiteDiagnosticCategoriesCompleteMatchingPredicate(ctx context.Context, id SiteId, predicate DiagnosticCategoryOperationPredicate) (resp ListSiteDiagnosticCategoriesCompleteResult, err error)

ListSiteDiagnosticCategoriesCompleteMatchingPredicate retrieves all of the results and then applied the predicate

func (DiagnosticsClient) ListSiteDiagnosticCategoriesSlot 

func (c DiagnosticsClient) ListSiteDiagnosticCategoriesSlot(ctx context.Context, id SlotId) (resp ListSiteDiagnosticCategoriesSlotOperationResponse, err error)

ListSiteDiagnosticCategoriesSlot ...

func (DiagnosticsClient) ListSiteDiagnosticCategoriesSlotComplete 

func (c DiagnosticsClient) ListSiteDiagnosticCategoriesSlotComplete(ctx context.Context, id SlotId) (ListSiteDiagnosticCategoriesSlotCompleteResult, error)

ListSiteDiagnosticCategoriesSlotComplete retrieves all of the results into a single object

func (DiagnosticsClient) ListSiteDiagnosticCategoriesSlotCompleteMatchingPredicate 

func (c DiagnosticsClient) ListSiteDiagnosticCategoriesSlotCompleteMatchingPredicate(ctx context.Context, id SlotId, predicate DiagnosticCategoryOperationPredicate) (resp ListSiteDiagnosticCategoriesSlotCompleteResult, err error)

ListSiteDiagnosticCategoriesSlotCompleteMatchingPredicate retrieves all of the results and then applied the predicate

type ExecuteSiteAnalysisOperationOptions 

type ExecuteSiteAnalysisOperationOptions struct {
	EndTime   *string
	StartTime *string
	TimeGrain *string
}

func DefaultExecuteSiteAnalysisOperationOptions 

func DefaultExecuteSiteAnalysisOperationOptions() ExecuteSiteAnalysisOperationOptions

type ExecuteSiteAnalysisOperationResponse 

type ExecuteSiteAnalysisOperationResponse struct {
	HttpResponse *http.Response
	Model        *DiagnosticAnalysis
}

type ExecuteSiteAnalysisSlotOperationOptions 

type ExecuteSiteAnalysisSlotOperationOptions struct {
	EndTime   *string
	StartTime *string
	TimeGrain *string
}

func DefaultExecuteSiteAnalysisSlotOperationOptions 

func DefaultExecuteSiteAnalysisSlotOperationOptions() ExecuteSiteAnalysisSlotOperationOptions

type ExecuteSiteAnalysisSlotOperationResponse 

type ExecuteSiteAnalysisSlotOperationResponse struct {
	HttpResponse *http.Response
	Model        *DiagnosticAnalysis
}

type ExecuteSiteDetectorOperationOptions 

type ExecuteSiteDetectorOperationOptions struct {
	EndTime   *string
	StartTime *string
	TimeGrain *string
}

func DefaultExecuteSiteDetectorOperationOptions 

func DefaultExecuteSiteDetectorOperationOptions() ExecuteSiteDetectorOperationOptions

type ExecuteSiteDetectorOperationResponse 

type ExecuteSiteDetectorOperationResponse struct {
	HttpResponse *http.Response
	Model        *DiagnosticDetectorResponse
}

type ExecuteSiteDetectorSlotOperationOptions 

type ExecuteSiteDetectorSlotOperationOptions struct {
	EndTime   *string
	StartTime *string
	TimeGrain *string
}

func DefaultExecuteSiteDetectorSlotOperationOptions 

func DefaultExecuteSiteDetectorSlotOperationOptions() ExecuteSiteDetectorSlotOperationOptions

type ExecuteSiteDetectorSlotOperationResponse 

type ExecuteSiteDetectorSlotOperationResponse struct {
	HttpResponse *http.Response
	Model        *DiagnosticDetectorResponse
}

type GetHostingEnvironmentDetectorResponseOperationOptions 

type GetHostingEnvironmentDetectorResponseOperationOptions struct {
	EndTime   *string
	StartTime *string
	TimeGrain *string
}

func DefaultGetHostingEnvironmentDetectorResponseOperationOptions 

func DefaultGetHostingEnvironmentDetectorResponseOperationOptions() GetHostingEnvironmentDetectorResponseOperationOptions

type GetHostingEnvironmentDetectorResponseOperationResponse 

type GetHostingEnvironmentDetectorResponseOperationResponse struct {
	HttpResponse *http.Response
	Model        *DetectorResponse
}

type GetSiteAnalysisOperationResponse 

type GetSiteAnalysisOperationResponse struct {
	HttpResponse *http.Response
	Model        *AnalysisDefinition
}

type GetSiteAnalysisSlotOperationResponse 

type GetSiteAnalysisSlotOperationResponse struct {
	HttpResponse *http.Response
	Model        *AnalysisDefinition
}

type GetSiteDetectorOperationResponse 

type GetSiteDetectorOperationResponse struct {
	HttpResponse *http.Response
	Model        *DetectorDefinitionResource
}

type GetSiteDetectorResponseOperationOptions 

type GetSiteDetectorResponseOperationOptions struct {
	EndTime   *string
	StartTime *string
	TimeGrain *string
}

func DefaultGetSiteDetectorResponseOperationOptions 

func DefaultGetSiteDetectorResponseOperationOptions() GetSiteDetectorResponseOperationOptions

type GetSiteDetectorResponseOperationResponse 

type GetSiteDetectorResponseOperationResponse struct {
	HttpResponse *http.Response
	Model        *DetectorResponse
}

type GetSiteDetectorResponseSlotOperationOptions 

type GetSiteDetectorResponseSlotOperationOptions struct {
	EndTime   *string
	StartTime *string
	TimeGrain *string
}

func DefaultGetSiteDetectorResponseSlotOperationOptions 

func DefaultGetSiteDetectorResponseSlotOperationOptions() GetSiteDetectorResponseSlotOperationOptions

type GetSiteDetectorResponseSlotOperationResponse 

type GetSiteDetectorResponseSlotOperationResponse struct {
	HttpResponse *http.Response
	Model        *DetectorResponse
}

type GetSiteDetectorSlotOperationResponse 

type GetSiteDetectorSlotOperationResponse struct {
	HttpResponse *http.Response
	Model        *DetectorDefinitionResource
}

type GetSiteDiagnosticCategoryOperationResponse 

type GetSiteDiagnosticCategoryOperationResponse struct {
	HttpResponse *http.Response
	Model        *DiagnosticCategory
}

type GetSiteDiagnosticCategorySlotOperationResponse 

type GetSiteDiagnosticCategorySlotOperationResponse struct {
	HttpResponse *http.Response
	Model        *DiagnosticCategory
}

type HostingEnvironmentDetectorId 

type HostingEnvironmentDetectorId struct {
	SubscriptionId         string
	ResourceGroupName      string
	HostingEnvironmentName string
	DetectorName           string
}

HostingEnvironmentDetectorId is a struct representing the Resource ID for a Hosting Environment Detector

func NewHostingEnvironmentDetectorID 

func NewHostingEnvironmentDetectorID(subscriptionId string, resourceGroupName string, hostingEnvironmentName string, detectorName string) HostingEnvironmentDetectorId

NewHostingEnvironmentDetectorID returns a new HostingEnvironmentDetectorId struct

func ParseHostingEnvironmentDetectorID 

func ParseHostingEnvironmentDetectorID(input string) (*HostingEnvironmentDetectorId, error)

ParseHostingEnvironmentDetectorID parses 'input' into a HostingEnvironmentDetectorId

func ParseHostingEnvironmentDetectorIDInsensitively 

func ParseHostingEnvironmentDetectorIDInsensitively(input string) (*HostingEnvironmentDetectorId, error)

ParseHostingEnvironmentDetectorIDInsensitively parses 'input' case-insensitively into a HostingEnvironmentDetectorId note: this method should only be used for API response data and not user input

func (HostingEnvironmentDetectorId) ID 

func (id HostingEnvironmentDetectorId) ID() string

ID returns the formatted Hosting Environment Detector ID

func (HostingEnvironmentDetectorId) Segments 

func (id HostingEnvironmentDetectorId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Hosting Environment Detector ID

func (HostingEnvironmentDetectorId) String 

func (id HostingEnvironmentDetectorId) String() string

String returns a human-readable description of this Hosting Environment Detector ID

type HostingEnvironmentId 

type HostingEnvironmentId struct {
	SubscriptionId         string
	ResourceGroupName      string
	HostingEnvironmentName string
}

HostingEnvironmentId is a struct representing the Resource ID for a Hosting Environment

func NewHostingEnvironmentID 

func NewHostingEnvironmentID(subscriptionId string, resourceGroupName string, hostingEnvironmentName string) HostingEnvironmentId

NewHostingEnvironmentID returns a new HostingEnvironmentId struct

func ParseHostingEnvironmentID 

func ParseHostingEnvironmentID(input string) (*HostingEnvironmentId, error)

ParseHostingEnvironmentID parses 'input' into a HostingEnvironmentId

func ParseHostingEnvironmentIDInsensitively 

func ParseHostingEnvironmentIDInsensitively(input string) (*HostingEnvironmentId, error)

ParseHostingEnvironmentIDInsensitively parses 'input' case-insensitively into a HostingEnvironmentId note: this method should only be used for API response data and not user input

func (HostingEnvironmentId) ID 

func (id HostingEnvironmentId) ID() string

ID returns the formatted Hosting Environment ID

func (HostingEnvironmentId) Segments 

func (id HostingEnvironmentId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Hosting Environment ID

func (HostingEnvironmentId) String 

func (id HostingEnvironmentId) String() string

String returns a human-readable description of this Hosting Environment ID

type InsightStatus 

type InsightStatus string
const (
	InsightStatusCritical InsightStatus = "Critical"
	InsightStatusInfo     InsightStatus = "Info"
	InsightStatusNone     InsightStatus = "None"
	InsightStatusSuccess  InsightStatus = "Success"
	InsightStatusWarning  InsightStatus = "Warning"
)

type IssueType 

type IssueType string
const (
	IssueTypeAppCrash             IssueType = "AppCrash"
	IssueTypeAppDeployment        IssueType = "AppDeployment"
	IssueTypeAseDeployment        IssueType = "AseDeployment"
	IssueTypeOther                IssueType = "Other"
	IssueTypePlatformIssue        IssueType = "PlatformIssue"
	IssueTypeRuntimeIssueDetected IssueType = "RuntimeIssueDetected"
	IssueTypeServiceIncident      IssueType = "ServiceIncident"
	IssueTypeUserIssue            IssueType = "UserIssue"
)

type KeyValuePairStringObject 

type KeyValuePairStringObject struct {
	Key   *string      `json:"key,omitempty"`
	Value *interface{} `json:"value,omitempty"`
}

type ListHostingEnvironmentDetectorResponsesCompleteResult 

type ListHostingEnvironmentDetectorResponsesCompleteResult struct {
	Items []DetectorResponse
}

type ListHostingEnvironmentDetectorResponsesOperationResponse 

type ListHostingEnvironmentDetectorResponsesOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]DetectorResponse
	// contains filtered or unexported fields
}

func (ListHostingEnvironmentDetectorResponsesOperationResponse) HasMore 

func (r ListHostingEnvironmentDetectorResponsesOperationResponse) HasMore() bool

func (ListHostingEnvironmentDetectorResponsesOperationResponse) LoadMore 

func (r ListHostingEnvironmentDetectorResponsesOperationResponse) LoadMore(ctx context.Context) (resp ListHostingEnvironmentDetectorResponsesOperationResponse, err error)

type ListSiteAnalysesCompleteResult 

type ListSiteAnalysesCompleteResult struct {
	Items []AnalysisDefinition
}

type ListSiteAnalysesOperationResponse 

type ListSiteAnalysesOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]AnalysisDefinition
	// contains filtered or unexported fields
}

func (ListSiteAnalysesOperationResponse) HasMore 

func (r ListSiteAnalysesOperationResponse) HasMore() bool

func (ListSiteAnalysesOperationResponse) LoadMore 

func (r ListSiteAnalysesOperationResponse) LoadMore(ctx context.Context) (resp ListSiteAnalysesOperationResponse, err error)

type ListSiteAnalysesSlotCompleteResult 

type ListSiteAnalysesSlotCompleteResult struct {
	Items []AnalysisDefinition
}

type ListSiteAnalysesSlotOperationResponse 

type ListSiteAnalysesSlotOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]AnalysisDefinition
	// contains filtered or unexported fields
}

func (ListSiteAnalysesSlotOperationResponse) HasMore 

func (r ListSiteAnalysesSlotOperationResponse) HasMore() bool

func (ListSiteAnalysesSlotOperationResponse) LoadMore 

func (r ListSiteAnalysesSlotOperationResponse) LoadMore(ctx context.Context) (resp ListSiteAnalysesSlotOperationResponse, err error)

type ListSiteDetectorResponsesCompleteResult 

type ListSiteDetectorResponsesCompleteResult struct {
	Items []DetectorResponse
}

type ListSiteDetectorResponsesOperationResponse 

type ListSiteDetectorResponsesOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]DetectorResponse
	// contains filtered or unexported fields
}

func (ListSiteDetectorResponsesOperationResponse) HasMore 

func (r ListSiteDetectorResponsesOperationResponse) HasMore() bool

func (ListSiteDetectorResponsesOperationResponse) LoadMore 

func (r ListSiteDetectorResponsesOperationResponse) LoadMore(ctx context.Context) (resp ListSiteDetectorResponsesOperationResponse, err error)

type ListSiteDetectorResponsesSlotCompleteResult 

type ListSiteDetectorResponsesSlotCompleteResult struct {
	Items []DetectorResponse
}

type ListSiteDetectorResponsesSlotOperationResponse 

type ListSiteDetectorResponsesSlotOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]DetectorResponse
	// contains filtered or unexported fields
}

func (ListSiteDetectorResponsesSlotOperationResponse) HasMore 

func (r ListSiteDetectorResponsesSlotOperationResponse) HasMore() bool

func (ListSiteDetectorResponsesSlotOperationResponse) LoadMore 

func (r ListSiteDetectorResponsesSlotOperationResponse) LoadMore(ctx context.Context) (resp ListSiteDetectorResponsesSlotOperationResponse, err error)

type ListSiteDetectorsCompleteResult 

type ListSiteDetectorsCompleteResult struct {
	Items []DetectorDefinitionResource
}

type ListSiteDetectorsOperationResponse 

type ListSiteDetectorsOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]DetectorDefinitionResource
	// contains filtered or unexported fields
}

func (ListSiteDetectorsOperationResponse) HasMore 

func (r ListSiteDetectorsOperationResponse) HasMore() bool

func (ListSiteDetectorsOperationResponse) LoadMore 

func (r ListSiteDetectorsOperationResponse) LoadMore(ctx context.Context) (resp ListSiteDetectorsOperationResponse, err error)

type ListSiteDetectorsSlotCompleteResult 

type ListSiteDetectorsSlotCompleteResult struct {
	Items []DetectorDefinitionResource
}

type ListSiteDetectorsSlotOperationResponse 

type ListSiteDetectorsSlotOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]DetectorDefinitionResource
	// contains filtered or unexported fields
}

func (ListSiteDetectorsSlotOperationResponse) HasMore 

func (r ListSiteDetectorsSlotOperationResponse) HasMore() bool

func (ListSiteDetectorsSlotOperationResponse) LoadMore 

func (r ListSiteDetectorsSlotOperationResponse) LoadMore(ctx context.Context) (resp ListSiteDetectorsSlotOperationResponse, err error)

type ListSiteDiagnosticCategoriesCompleteResult 

type ListSiteDiagnosticCategoriesCompleteResult struct {
	Items []DiagnosticCategory
}

type ListSiteDiagnosticCategoriesOperationResponse 

type ListSiteDiagnosticCategoriesOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]DiagnosticCategory
	// contains filtered or unexported fields
}

func (ListSiteDiagnosticCategoriesOperationResponse) HasMore 

func (r ListSiteDiagnosticCategoriesOperationResponse) HasMore() bool

func (ListSiteDiagnosticCategoriesOperationResponse) LoadMore 

func (r ListSiteDiagnosticCategoriesOperationResponse) LoadMore(ctx context.Context) (resp ListSiteDiagnosticCategoriesOperationResponse, err error)

type ListSiteDiagnosticCategoriesSlotCompleteResult 

type ListSiteDiagnosticCategoriesSlotCompleteResult struct {
	Items []DiagnosticCategory
}

type ListSiteDiagnosticCategoriesSlotOperationResponse 

type ListSiteDiagnosticCategoriesSlotOperationResponse struct {
	HttpResponse *http.Response
	Model        *[]DiagnosticCategory
	// contains filtered or unexported fields
}

func (ListSiteDiagnosticCategoriesSlotOperationResponse) HasMore 

func (r ListSiteDiagnosticCategoriesSlotOperationResponse) HasMore() bool

func (ListSiteDiagnosticCategoriesSlotOperationResponse) LoadMore 

func (r ListSiteDiagnosticCategoriesSlotOperationResponse) LoadMore(ctx context.Context) (resp ListSiteDiagnosticCategoriesSlotOperationResponse, err error)

type NameValuePair 

type NameValuePair struct {
	Name  *string `json:"name,omitempty"`
	Value *string `json:"value,omitempty"`
}

type QueryUtterancesResult 

type QueryUtterancesResult struct {
	SampleUtterance *SampleUtterance `json:"sampleUtterance,omitempty"`
	Score           *float64         `json:"score,omitempty"`
}

type QueryUtterancesResults 

type QueryUtterancesResults struct {
	Query   *string                  `json:"query,omitempty"`
	Results *[]QueryUtterancesResult `json:"results,omitempty"`
}

type Rendering 

type Rendering struct {
	Description *string        `json:"description,omitempty"`
	Title       *string        `json:"title,omitempty"`
	Type        *RenderingType `json:"type,omitempty"`
}

type RenderingType 

type RenderingType string
const (
	RenderingTypeAppInsight               RenderingType = "AppInsight"
	RenderingTypeAppInsightEnablement     RenderingType = "AppInsightEnablement"
	RenderingTypeCard                     RenderingType = "Card"
	RenderingTypeChangeAnalysisOnboarding RenderingType = "ChangeAnalysisOnboarding"
	RenderingTypeChangeSets               RenderingType = "ChangeSets"
	RenderingTypeChangesView              RenderingType = "ChangesView"
	RenderingTypeDataSummary              RenderingType = "DataSummary"
	RenderingTypeDependencyGraph          RenderingType = "DependencyGraph"
	RenderingTypeDetector                 RenderingType = "Detector"
	RenderingTypeDownTime                 RenderingType = "DownTime"
	RenderingTypeDropDown                 RenderingType = "DropDown"
	RenderingTypeDynamicInsight           RenderingType = "DynamicInsight"
	RenderingTypeEmail                    RenderingType = "Email"
	RenderingTypeForm                     RenderingType = "Form"
	RenderingTypeGuage                    RenderingType = "Guage"
	RenderingTypeInsights                 RenderingType = "Insights"
	RenderingTypeMarkdown                 RenderingType = "Markdown"
	RenderingTypeNoGraph                  RenderingType = "NoGraph"
	RenderingTypePieChart                 RenderingType = "PieChart"
	RenderingTypeSearchComponent          RenderingType = "SearchComponent"
	RenderingTypeSolution                 RenderingType = "Solution"
	RenderingTypeSummaryCard              RenderingType = "SummaryCard"
	RenderingTypeTable                    RenderingType = "Table"
	RenderingTypeTimeSeries               RenderingType = "TimeSeries"
	RenderingTypeTimeSeriesPerInstance    RenderingType = "TimeSeriesPerInstance"
)

type ResponseMetaData 

type ResponseMetaData struct {
	DataSource *DataSource `json:"dataSource,omitempty"`
}

type SampleUtterance 

type SampleUtterance struct {
	Links *[]string `json:"links,omitempty"`
	Qid   *string   `json:"qid,omitempty"`
	Text  *string   `json:"text,omitempty"`
}

type SiteId 

type SiteId struct {
	SubscriptionId    string
	ResourceGroupName string
	SiteName          string
}

SiteId is a struct representing the Resource ID for a Site

func NewSiteID 

func NewSiteID(subscriptionId string, resourceGroupName string, siteName string) SiteId

NewSiteID returns a new SiteId struct

func ParseSiteID 

func ParseSiteID(input string) (*SiteId, error)

ParseSiteID parses 'input' into a SiteId

func ParseSiteIDInsensitively 

func ParseSiteIDInsensitively(input string) (*SiteId, error)

ParseSiteIDInsensitively parses 'input' case-insensitively into a SiteId note: this method should only be used for API response data and not user input

func (SiteId) ID 

func (id SiteId) ID() string

ID returns the formatted Site ID

func (SiteId) Segments 

func (id SiteId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Site ID

func (SiteId) String 

func (id SiteId) String() string

String returns a human-readable description of this Site ID

type SlotDetectorId 

type SlotDetectorId struct {
	SubscriptionId    string
	ResourceGroupName string
	SiteName          string
	SlotName          string
	DetectorName      string
}

SlotDetectorId is a struct representing the Resource ID for a Slot Detector

func NewSlotDetectorID 

func NewSlotDetectorID(subscriptionId string, resourceGroupName string, siteName string, slotName string, detectorName string) SlotDetectorId

NewSlotDetectorID returns a new SlotDetectorId struct

func ParseSlotDetectorID 

func ParseSlotDetectorID(input string) (*SlotDetectorId, error)

ParseSlotDetectorID parses 'input' into a SlotDetectorId

func ParseSlotDetectorIDInsensitively 

func ParseSlotDetectorIDInsensitively(input string) (*SlotDetectorId, error)

ParseSlotDetectorIDInsensitively parses 'input' case-insensitively into a SlotDetectorId note: this method should only be used for API response data and not user input

func (SlotDetectorId) ID 

func (id SlotDetectorId) ID() string

ID returns the formatted Slot Detector ID

func (SlotDetectorId) Segments 

func (id SlotDetectorId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Slot Detector ID

func (SlotDetectorId) String 

func (id SlotDetectorId) String() string

String returns a human-readable description of this Slot Detector ID

type SlotDiagnosticDetectorId 

type SlotDiagnosticDetectorId struct {
	SubscriptionId    string
	ResourceGroupName string
	SiteName          string
	SlotName          string
	DiagnosticName    string
	DetectorName      string
}

SlotDiagnosticDetectorId is a struct representing the Resource ID for a Slot Diagnostic Detector

func NewSlotDiagnosticDetectorID 

func NewSlotDiagnosticDetectorID(subscriptionId string, resourceGroupName string, siteName string, slotName string, diagnosticName string, detectorName string) SlotDiagnosticDetectorId

NewSlotDiagnosticDetectorID returns a new SlotDiagnosticDetectorId struct

func ParseSlotDiagnosticDetectorID 

func ParseSlotDiagnosticDetectorID(input string) (*SlotDiagnosticDetectorId, error)

ParseSlotDiagnosticDetectorID parses 'input' into a SlotDiagnosticDetectorId

func ParseSlotDiagnosticDetectorIDInsensitively 

func ParseSlotDiagnosticDetectorIDInsensitively(input string) (*SlotDiagnosticDetectorId, error)

ParseSlotDiagnosticDetectorIDInsensitively parses 'input' case-insensitively into a SlotDiagnosticDetectorId note: this method should only be used for API response data and not user input

func (SlotDiagnosticDetectorId) ID 

func (id SlotDiagnosticDetectorId) ID() string

ID returns the formatted Slot Diagnostic Detector ID

func (SlotDiagnosticDetectorId) Segments 

func (id SlotDiagnosticDetectorId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Slot Diagnostic Detector ID

func (SlotDiagnosticDetectorId) String 

func (id SlotDiagnosticDetectorId) String() string

String returns a human-readable description of this Slot Diagnostic Detector ID

type SlotDiagnosticId 

type SlotDiagnosticId struct {
	SubscriptionId    string
	ResourceGroupName string
	SiteName          string
	SlotName          string
	DiagnosticName    string
}

SlotDiagnosticId is a struct representing the Resource ID for a Slot Diagnostic

func NewSlotDiagnosticID 

func NewSlotDiagnosticID(subscriptionId string, resourceGroupName string, siteName string, slotName string, diagnosticName string) SlotDiagnosticId

NewSlotDiagnosticID returns a new SlotDiagnosticId struct

func ParseSlotDiagnosticID 

func ParseSlotDiagnosticID(input string) (*SlotDiagnosticId, error)

ParseSlotDiagnosticID parses 'input' into a SlotDiagnosticId

func ParseSlotDiagnosticIDInsensitively 

func ParseSlotDiagnosticIDInsensitively(input string) (*SlotDiagnosticId, error)

ParseSlotDiagnosticIDInsensitively parses 'input' case-insensitively into a SlotDiagnosticId note: this method should only be used for API response data and not user input

func (SlotDiagnosticId) ID 

func (id SlotDiagnosticId) ID() string

ID returns the formatted Slot Diagnostic ID

func (SlotDiagnosticId) Segments 

func (id SlotDiagnosticId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Slot Diagnostic ID

func (SlotDiagnosticId) String 

func (id SlotDiagnosticId) String() string

String returns a human-readable description of this Slot Diagnostic ID

type SlotId 

type SlotId struct {
	SubscriptionId    string
	ResourceGroupName string
	SiteName          string
	SlotName          string
}

SlotId is a struct representing the Resource ID for a Slot

func NewSlotID 

func NewSlotID(subscriptionId string, resourceGroupName string, siteName string, slotName string) SlotId

NewSlotID returns a new SlotId struct

func ParseSlotID 

func ParseSlotID(input string) (*SlotId, error)

ParseSlotID parses 'input' into a SlotId

func ParseSlotIDInsensitively 

func ParseSlotIDInsensitively(input string) (*SlotId, error)

ParseSlotIDInsensitively parses 'input' case-insensitively into a SlotId note: this method should only be used for API response data and not user input

func (SlotId) ID 

func (id SlotId) ID() string

ID returns the formatted Slot ID

func (SlotId) Segments 

func (id SlotId) Segments() []resourceids.Segment

Segments returns a slice of Resource ID Segments which comprise this Slot ID

func (SlotId) String 

func (id SlotId) String() string

String returns a human-readable description of this Slot ID

type Solution 

type Solution struct {
	Data        *[][]NameValuePair `json:"data,omitempty"`
	Description *string            `json:"description,omitempty"`
	DisplayName *string            `json:"displayName,omitempty"`
	Id          *float64           `json:"id,omitempty"`
	Metadata    *[][]NameValuePair `json:"metadata,omitempty"`
	Order       *float64           `json:"order,omitempty"`
	Type        *SolutionType      `json:"type,omitempty"`
}

type SolutionType 

type SolutionType string
const (
	SolutionTypeBestPractices     SolutionType = "BestPractices"
	SolutionTypeDeepInvestigation SolutionType = "DeepInvestigation"
	SolutionTypeQuickSolution     SolutionType = "QuickSolution"
)

type Status 

type Status struct {
	Message  *string        `json:"message,omitempty"`
	StatusId *InsightStatus `json:"statusId,omitempty"`
}

type SupportTopic 

type SupportTopic struct {
	Id    *string `json:"id,omitempty"`
	PesId *string `json:"pesId,omitempty"`
}

Source Files

View all Source files

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.