Updating based on c76bae01

resource-manager/datafactory/2018-06-01/pipelines/model_continuationsettingsreference.go

@@ -0,0 +1,10 @@
+package pipelines
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See NOTICE.txt in the project root for license information.
+
+type ContinuationSettingsReference struct {
+	ContinuationTtlInMinutes *interface{} `json:"continuationTtlInMinutes,omitempty"`
+	CustomizedCheckpointKey  *interface{} `json:"customizedCheckpointKey,omitempty"`
+	IdleCondition            *interface{} `json:"idleCondition,omitempty"`
+}

resource-manager/datafactory/2018-06-01/pipelines/model_executedataflowactivitytypeproperties.go

@@ -5,6 +5,7 @@ package pipelines
 
 type ExecuteDataFlowActivityTypeProperties struct {
 	Compute                  *ExecuteDataFlowActivityTypePropertiesCompute `json:"compute,omitempty"`
+	ContinuationSettings     *ContinuationSettingsReference                `json:"continuationSettings,omitempty"`
 	ContinueOnError          *interface{}                                  `json:"continueOnError,omitempty"`
 	DataFlow                 DataFlowReference                             `json:"dataFlow"`
 	IntegrationRuntime       *IntegrationRuntimeReference                  `json:"integrationRuntime,omitempty"`

resource-manager/datafactory/2018-06-01/pipelines/model_executepowerqueryactivitytypeproperties.go

@@ -5,6 +5,7 @@ package pipelines
 
 type ExecutePowerQueryActivityTypeProperties struct {
 	Compute                  *ExecuteDataFlowActivityTypePropertiesCompute `json:"compute,omitempty"`
+	ContinuationSettings     *ContinuationSettingsReference                `json:"continuationSettings,omitempty"`
 	ContinueOnError          *interface{}                                  `json:"continueOnError,omitempty"`
 	DataFlow                 DataFlowReference                             `json:"dataFlow"`
 	IntegrationRuntime       *IntegrationRuntimeReference                  `json:"integrationRuntime,omitempty"`

resource-manager/machinelearningservices/2024-04-01/v2workspaceconnectionresource/model_accountkeyauthtypeworkspaceconnectionproperties.go

@@ -14,7 +14,7 @@ import (
 var _ WorkspaceConnectionPropertiesV2 = AccountKeyAuthTypeWorkspaceConnectionProperties{}
 
 type AccountKeyAuthTypeWorkspaceConnectionProperties struct {
-	Credentials *WorkspaceConnectionSharedAccessSignature `json:"credentials,omitempty"`
+	Credentials *WorkspaceConnectionAccountKey `json:"credentials,omitempty"`
 
 	// Fields inherited from WorkspaceConnectionPropertiesV2
 	Category                *ConnectionCategory `json:"category,omitempty"`

resource-manager/machinelearningservices/2024-04-01/v2workspaceconnectionresource/model_workspaceconnectionaccountkey.go

@@ -0,0 +1,8 @@
+package v2workspaceconnectionresource
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See NOTICE.txt in the project root for license information.
+
+type WorkspaceConnectionAccountKey struct {
+	Key *string `json:"key,omitempty"`
+}

resource-manager/netapp/2023-11-01/volumes/model_volumepatchproperties.go

@@ -12,6 +12,7 @@ type VolumePatchProperties struct {
 	DefaultUserQuotaInKiBs    *int64                               `json:"defaultUserQuotaInKiBs,omitempty"`
 	ExportPolicy              *VolumePatchPropertiesExportPolicy   `json:"exportPolicy,omitempty"`
 	IsDefaultQuotaEnabled     *bool                                `json:"isDefaultQuotaEnabled,omitempty"`
+	ProtocolTypes             *[]string                            `json:"protocolTypes,omitempty"`
 	ServiceLevel              *ServiceLevel                        `json:"serviceLevel,omitempty"`
 	SmbAccessBasedEnumeration *SmbAccessBasedEnumeration           `json:"smbAccessBasedEnumeration,omitempty"`
 	SmbNonBrowsable           *SmbNonBrowsable                     `json:"smbNonBrowsable,omitempty"`

resource-manager/resourcegraph/2022-10-01/client.go

@@ -6,23 +6,41 @@ package v2022_10_01
 import (
 	"fmt"
 
+	"github.com/hashicorp/go-azure-sdk/resource-manager/resourcegraph/2022-10-01/graphqueries"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/resourcegraph/2022-10-01/graphquery"
 	"github.com/hashicorp/go-azure-sdk/resource-manager/resourcegraph/2022-10-01/resources"
 	"github.com/hashicorp/go-azure-sdk/sdk/client/resourcemanager"
 	sdkEnv "github.com/hashicorp/go-azure-sdk/sdk/environments"
 )
 
 type Client struct {
-	Resources *resources.ResourcesClient
+	GraphQuery   *graphquery.GraphQueryClient
+	Graphqueries *graphqueries.GraphqueriesClient
+	Resources    *resources.ResourcesClient
 }
 
 func NewClientWithBaseURI(sdkApi sdkEnv.Api, configureFunc func(c *resourcemanager.Client)) (*Client, error) {
+	graphQueryClient, err := graphquery.NewGraphQueryClientWithBaseURI(sdkApi)
+	if err != nil {
+		return nil, fmt.Errorf("building GraphQuery client: %+v", err)
+	}
+	configureFunc(graphQueryClient.Client)
+
+	graphqueriesClient, err := graphqueries.NewGraphqueriesClientWithBaseURI(sdkApi)
+	if err != nil {
+		return nil, fmt.Errorf("building Graphqueries client: %+v", err)
+	}
+	configureFunc(graphqueriesClient.Client)
+
 	resourcesClient, err := resources.NewResourcesClientWithBaseURI(sdkApi)
 	if err != nil {
 		return nil, fmt.Errorf("building Resources client: %+v", err)
 	}
 	configureFunc(resourcesClient.Client)
 
 	return &Client{
-		Resources: resourcesClient,
+		GraphQuery:   graphQueryClient,
+		Graphqueries: graphqueriesClient,
+		Resources:    resourcesClient,
 	}, nil
 }

resource-manager/resourcegraph/2022-10-01/graphqueries/README.md

@@ -0,0 +1,41 @@
+
+## `github.com/hashicorp/go-azure-sdk/resource-manager/resourcegraph/2022-10-01/graphqueries` Documentation
+
+The `graphqueries` SDK allows for interaction with the Azure Resource Manager Service `resourcegraph` (API Version `2022-10-01`).
+
+This readme covers example usages, but further information on [using this SDK can be found in the project root](https://github.com/hashicorp/go-azure-sdk/tree/main/docs).
+
+### Import Path
+
+```go
+import "github.com/hashicorp/go-azure-sdk/resource-manager/resourcegraph/2022-10-01/graphqueries"
+```
+
+
+### Client Initialization
+
+```go
+client := graphqueries.NewGraphqueriesClientWithBaseURI("https://management.azure.com")
+client.Client.Authorizer = authorizer
+```
+
+
+### Example Usage: `GraphqueriesClient.GraphQueryUpdate`
+
+```go
+ctx := context.TODO()
+id := graphqueries.NewQueryID("12345678-1234-9876-4563-123456789012", "example-resource-group", "queryValue")
+
+payload := graphqueries.GraphQueryUpdateParameters{
+	// ...
+}
+
+
+read, err := client.GraphQueryUpdate(ctx, id, payload)
+if err != nil {
+	// handle the error
+}
+if model := read.Model; model != nil {
+	// do something with the model/response object
+}
+```

resource-manager/resourcegraph/2022-10-01/graphqueries/client.go

@@ -0,0 +1,26 @@
+package graphqueries
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/go-azure-sdk/sdk/client/resourcemanager"
+	sdkEnv "github.com/hashicorp/go-azure-sdk/sdk/environments"
+)
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See NOTICE.txt in the project root for license information.
+
+type GraphqueriesClient struct {
+	Client *resourcemanager.Client
+}
+
+func NewGraphqueriesClientWithBaseURI(sdkApi sdkEnv.Api) (*GraphqueriesClient, error) {
+	client, err := resourcemanager.NewResourceManagerClient(sdkApi, "graphqueries", defaultApiVersion)
+	if err != nil {
+		return nil, fmt.Errorf("instantiating GraphqueriesClient: %+v", err)
+	}
+
+	return &GraphqueriesClient{
+		Client: client,
+	}, nil
+}

resource-manager/resourcegraph/2022-10-01/graphqueries/constants.go

@@ -0,0 +1,48 @@
+package graphqueries
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See NOTICE.txt in the project root for license information.
+
+type ResultKind string
+
+const (
+	ResultKindBasic ResultKind = "basic"
+)
+
+func PossibleValuesForResultKind() []string {
+	return []string{
+		string(ResultKindBasic),
+	}
+}
+
+func (s *ResultKind) UnmarshalJSON(bytes []byte) error {
+	var decoded string
+	if err := json.Unmarshal(bytes, &decoded); err != nil {
+		return fmt.Errorf("unmarshaling: %+v", err)
+	}
+	out, err := parseResultKind(decoded)
+	if err != nil {
+		return fmt.Errorf("parsing %q: %+v", decoded, err)
+	}
+	*s = *out
+	return nil
+}
+
+func parseResultKind(input string) (*ResultKind, error) {
+	vals := map[string]ResultKind{
+		"basic": ResultKindBasic,
+	}
+	if v, ok := vals[strings.ToLower(input)]; ok {
+		return &v, nil
+	}
+
+	// otherwise presume it's an undefined value and best-effort it
+	out := ResultKind(input)
+	return &out, nil
+}

resource-manager/resourcegraph/2022-10-01/graphqueries/id_query.go

@@ -0,0 +1,130 @@
+package graphqueries
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/recaser"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/resourceids"
+)
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See NOTICE.txt in the project root for license information.
+
+func init() {
+	recaser.RegisterResourceId(&QueryId{})
+}
+
+var _ resourceids.ResourceId = &QueryId{}
+
+// QueryId is a struct representing the Resource ID for a Query
+type QueryId struct {
+	SubscriptionId    string
+	ResourceGroupName string
+	QueryName         string
+}
+
+// NewQueryID returns a new QueryId struct
+func NewQueryID(subscriptionId string, resourceGroupName string, queryName string) QueryId {
+	return QueryId{
+		SubscriptionId:    subscriptionId,
+		ResourceGroupName: resourceGroupName,
+		QueryName:         queryName,
+	}
+}
+
+// ParseQueryID parses 'input' into a QueryId
+func ParseQueryID(input string) (*QueryId, error) {
+	parser := resourceids.NewParserFromResourceIdType(&QueryId{})
+	parsed, err := parser.Parse(input, false)
+	if err != nil {
+		return nil, fmt.Errorf("parsing %q: %+v", input, err)
+	}
+
+	id := QueryId{}
+	if err := id.FromParseResult(*parsed); err != nil {
+		return nil, err
+	}
+
+	return &id, nil
+}
+
+// ParseQueryIDInsensitively parses 'input' case-insensitively into a QueryId
+// note: this method should only be used for API response data and not user input
+func ParseQueryIDInsensitively(input string) (*QueryId, error) {
+	parser := resourceids.NewParserFromResourceIdType(&QueryId{})
+	parsed, err := parser.Parse(input, true)
+	if err != nil {
+		return nil, fmt.Errorf("parsing %q: %+v", input, err)
+	}
+
+	id := QueryId{}
+	if err := id.FromParseResult(*parsed); err != nil {
+		return nil, err
+	}
+
+	return &id, nil
+}
+
+func (id *QueryId) FromParseResult(input resourceids.ParseResult) error {
+	var ok bool
+
+	if id.SubscriptionId, ok = input.Parsed["subscriptionId"]; !ok {
+		return resourceids.NewSegmentNotSpecifiedError(id, "subscriptionId", input)
+	}
+
+	if id.ResourceGroupName, ok = input.Parsed["resourceGroupName"]; !ok {
+		return resourceids.NewSegmentNotSpecifiedError(id, "resourceGroupName", input)
+	}
+
+	if id.QueryName, ok = input.Parsed["queryName"]; !ok {
+		return resourceids.NewSegmentNotSpecifiedError(id, "queryName", input)
+	}
+
+	return nil
+}
+
+// ValidateQueryID checks that 'input' can be parsed as a Query ID
+func ValidateQueryID(input interface{}, key string) (warnings []string, errors []error) {
+	v, ok := input.(string)
+	if !ok {
+		errors = append(errors, fmt.Errorf("expected %q to be a string", key))
+		return
+	}
+
+	if _, err := ParseQueryID(v); err != nil {
+		errors = append(errors, err)
+	}
+
+	return
+}
+
+// ID returns the formatted Query ID
+func (id QueryId) ID() string {
+	fmtString := "/subscriptions/%s/resourceGroups/%s/providers/Microsoft.ResourceGraph/queries/%s"
+	return fmt.Sprintf(fmtString, id.SubscriptionId, id.ResourceGroupName, id.QueryName)
+}
+
+// Segments returns a slice of Resource ID Segments which comprise this Query ID
+func (id QueryId) Segments() []resourceids.Segment {
+	return []resourceids.Segment{
+		resourceids.StaticSegment("staticSubscriptions", "subscriptions", "subscriptions"),
+		resourceids.SubscriptionIdSegment("subscriptionId", "12345678-1234-9876-4563-123456789012"),
+		resourceids.StaticSegment("staticResourceGroups", "resourceGroups", "resourceGroups"),
+		resourceids.ResourceGroupSegment("resourceGroupName", "example-resource-group"),
+		resourceids.StaticSegment("staticProviders", "providers", "providers"),
+		resourceids.ResourceProviderSegment("staticMicrosoftResourceGraph", "Microsoft.ResourceGraph", "Microsoft.ResourceGraph"),
+		resourceids.StaticSegment("staticQueries", "queries", "queries"),
+		resourceids.UserSpecifiedSegment("queryName", "queryValue"),
+	}
+}
+
+// String returns a human-readable description of this Query ID
+func (id QueryId) String() string {
+	components := []string{
+		fmt.Sprintf("Subscription: %q", id.SubscriptionId),
+		fmt.Sprintf("Resource Group Name: %q", id.ResourceGroupName),
+		fmt.Sprintf("Query Name: %q", id.QueryName),
+	}
+	return fmt.Sprintf("Query (%s)", strings.Join(components, "\n"))
+}