diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/CHANGELOG.md b/sdk/resourcemanager/appnetwork/armappnetwork/CHANGELOG.md new file mode 100644 index 000000000000..ea174fb3e116 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/CHANGELOG.md @@ -0,0 +1,8 @@ +# Release History + +## 0.1.0 (2026-03-25) +### Other Changes + +The package of `github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appnetwork/armappnetwork` is using our [next generation design principles](https://azure.github.io/azure-sdk/general_introduction.html). + +To learn more, please refer to our documentation [Quick Start](https://aka.ms/azsdk/go/mgmt). \ No newline at end of file diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/LICENSE.txt b/sdk/resourcemanager/appnetwork/armappnetwork/LICENSE.txt new file mode 100644 index 000000000000..dc0c2ffb3dc1 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/LICENSE.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Microsoft Corporation. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/README.md b/sdk/resourcemanager/appnetwork/armappnetwork/README.md new file mode 100644 index 000000000000..c251b2576c29 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/README.md @@ -0,0 +1,90 @@ +# Azure Kubernetes Application Network Module for Go + +The `armappnetwork` module provides operations for working with Azure Kubernetes Application Network. + +[Source code](https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/resourcemanager/appnetwork/armappnetwork) + +# Getting started + +## Prerequisites + +- An [Azure subscription](https://azure.microsoft.com/free/) +- [Supported](https://aka.ms/azsdk/go/supported-versions) version of Go (You could download and install the latest version of Go from [here](https://go.dev/doc/install). 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](https://go.dev/doc/manage-install).) + +## Install the package + +This project uses [Go modules](https://github.com/golang/go/wiki/Modules) for versioning and dependency management. + +Install the Azure Kubernetes Application Network module: + +```sh +go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appnetwork/armappnetwork +``` + +## Authorization + +When creating a client, you will need to provide a credential for authenticating with Azure Kubernetes Application Network. The `azidentity` module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more. + +```go +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](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity). + +## Client Factory + +Azure Kubernetes Application Network module consists of one or more clients. We provide a client factory which could be used to create any client in this module. + +```go +clientFactory, err := armappnetwork.NewClientFactory(, 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](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore). + +```go +options := arm.ClientOptions { + ClientOptions: azcore.ClientOptions { + Cloud: cloud.AzureChina, + }, +} +clientFactory, err := armappnetwork.NewClientFactory(, 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. + +```go +client := clientFactory.NewAppLinkMembersClient() +``` + +## 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](https://github.com/Azure/azure-sdk-for-go/issues) and assign the `Appnetwork` 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](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](https://opensource.microsoft.com/codeofconduct/). +For more information, see the +[Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) +or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any +additional questions or comments. \ No newline at end of file diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/applinkmembers_client.go b/sdk/resourcemanager/appnetwork/armappnetwork/applinkmembers_client.go new file mode 100644 index 000000000000..22972826b0fc --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/applinkmembers_client.go @@ -0,0 +1,427 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork + +import ( + "context" + "errors" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "net/url" + "strings" +) + +// AppLinkMembersClient contains the methods for the AppLinkMembers group. +// Don't use this type directly, use NewAppLinkMembersClient() instead. +type AppLinkMembersClient struct { + internal *arm.Client + subscriptionID string +} + +// NewAppLinkMembersClient creates a new instance of AppLinkMembersClient with the specified values. +// - subscriptionID - The ID of the target subscription. The value must be an UUID. +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - Contains optional client configuration. Pass nil to accept the default values. +func NewAppLinkMembersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AppLinkMembersClient, error) { + cl, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &AppLinkMembersClient{ + subscriptionID: subscriptionID, + internal: cl, + } + return client, nil +} + +// BeginCreateOrUpdate - Create an AppLinkMember. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - appLinkName - The name of the AppLink +// - appLinkMemberName - The name of the AppLinkMember +// - resource - Resource create parameters. +// - options - AppLinkMembersClientBeginCreateOrUpdateOptions contains the optional parameters for the AppLinkMembersClient.BeginCreateOrUpdate +// method. +func (client *AppLinkMembersClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, resource AppLinkMember, options *AppLinkMembersClientBeginCreateOrUpdateOptions) (*runtime.Poller[AppLinkMembersClientCreateOrUpdateResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.createOrUpdate(ctx, resourceGroupName, appLinkName, appLinkMemberName, resource, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[AppLinkMembersClientCreateOrUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[AppLinkMembersClientCreateOrUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// CreateOrUpdate - Create an AppLinkMember. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +func (client *AppLinkMembersClient) createOrUpdate(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, resource AppLinkMember, options *AppLinkMembersClientBeginCreateOrUpdateOptions) (*http.Response, error) { + var err error + const operationName = "AppLinkMembersClient.BeginCreateOrUpdate" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, appLinkName, appLinkMemberName, resource, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusCreated) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// createOrUpdateCreateRequest creates the CreateOrUpdate request. +func (client *AppLinkMembersClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, resource AppLinkMember, _ *AppLinkMembersClientBeginCreateOrUpdateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AppLink/appLinks/{appLinkName}/appLinkMembers/{appLinkMemberName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if appLinkName == "" { + return nil, errors.New("parameter appLinkName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkName}", url.PathEscape(appLinkName)) + if appLinkMemberName == "" { + return nil, errors.New("parameter appLinkMemberName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkMemberName}", url.PathEscape(appLinkMemberName)) + req, err := runtime.NewRequest(ctx, http.MethodPut, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + req.Raw().Header["Content-Type"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, resource); err != nil { + return nil, err + } + return req, nil +} + +// BeginDelete - Delete an AppLinkMember. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - appLinkName - The name of the AppLink +// - appLinkMemberName - The name of the AppLinkMember +// - options - AppLinkMembersClientBeginDeleteOptions contains the optional parameters for the AppLinkMembersClient.BeginDelete +// method. +func (client *AppLinkMembersClient) BeginDelete(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, options *AppLinkMembersClientBeginDeleteOptions) (*runtime.Poller[AppLinkMembersClientDeleteResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.deleteOperation(ctx, resourceGroupName, appLinkName, appLinkMemberName, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[AppLinkMembersClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[AppLinkMembersClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Delete - Delete an AppLinkMember. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +func (client *AppLinkMembersClient) deleteOperation(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, options *AppLinkMembersClientBeginDeleteOptions) (*http.Response, error) { + var err error + const operationName = "AppLinkMembersClient.BeginDelete" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.deleteCreateRequest(ctx, resourceGroupName, appLinkName, appLinkMemberName, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusAccepted, http.StatusNoContent) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// deleteCreateRequest creates the Delete request. +func (client *AppLinkMembersClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, _ *AppLinkMembersClientBeginDeleteOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AppLink/appLinks/{appLinkName}/appLinkMembers/{appLinkMemberName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if appLinkName == "" { + return nil, errors.New("parameter appLinkName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkName}", url.PathEscape(appLinkName)) + if appLinkMemberName == "" { + return nil, errors.New("parameter appLinkMemberName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkMemberName}", url.PathEscape(appLinkMemberName)) + req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + return req, nil +} + +// Get - Get an AppLinkMember. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - appLinkName - The name of the AppLink +// - appLinkMemberName - The name of the AppLinkMember +// - options - AppLinkMembersClientGetOptions contains the optional parameters for the AppLinkMembersClient.Get method. +func (client *AppLinkMembersClient) Get(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, options *AppLinkMembersClientGetOptions) (AppLinkMembersClientGetResponse, error) { + var err error + const operationName = "AppLinkMembersClient.Get" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.getCreateRequest(ctx, resourceGroupName, appLinkName, appLinkMemberName, options) + if err != nil { + return AppLinkMembersClientGetResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return AppLinkMembersClientGetResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return AppLinkMembersClientGetResponse{}, err + } + resp, err := client.getHandleResponse(httpResp) + return resp, err +} + +// getCreateRequest creates the Get request. +func (client *AppLinkMembersClient) getCreateRequest(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, _ *AppLinkMembersClientGetOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AppLink/appLinks/{appLinkName}/appLinkMembers/{appLinkMemberName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if appLinkName == "" { + return nil, errors.New("parameter appLinkName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkName}", url.PathEscape(appLinkName)) + if appLinkMemberName == "" { + return nil, errors.New("parameter appLinkMemberName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkMemberName}", url.PathEscape(appLinkMemberName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// getHandleResponse handles the Get response. +func (client *AppLinkMembersClient) getHandleResponse(resp *http.Response) (AppLinkMembersClientGetResponse, error) { + result := AppLinkMembersClientGetResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.AppLinkMember); err != nil { + return AppLinkMembersClientGetResponse{}, err + } + return result, nil +} + +// NewListByAppLinkPager - List AppLinkMember resources by AppLink. +// +// Generated from API version 2025-08-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - appLinkName - The name of the AppLink +// - options - AppLinkMembersClientListByAppLinkOptions contains the optional parameters for the AppLinkMembersClient.NewListByAppLinkPager +// method. +func (client *AppLinkMembersClient) NewListByAppLinkPager(resourceGroupName string, appLinkName string, options *AppLinkMembersClientListByAppLinkOptions) *runtime.Pager[AppLinkMembersClientListByAppLinkResponse] { + return runtime.NewPager(runtime.PagingHandler[AppLinkMembersClientListByAppLinkResponse]{ + More: func(page AppLinkMembersClientListByAppLinkResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *AppLinkMembersClientListByAppLinkResponse) (AppLinkMembersClientListByAppLinkResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "AppLinkMembersClient.NewListByAppLinkPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listByAppLinkCreateRequest(ctx, resourceGroupName, appLinkName, options) + }, nil) + if err != nil { + return AppLinkMembersClientListByAppLinkResponse{}, err + } + return client.listByAppLinkHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listByAppLinkCreateRequest creates the ListByAppLink request. +func (client *AppLinkMembersClient) listByAppLinkCreateRequest(ctx context.Context, resourceGroupName string, appLinkName string, _ *AppLinkMembersClientListByAppLinkOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AppLink/appLinks/{appLinkName}/appLinkMembers" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if appLinkName == "" { + return nil, errors.New("parameter appLinkName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkName}", url.PathEscape(appLinkName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listByAppLinkHandleResponse handles the ListByAppLink response. +func (client *AppLinkMembersClient) listByAppLinkHandleResponse(resp *http.Response) (AppLinkMembersClientListByAppLinkResponse, error) { + result := AppLinkMembersClientListByAppLinkResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.AppLinkMemberListResult); err != nil { + return AppLinkMembersClientListByAppLinkResponse{}, err + } + return result, nil +} + +// BeginUpdate - Update an AppLinkMember. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - appLinkName - The name of the AppLink +// - appLinkMemberName - The name of the AppLinkMember +// - properties - The resource properties to be updated. +// - options - AppLinkMembersClientBeginUpdateOptions contains the optional parameters for the AppLinkMembersClient.BeginUpdate +// method. +func (client *AppLinkMembersClient) BeginUpdate(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, properties AppLinkMemberUpdate, options *AppLinkMembersClientBeginUpdateOptions) (*runtime.Poller[AppLinkMembersClientUpdateResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.update(ctx, resourceGroupName, appLinkName, appLinkMemberName, properties, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[AppLinkMembersClientUpdateResponse]{ + FinalStateVia: runtime.FinalStateViaAzureAsyncOp, + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[AppLinkMembersClientUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Update - Update an AppLinkMember. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +func (client *AppLinkMembersClient) update(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, properties AppLinkMemberUpdate, options *AppLinkMembersClientBeginUpdateOptions) (*http.Response, error) { + var err error + const operationName = "AppLinkMembersClient.BeginUpdate" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.updateCreateRequest(ctx, resourceGroupName, appLinkName, appLinkMemberName, properties, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusAccepted) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// updateCreateRequest creates the Update request. +func (client *AppLinkMembersClient) updateCreateRequest(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, properties AppLinkMemberUpdate, _ *AppLinkMembersClientBeginUpdateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AppLink/appLinks/{appLinkName}/appLinkMembers/{appLinkMemberName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if appLinkName == "" { + return nil, errors.New("parameter appLinkName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkName}", url.PathEscape(appLinkName)) + if appLinkMemberName == "" { + return nil, errors.New("parameter appLinkMemberName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkMemberName}", url.PathEscape(appLinkMemberName)) + req, err := runtime.NewRequest(ctx, http.MethodPatch, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + req.Raw().Header["Content-Type"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, properties); err != nil { + return nil, err + } + return req, nil +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/applinkmembers_client_example_test.go b/sdk/resourcemanager/appnetwork/armappnetwork/applinkmembers_client_example_test.go new file mode 100644 index 000000000000..f2c05313cfc8 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/applinkmembers_client_example_test.go @@ -0,0 +1,394 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork_test + +import ( + "context" + "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/appnetwork/armappnetwork" + "log" +) + +// Generated from example definition: 2025-08-01-preview/AppLinkMembers_CreateOrUpdate.json +func ExampleAppLinkMembersClient_BeginCreateOrUpdate() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + poller, err := clientFactory.NewAppLinkMembersClient().BeginCreateOrUpdate(ctx, "test_rg", "applink-test-01", "member-01", armappnetwork.AppLinkMember{ + Properties: &armappnetwork.AppLinkMemberProperties{ + ClusterType: to.Ptr(armappnetwork.ClusterTypeAKS), + Metadata: &armappnetwork.Metadata{ + ResourceID: to.Ptr("/subscriptions/bc7e0da9-5e4c-4a91-9252-9658837006cf/resourcegroups/applink-rg/providers/Microsoft.ContainerService/managedClusters/applink-member1"), + }, + UpgradeProfile: &armappnetwork.UpgradeProfile{ + Mode: to.Ptr(armappnetwork.UpgradeModeFullyManaged), + FullyManagedUpgradeProfile: &armappnetwork.FullyManagedUpgradeProfile{ + ReleaseChannel: to.Ptr(armappnetwork.UpgradeReleaseChannelStable), + }, + }, + ConnectivityProfile: &armappnetwork.ConnectivityProfile{ + PrivateConnect: &armappnetwork.PrivateConnectProfile{ + SubnetResourceID: to.Ptr("/subscriptions/bc7e0da9-5e4c-4a91-9252-9658837006cf/resourceGroups/applink-vnet-rg/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/subnet1"), + }, + EastWestGateway: &armappnetwork.EastWestGatewayProfile{ + Visibility: to.Ptr(armappnetwork.EastWestGatewayVisibilityInternal), + }, + }, + }, + Tags: map[string]*string{ + "key2913": to.Ptr("test_tag"), + }, + Location: to.Ptr("westus2"), + }, 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 = armappnetwork.AppLinkMembersClientCreateOrUpdateResponse{ + // AppLinkMember: &armappnetwork.AppLinkMember{ + // Properties: &armappnetwork.AppLinkMemberProperties{ + // ClusterType: to.Ptr(armappnetwork.ClusterTypeAKS), + // Metadata: &armappnetwork.Metadata{ + // ResourceID: to.Ptr("/subscriptions/bc7e0da9-5e4c-4a91-9252-9658837006cf/resourcegroups/applink-rg/providers/Microsoft.ContainerService/managedClusters/applink-member1"), + // }, + // UpgradeProfile: &armappnetwork.UpgradeProfile{ + // Mode: to.Ptr(armappnetwork.UpgradeModeFullyManaged), + // FullyManagedUpgradeProfile: &armappnetwork.FullyManagedUpgradeProfile{ + // ReleaseChannel: to.Ptr(armappnetwork.UpgradeReleaseChannelStable), + // }, + // }, + // ObservabilityProfile: &armappnetwork.ObservabilityProfile{ + // Metrics: &armappnetwork.MetricsProfile{ + // MetricsEndpoint: to.Ptr("https://mcp-fqdn"), + // }, + // }, + // ConnectivityProfile: &armappnetwork.ConnectivityProfile{ + // PrivateConnect: &armappnetwork.PrivateConnectProfile{ + // SubnetResourceID: to.Ptr("/subscriptions/bc7e0da9-5e4c-4a91-9252-9658837006cf/resourceGroups/applink-vnet-rg/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/subnet1"), + // }, + // EastWestGateway: &armappnetwork.EastWestGatewayProfile{ + // Visibility: to.Ptr(armappnetwork.EastWestGatewayVisibilityInternal), + // }, + // }, + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // Tags: map[string]*string{ + // "key2913": to.Ptr("test_tag"), + // }, + // Location: to.Ptr("westus2"), + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-01/appLinkMembers/member-01"), + // Name: to.Ptr("member-01"), + // Type: to.Ptr("Microsoft.AppLink/appLinks/appLinkMembers"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("user01"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("user02"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // } +} + +// Generated from example definition: 2025-08-01-preview/AppLinkMembers_Delete.json +func ExampleAppLinkMembersClient_BeginDelete() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + poller, err := clientFactory.NewAppLinkMembersClient().BeginDelete(ctx, "test_rg", "applink-test-01", "member-01", 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) + } +} + +// Generated from example definition: 2025-08-01-preview/AppLinkMembers_Get.json +func ExampleAppLinkMembersClient_Get() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + res, err := clientFactory.NewAppLinkMembersClient().Get(ctx, "test_rg", "applink-test-01", "member-01", 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 = armappnetwork.AppLinkMembersClientGetResponse{ + // AppLinkMember: &armappnetwork.AppLinkMember{ + // Properties: &armappnetwork.AppLinkMemberProperties{ + // ClusterType: to.Ptr(armappnetwork.ClusterTypeAKS), + // Metadata: &armappnetwork.Metadata{ + // ResourceID: to.Ptr("/subscriptions/bc7e0da9-5e4c-4a91-9252-9658837006cf/resourcegroups/applink-rg/providers/Microsoft.ContainerService/managedClusters/applink-member1"), + // }, + // UpgradeProfile: &armappnetwork.UpgradeProfile{ + // Mode: to.Ptr(armappnetwork.UpgradeModeFullyManaged), + // FullyManagedUpgradeProfile: &armappnetwork.FullyManagedUpgradeProfile{ + // ReleaseChannel: to.Ptr(armappnetwork.UpgradeReleaseChannelStable), + // }, + // }, + // ObservabilityProfile: &armappnetwork.ObservabilityProfile{ + // Metrics: &armappnetwork.MetricsProfile{ + // MetricsEndpoint: to.Ptr("https://mcp-fqdn"), + // }, + // }, + // ConnectivityProfile: &armappnetwork.ConnectivityProfile{ + // PrivateConnect: &armappnetwork.PrivateConnectProfile{ + // SubnetResourceID: to.Ptr("/subscriptions/bc7e0da9-5e4c-4a91-9252-9658837006cf/resourceGroups/applink-vnet-rg/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/subnet1"), + // }, + // EastWestGateway: &armappnetwork.EastWestGatewayProfile{ + // Visibility: to.Ptr(armappnetwork.EastWestGatewayVisibilityInternal), + // }, + // }, + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // Tags: map[string]*string{ + // "key2913": to.Ptr("test_tag"), + // }, + // Location: to.Ptr("westus2"), + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-01/appLinkMembers/member-01"), + // Name: to.Ptr("member-01"), + // Type: to.Ptr("Microsoft.AppLink/appLinks/appLinkMembers"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("user01"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("user02"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // } +} + +// Generated from example definition: 2025-08-01-preview/AppLinkMembers_ListByAppLink.json +func ExampleAppLinkMembersClient_NewListByAppLinkPager() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + pager := clientFactory.NewAppLinkMembersClient().NewListByAppLinkPager("test_rg", "applink-test-01", 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 = armappnetwork.AppLinkMembersClientListByAppLinkResponse{ + // AppLinkMemberListResult: armappnetwork.AppLinkMemberListResult{ + // Value: []*armappnetwork.AppLinkMember{ + // { + // Properties: &armappnetwork.AppLinkMemberProperties{ + // ClusterType: to.Ptr(armappnetwork.ClusterTypeAKS), + // Metadata: &armappnetwork.Metadata{ + // ResourceID: to.Ptr("/subscriptions/bc7e0da9-5e4c-4a91-9252-9658837006cf/resourcegroups/applink-rg/providers/Microsoft.ContainerService/managedClusters/applink-member1"), + // }, + // UpgradeProfile: &armappnetwork.UpgradeProfile{ + // Mode: to.Ptr(armappnetwork.UpgradeModeFullyManaged), + // FullyManagedUpgradeProfile: &armappnetwork.FullyManagedUpgradeProfile{ + // ReleaseChannel: to.Ptr(armappnetwork.UpgradeReleaseChannelStable), + // }, + // }, + // ObservabilityProfile: &armappnetwork.ObservabilityProfile{ + // Metrics: &armappnetwork.MetricsProfile{ + // MetricsEndpoint: to.Ptr("https://mcp-fqdn"), + // }, + // }, + // ConnectivityProfile: &armappnetwork.ConnectivityProfile{ + // PrivateConnect: &armappnetwork.PrivateConnectProfile{ + // SubnetResourceID: to.Ptr("/subscriptions/bc7e0da9-5e4c-4a91-9252-9658837006cf/resourceGroups/applink-vnet-rg/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/subnet1"), + // }, + // EastWestGateway: &armappnetwork.EastWestGatewayProfile{ + // Visibility: to.Ptr(armappnetwork.EastWestGatewayVisibilityInternal), + // }, + // }, + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // Tags: map[string]*string{ + // "key2913": to.Ptr("test_tag"), + // }, + // Location: to.Ptr("westus2"), + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-01/appLinkMembers/member-01"), + // Name: to.Ptr("member-01"), + // Type: to.Ptr("Microsoft.AppLink/appLinks/appLinkMembers"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("user01"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("user02"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // { + // Properties: &armappnetwork.AppLinkMemberProperties{ + // ClusterType: to.Ptr(armappnetwork.ClusterTypeAKS), + // Metadata: &armappnetwork.Metadata{ + // ResourceID: to.Ptr("/subscriptions/bc7e0da9-5e4c-4a91-9252-9658837006cf/resourcegroups/applink-rg/providers/Microsoft.ContainerService/managedClusters/applink-member2"), + // }, + // UpgradeProfile: &armappnetwork.UpgradeProfile{ + // Mode: to.Ptr(armappnetwork.UpgradeModeSelfManaged), + // SelfManagedUpgradeProfile: &armappnetwork.SelfManagedUpgradeProfile{ + // Version: to.Ptr("1.27"), + // }, + // }, + // ObservabilityProfile: &armappnetwork.ObservabilityProfile{ + // Metrics: &armappnetwork.MetricsProfile{ + // MetricsEndpoint: to.Ptr("https://mcp-fqdn"), + // }, + // }, + // ConnectivityProfile: &armappnetwork.ConnectivityProfile{ + // EastWestGateway: &armappnetwork.EastWestGatewayProfile{ + // Visibility: to.Ptr(armappnetwork.EastWestGatewayVisibilityExternal), + // }, + // }, + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // Tags: map[string]*string{ + // "env": to.Ptr("production"), + // }, + // Location: to.Ptr("westus2"), + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-01/appLinkMembers/member-02"), + // Name: to.Ptr("member-02"), + // Type: to.Ptr("Microsoft.AppLink/appLinks/appLinkMembers"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("user01"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("user02"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // }, + // NextLink: to.Ptr("https://management.azure.com/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-01/appLinkMembers?api-version=2025-08-01-preview&$skiptoken=eyJjb250aW51YXRpb24iOiAibWVtYmVyLTAzIn0%3D"), + // }, + // } + } +} + +// Generated from example definition: 2025-08-01-preview/AppLinkMembers_Update.json +func ExampleAppLinkMembersClient_BeginUpdate() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + poller, err := clientFactory.NewAppLinkMembersClient().BeginUpdate(ctx, "test_rg", "applink-test-01", "member-01", armappnetwork.AppLinkMemberUpdate{ + Tags: map[string]*string{ + "key7952": to.Ptr("updated_tag_value"), + }, + Properties: &armappnetwork.AppLinkMemberUpdateProperties{ + UpgradeProfile: &armappnetwork.UpgradeProfile{ + Mode: to.Ptr(armappnetwork.UpgradeModeSelfManaged), + SelfManagedUpgradeProfile: &armappnetwork.SelfManagedUpgradeProfile{ + Version: to.Ptr("1.26"), + }, + }, + ConnectivityProfile: &armappnetwork.ConnectivityProfile{ + EastWestGateway: &armappnetwork.EastWestGatewayProfile{ + Visibility: to.Ptr(armappnetwork.EastWestGatewayVisibilityInternal), + }, + }, + }, + }, 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 = armappnetwork.AppLinkMembersClientUpdateResponse{ + // AppLinkMember: &armappnetwork.AppLinkMember{ + // Properties: &armappnetwork.AppLinkMemberProperties{ + // ClusterType: to.Ptr(armappnetwork.ClusterTypeAKS), + // Metadata: &armappnetwork.Metadata{ + // ResourceID: to.Ptr("/subscriptions/bc7e0da9-5e4c-4a91-9252-9658837006cf/resourcegroups/applink-rg/providers/Microsoft.ContainerService/managedClusters/applink-member1"), + // }, + // UpgradeProfile: &armappnetwork.UpgradeProfile{ + // Mode: to.Ptr(armappnetwork.UpgradeModeSelfManaged), + // SelfManagedUpgradeProfile: &armappnetwork.SelfManagedUpgradeProfile{ + // Version: to.Ptr("1.26"), + // }, + // }, + // ObservabilityProfile: &armappnetwork.ObservabilityProfile{ + // Metrics: &armappnetwork.MetricsProfile{ + // MetricsEndpoint: to.Ptr("https://mcp-fqdn"), + // }, + // }, + // ConnectivityProfile: &armappnetwork.ConnectivityProfile{ + // PrivateConnect: &armappnetwork.PrivateConnectProfile{ + // SubnetResourceID: to.Ptr("/subscriptions/bc7e0da9-5e4c-4a91-9252-9658837006cf/resourceGroups/applink-vnet-rg/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/subnet1"), + // }, + // EastWestGateway: &armappnetwork.EastWestGatewayProfile{ + // Visibility: to.Ptr(armappnetwork.EastWestGatewayVisibilityInternal), + // }, + // }, + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // Tags: map[string]*string{ + // "key7952": to.Ptr("updated_tag_value"), + // }, + // Location: to.Ptr("westus2"), + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-01/appLinkMembers/member-01"), + // Name: to.Ptr("member-01"), + // Type: to.Ptr("Microsoft.AppLink/appLinks/appLinkMembers"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("user01"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("user02"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // } +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/applinks_client.go b/sdk/resourcemanager/appnetwork/armappnetwork/applinks_client.go new file mode 100644 index 000000000000..0b0f0483fcd7 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/applinks_client.go @@ -0,0 +1,455 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork + +import ( + "context" + "errors" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "net/url" + "strings" +) + +// AppLinksClient contains the methods for the AppLinks group. +// Don't use this type directly, use NewAppLinksClient() instead. +type AppLinksClient struct { + internal *arm.Client + subscriptionID string +} + +// NewAppLinksClient creates a new instance of AppLinksClient with the specified values. +// - subscriptionID - The ID of the target subscription. The value must be an UUID. +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - Contains optional client configuration. Pass nil to accept the default values. +func NewAppLinksClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AppLinksClient, error) { + cl, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &AppLinksClient{ + subscriptionID: subscriptionID, + internal: cl, + } + return client, nil +} + +// BeginCreateOrUpdate - Create an AppLink. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - appLinkName - The name of the AppLink +// - resource - Resource create parameters. +// - options - AppLinksClientBeginCreateOrUpdateOptions contains the optional parameters for the AppLinksClient.BeginCreateOrUpdate +// method. +func (client *AppLinksClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, appLinkName string, resource AppLink, options *AppLinksClientBeginCreateOrUpdateOptions) (*runtime.Poller[AppLinksClientCreateOrUpdateResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.createOrUpdate(ctx, resourceGroupName, appLinkName, resource, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[AppLinksClientCreateOrUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[AppLinksClientCreateOrUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// CreateOrUpdate - Create an AppLink. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +func (client *AppLinksClient) createOrUpdate(ctx context.Context, resourceGroupName string, appLinkName string, resource AppLink, options *AppLinksClientBeginCreateOrUpdateOptions) (*http.Response, error) { + var err error + const operationName = "AppLinksClient.BeginCreateOrUpdate" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, appLinkName, resource, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusCreated) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// createOrUpdateCreateRequest creates the CreateOrUpdate request. +func (client *AppLinksClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, appLinkName string, resource AppLink, _ *AppLinksClientBeginCreateOrUpdateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AppLink/appLinks/{appLinkName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if appLinkName == "" { + return nil, errors.New("parameter appLinkName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkName}", url.PathEscape(appLinkName)) + req, err := runtime.NewRequest(ctx, http.MethodPut, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + req.Raw().Header["Content-Type"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, resource); err != nil { + return nil, err + } + return req, nil +} + +// BeginDelete - Delete an AppLink. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - appLinkName - The name of the AppLink +// - options - AppLinksClientBeginDeleteOptions contains the optional parameters for the AppLinksClient.BeginDelete method. +func (client *AppLinksClient) BeginDelete(ctx context.Context, resourceGroupName string, appLinkName string, options *AppLinksClientBeginDeleteOptions) (*runtime.Poller[AppLinksClientDeleteResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.deleteOperation(ctx, resourceGroupName, appLinkName, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[AppLinksClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[AppLinksClientDeleteResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Delete - Delete an AppLink. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +func (client *AppLinksClient) deleteOperation(ctx context.Context, resourceGroupName string, appLinkName string, options *AppLinksClientBeginDeleteOptions) (*http.Response, error) { + var err error + const operationName = "AppLinksClient.BeginDelete" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.deleteCreateRequest(ctx, resourceGroupName, appLinkName, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusAccepted, http.StatusNoContent) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// deleteCreateRequest creates the Delete request. +func (client *AppLinksClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, appLinkName string, _ *AppLinksClientBeginDeleteOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AppLink/appLinks/{appLinkName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if appLinkName == "" { + return nil, errors.New("parameter appLinkName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkName}", url.PathEscape(appLinkName)) + req, err := runtime.NewRequest(ctx, http.MethodDelete, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + return req, nil +} + +// Get - Get an AppLink. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - appLinkName - The name of the AppLink +// - options - AppLinksClientGetOptions contains the optional parameters for the AppLinksClient.Get method. +func (client *AppLinksClient) Get(ctx context.Context, resourceGroupName string, appLinkName string, options *AppLinksClientGetOptions) (AppLinksClientGetResponse, error) { + var err error + const operationName = "AppLinksClient.Get" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.getCreateRequest(ctx, resourceGroupName, appLinkName, options) + if err != nil { + return AppLinksClientGetResponse{}, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return AppLinksClientGetResponse{}, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK) { + err = runtime.NewResponseError(httpResp) + return AppLinksClientGetResponse{}, err + } + resp, err := client.getHandleResponse(httpResp) + return resp, err +} + +// getCreateRequest creates the Get request. +func (client *AppLinksClient) getCreateRequest(ctx context.Context, resourceGroupName string, appLinkName string, _ *AppLinksClientGetOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AppLink/appLinks/{appLinkName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if appLinkName == "" { + return nil, errors.New("parameter appLinkName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkName}", url.PathEscape(appLinkName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// getHandleResponse handles the Get response. +func (client *AppLinksClient) getHandleResponse(resp *http.Response) (AppLinksClientGetResponse, error) { + result := AppLinksClientGetResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.AppLink); err != nil { + return AppLinksClientGetResponse{}, err + } + return result, nil +} + +// NewListByResourceGroupPager - List AppLink resources by resource group. +// +// Generated from API version 2025-08-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - options - AppLinksClientListByResourceGroupOptions contains the optional parameters for the AppLinksClient.NewListByResourceGroupPager +// method. +func (client *AppLinksClient) NewListByResourceGroupPager(resourceGroupName string, options *AppLinksClientListByResourceGroupOptions) *runtime.Pager[AppLinksClientListByResourceGroupResponse] { + return runtime.NewPager(runtime.PagingHandler[AppLinksClientListByResourceGroupResponse]{ + More: func(page AppLinksClientListByResourceGroupResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *AppLinksClientListByResourceGroupResponse) (AppLinksClientListByResourceGroupResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "AppLinksClient.NewListByResourceGroupPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listByResourceGroupCreateRequest(ctx, resourceGroupName, options) + }, nil) + if err != nil { + return AppLinksClientListByResourceGroupResponse{}, err + } + return client.listByResourceGroupHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listByResourceGroupCreateRequest creates the ListByResourceGroup request. +func (client *AppLinksClient) listByResourceGroupCreateRequest(ctx context.Context, resourceGroupName string, _ *AppLinksClientListByResourceGroupOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AppLink/appLinks" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listByResourceGroupHandleResponse handles the ListByResourceGroup response. +func (client *AppLinksClient) listByResourceGroupHandleResponse(resp *http.Response) (AppLinksClientListByResourceGroupResponse, error) { + result := AppLinksClientListByResourceGroupResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.AppLinkListResult); err != nil { + return AppLinksClientListByResourceGroupResponse{}, err + } + return result, nil +} + +// NewListBySubscriptionPager - List AppLink resources by subscription. +// +// Generated from API version 2025-08-01-preview +// - options - AppLinksClientListBySubscriptionOptions contains the optional parameters for the AppLinksClient.NewListBySubscriptionPager +// method. +func (client *AppLinksClient) NewListBySubscriptionPager(options *AppLinksClientListBySubscriptionOptions) *runtime.Pager[AppLinksClientListBySubscriptionResponse] { + return runtime.NewPager(runtime.PagingHandler[AppLinksClientListBySubscriptionResponse]{ + More: func(page AppLinksClientListBySubscriptionResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *AppLinksClientListBySubscriptionResponse) (AppLinksClientListBySubscriptionResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "AppLinksClient.NewListBySubscriptionPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listBySubscriptionCreateRequest(ctx, options) + }, nil) + if err != nil { + return AppLinksClientListBySubscriptionResponse{}, err + } + return client.listBySubscriptionHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listBySubscriptionCreateRequest creates the ListBySubscription request. +func (client *AppLinksClient) listBySubscriptionCreateRequest(ctx context.Context, _ *AppLinksClientListBySubscriptionOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.AppLink/appLinks" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listBySubscriptionHandleResponse handles the ListBySubscription response. +func (client *AppLinksClient) listBySubscriptionHandleResponse(resp *http.Response) (AppLinksClientListBySubscriptionResponse, error) { + result := AppLinksClientListBySubscriptionResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.AppLinkListResult); err != nil { + return AppLinksClientListBySubscriptionResponse{}, err + } + return result, nil +} + +// BeginUpdate - Update an AppLink. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - appLinkName - The name of the AppLink +// - properties - The resource properties to be updated. +// - options - AppLinksClientBeginUpdateOptions contains the optional parameters for the AppLinksClient.BeginUpdate method. +func (client *AppLinksClient) BeginUpdate(ctx context.Context, resourceGroupName string, appLinkName string, properties AppLinkUpdate, options *AppLinksClientBeginUpdateOptions) (*runtime.Poller[AppLinksClientUpdateResponse], error) { + if options == nil || options.ResumeToken == "" { + resp, err := client.update(ctx, resourceGroupName, appLinkName, properties, options) + if err != nil { + return nil, err + } + poller, err := runtime.NewPoller(resp, client.internal.Pipeline(), &runtime.NewPollerOptions[AppLinksClientUpdateResponse]{ + FinalStateVia: runtime.FinalStateViaAzureAsyncOp, + Tracer: client.internal.Tracer(), + }) + return poller, err + } else { + return runtime.NewPollerFromResumeToken(options.ResumeToken, client.internal.Pipeline(), &runtime.NewPollerFromResumeTokenOptions[AppLinksClientUpdateResponse]{ + Tracer: client.internal.Tracer(), + }) + } +} + +// Update - Update an AppLink. +// If the operation fails it returns an *azcore.ResponseError type. +// +// Generated from API version 2025-08-01-preview +func (client *AppLinksClient) update(ctx context.Context, resourceGroupName string, appLinkName string, properties AppLinkUpdate, options *AppLinksClientBeginUpdateOptions) (*http.Response, error) { + var err error + const operationName = "AppLinksClient.BeginUpdate" + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, operationName) + ctx, endSpan := runtime.StartSpan(ctx, operationName, client.internal.Tracer(), nil) + defer func() { endSpan(err) }() + req, err := client.updateCreateRequest(ctx, resourceGroupName, appLinkName, properties, options) + if err != nil { + return nil, err + } + httpResp, err := client.internal.Pipeline().Do(req) + if err != nil { + return nil, err + } + if !runtime.HasStatusCode(httpResp, http.StatusOK, http.StatusAccepted) { + err = runtime.NewResponseError(httpResp) + return nil, err + } + return httpResp, nil +} + +// updateCreateRequest creates the Update request. +func (client *AppLinksClient) updateCreateRequest(ctx context.Context, resourceGroupName string, appLinkName string, properties AppLinkUpdate, _ *AppLinksClientBeginUpdateOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AppLink/appLinks/{appLinkName}" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if appLinkName == "" { + return nil, errors.New("parameter appLinkName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkName}", url.PathEscape(appLinkName)) + req, err := runtime.NewRequest(ctx, http.MethodPatch, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + req.Raw().Header["Content-Type"] = []string{"application/json"} + if err := runtime.MarshalAsJSON(req, properties); err != nil { + return nil, err + } + return req, nil +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/applinks_client_example_test.go b/sdk/resourcemanager/appnetwork/armappnetwork/applinks_client_example_test.go new file mode 100644 index 000000000000..2fc62252e09e --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/applinks_client_example_test.go @@ -0,0 +1,401 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork_test + +import ( + "context" + "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/appnetwork/armappnetwork" + "log" +) + +// Generated from example definition: 2025-08-01-preview/AppLinks_CreateOrUpdate.json +func ExampleAppLinksClient_BeginCreateOrUpdate() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + poller, err := clientFactory.NewAppLinksClient().BeginCreateOrUpdate(ctx, "test_rg", "applink-test-01", armappnetwork.AppLink{ + Properties: &armappnetwork.AppLinkProperties{}, + Identity: &armappnetwork.ManagedServiceIdentity{ + Type: to.Ptr(armappnetwork.ManagedServiceIdentityTypeSystemAssigned), + }, + Tags: map[string]*string{ + "key2913": to.Ptr("test_tag"), + }, + Location: to.Ptr("westus2"), + }, 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 = armappnetwork.AppLinksClientCreateOrUpdateResponse{ + // AppLink: &armappnetwork.AppLink{ + // Properties: &armappnetwork.AppLinkProperties{ + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // Identity: &armappnetwork.ManagedServiceIdentity{ + // Type: to.Ptr(armappnetwork.ManagedServiceIdentityTypeSystemAssigned), + // PrincipalID: to.Ptr("00000000-1111-2222-3333-444444444444"), + // TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"), + // }, + // Tags: map[string]*string{ + // "key2913": to.Ptr("test_tag"), + // }, + // Location: to.Ptr("westus2"), + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-01"), + // Name: to.Ptr("applink-test-01"), + // Type: to.Ptr("Microsoft.AppLink/appLinks"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("user01"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("user02"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // } +} + +// Generated from example definition: 2025-08-01-preview/AppLinks_Delete.json +func ExampleAppLinksClient_BeginDelete() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + poller, err := clientFactory.NewAppLinksClient().BeginDelete(ctx, "test_rg", "applink-test-01", 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) + } +} + +// Generated from example definition: 2025-08-01-preview/AppLinks_Get.json +func ExampleAppLinksClient_Get() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + res, err := clientFactory.NewAppLinksClient().Get(ctx, "test_rg", "applink-test-01", 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 = armappnetwork.AppLinksClientGetResponse{ + // AppLink: &armappnetwork.AppLink{ + // Properties: &armappnetwork.AppLinkProperties{ + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // Identity: &armappnetwork.ManagedServiceIdentity{ + // Type: to.Ptr(armappnetwork.ManagedServiceIdentityTypeSystemAssigned), + // PrincipalID: to.Ptr("00000000-1111-2222-3333-444444444444"), + // TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"), + // }, + // Tags: map[string]*string{ + // "key2913": to.Ptr("test_tag"), + // }, + // Location: to.Ptr("westus2"), + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-01"), + // Name: to.Ptr("applink-test-01"), + // Type: to.Ptr("Microsoft.AppLink/appLinks"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("user01"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("user02"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // } +} + +// Generated from example definition: 2025-08-01-preview/AppLinks_ListByResourceGroup.json +func ExampleAppLinksClient_NewListByResourceGroupPager() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + pager := clientFactory.NewAppLinksClient().NewListByResourceGroupPager("test_rg", 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 = armappnetwork.AppLinksClientListByResourceGroupResponse{ + // AppLinkListResult: armappnetwork.AppLinkListResult{ + // Value: []*armappnetwork.AppLink{ + // { + // Properties: &armappnetwork.AppLinkProperties{ + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // Identity: &armappnetwork.ManagedServiceIdentity{ + // Type: to.Ptr(armappnetwork.ManagedServiceIdentityTypeSystemAssigned), + // PrincipalID: to.Ptr("00000000-1111-2222-3333-444444444444"), + // TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"), + // }, + // Tags: map[string]*string{ + // "key2913": to.Ptr("test_tag"), + // }, + // Location: to.Ptr("westus2"), + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-01"), + // Name: to.Ptr("applink-test-01"), + // Type: to.Ptr("Microsoft.AppLink/appLinks"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("user01"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("user02"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // { + // Properties: &armappnetwork.AppLinkProperties{ + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // Identity: &armappnetwork.ManagedServiceIdentity{ + // Type: to.Ptr(armappnetwork.ManagedServiceIdentityTypeUserAssigned), + // UserAssignedIdentities: map[string]*armappnetwork.UserAssignedIdentity{ + // "/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/test-identity": &armappnetwork.UserAssignedIdentity{ + // PrincipalID: to.Ptr("11111111-2222-3333-4444-555555555555"), + // ClientID: to.Ptr("66666666-7777-8888-9999-aaaaaaaaaaaa"), + // }, + // }, + // }, + // Tags: map[string]*string{ + // "environment": to.Ptr("production"), + // }, + // Location: to.Ptr("westus2"), + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-02"), + // Name: to.Ptr("applink-test-02"), + // Type: to.Ptr("Microsoft.AppLink/appLinks"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("user01"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("user02"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // }, + // NextLink: to.Ptr("https://management.azure.com/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks?api-version=2025-08-01-preview&$skiptoken=eyJjb250aW51YXRpb24iOiAiYXBwbGluay10ZXN0LTAzIn0%3D"), + // }, + // } + } +} + +// Generated from example definition: 2025-08-01-preview/AppLinks_ListBySubscription.json +func ExampleAppLinksClient_NewListBySubscriptionPager() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + pager := clientFactory.NewAppLinksClient().NewListBySubscriptionPager(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 = armappnetwork.AppLinksClientListBySubscriptionResponse{ + // AppLinkListResult: armappnetwork.AppLinkListResult{ + // Value: []*armappnetwork.AppLink{ + // { + // Properties: &armappnetwork.AppLinkProperties{ + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // Identity: &armappnetwork.ManagedServiceIdentity{ + // Type: to.Ptr(armappnetwork.ManagedServiceIdentityTypeSystemAssigned), + // PrincipalID: to.Ptr("00000000-1111-2222-3333-444444444444"), + // TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"), + // }, + // Tags: map[string]*string{ + // "environment": to.Ptr("production"), + // "team": to.Ptr("platform"), + // }, + // Location: to.Ptr("westus2"), + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/rg1/providers/Microsoft.AppLink/appLinks/applink-prod-01"), + // Name: to.Ptr("applink-prod-01"), + // Type: to.Ptr("Microsoft.AppLink/appLinks"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("user01"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("user02"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // { + // Properties: &armappnetwork.AppLinkProperties{ + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // Identity: &armappnetwork.ManagedServiceIdentity{ + // Type: to.Ptr(armappnetwork.ManagedServiceIdentityTypeUserAssigned), + // UserAssignedIdentities: map[string]*armappnetwork.UserAssignedIdentity{ + // "/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/rg2/providers/Microsoft.ManagedIdentity/userAssignedIdentities/applink-identity": &armappnetwork.UserAssignedIdentity{ + // PrincipalID: to.Ptr("22222222-3333-4444-5555-666666666666"), + // ClientID: to.Ptr("77777777-8888-9999-aaaa-bbbbbbbbbbbb"), + // }, + // }, + // }, + // Tags: map[string]*string{ + // "environment": to.Ptr("development"), + // "cost-center": to.Ptr("engineering"), + // }, + // Location: to.Ptr("eastus"), + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/rg2/providers/Microsoft.AppLink/appLinks/applink-dev-01"), + // Name: to.Ptr("applink-dev-01"), + // Type: to.Ptr("Microsoft.AppLink/appLinks"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("dev-user"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-10T14:22:30.000Z"); return t}()), + // LastModifiedBy: to.Ptr("dev-user"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-06-15T09:15:45.000Z"); return t}()), + // }, + // }, + // { + // Properties: &armappnetwork.AppLinkProperties{ + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateProvisioning), + // }, + // Identity: &armappnetwork.ManagedServiceIdentity{ + // Type: to.Ptr(armappnetwork.ManagedServiceIdentityTypeSystemAssigned), + // PrincipalID: to.Ptr("33333333-4444-5555-6666-777777777777"), + // TenantID: to.Ptr("00000000-1111-2222-3333-444444444444"), + // }, + // Tags: map[string]*string{ + // "environment": to.Ptr("staging"), + // }, + // Location: to.Ptr("northeurope"), + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/rg3/providers/Microsoft.AppLink/appLinks/applink-staging-01"), + // Name: to.Ptr("applink-staging-01"), + // Type: to.Ptr("Microsoft.AppLink/appLinks"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("staging-user"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-07-01T08:30:00.000Z"); return t}()), + // LastModifiedBy: to.Ptr("staging-user"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-07-01T08:30:00.000Z"); return t}()), + // }, + // }, + // }, + // NextLink: to.Ptr("https://management.azure.com/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/providers/Microsoft.AppLink/appLinks?api-version=2025-08-01-preview&$skiptoken=eyJjb250aW51YXRpb24iOiAiYXBwbGluay1zdGFnaW5nLTAyIn0%3D"), + // }, + // } + } +} + +// Generated from example definition: 2025-08-01-preview/AppLinks_Update.json +func ExampleAppLinksClient_BeginUpdate() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + poller, err := clientFactory.NewAppLinksClient().BeginUpdate(ctx, "test_rg", "applink-test-01", armappnetwork.AppLinkUpdate{ + Tags: map[string]*string{ + "environment": to.Ptr("production"), + "cost-center": to.Ptr("platform"), + }, + }, 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 = armappnetwork.AppLinksClientUpdateResponse{ + // AppLink: &armappnetwork.AppLink{ + // Properties: &armappnetwork.AppLinkProperties{ + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // Identity: &armappnetwork.ManagedServiceIdentity{ + // Type: to.Ptr(armappnetwork.ManagedServiceIdentityTypeUserAssigned), + // UserAssignedIdentities: map[string]*armappnetwork.UserAssignedIdentity{ + // "/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/applink-identity": &armappnetwork.UserAssignedIdentity{ + // PrincipalID: to.Ptr("44444444-5555-6666-7777-888888888888"), + // ClientID: to.Ptr("99999999-aaaa-bbbb-cccc-dddddddddddd"), + // }, + // }, + // }, + // Tags: map[string]*string{ + // "environment": to.Ptr("production"), + // "cost-center": to.Ptr("platform"), + // }, + // Location: to.Ptr("westus2"), + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-01"), + // Name: to.Ptr("applink-test-01"), + // Type: to.Ptr("Microsoft.AppLink/appLinks"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("user01"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("user02"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeUser), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // } +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/availableversions_client.go b/sdk/resourcemanager/appnetwork/armappnetwork/availableversions_client.go new file mode 100644 index 000000000000..27c5399fb909 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/availableversions_client.go @@ -0,0 +1,103 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork + +import ( + "context" + "errors" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "net/url" + "strings" +) + +// AvailableVersionsClient contains the methods for the AvailableVersions group. +// Don't use this type directly, use NewAvailableVersionsClient() instead. +type AvailableVersionsClient struct { + internal *arm.Client + subscriptionID string +} + +// NewAvailableVersionsClient creates a new instance of AvailableVersionsClient with the specified values. +// - subscriptionID - The ID of the target subscription. The value must be an UUID. +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - Contains optional client configuration. Pass nil to accept the default values. +func NewAvailableVersionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AvailableVersionsClient, error) { + cl, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &AvailableVersionsClient{ + subscriptionID: subscriptionID, + internal: cl, + } + return client, nil +} + +// NewListByLocationPager - List AvailableVersion resources by location. +// +// Generated from API version 2025-08-01-preview +// - location - The name of the Azure region. +// - options - AvailableVersionsClientListByLocationOptions contains the optional parameters for the AvailableVersionsClient.NewListByLocationPager +// method. +func (client *AvailableVersionsClient) NewListByLocationPager(location string, options *AvailableVersionsClientListByLocationOptions) *runtime.Pager[AvailableVersionsClientListByLocationResponse] { + return runtime.NewPager(runtime.PagingHandler[AvailableVersionsClientListByLocationResponse]{ + More: func(page AvailableVersionsClientListByLocationResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *AvailableVersionsClientListByLocationResponse) (AvailableVersionsClientListByLocationResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "AvailableVersionsClient.NewListByLocationPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listByLocationCreateRequest(ctx, location, options) + }, nil) + if err != nil { + return AvailableVersionsClientListByLocationResponse{}, err + } + return client.listByLocationHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listByLocationCreateRequest creates the ListByLocation request. +func (client *AvailableVersionsClient) listByLocationCreateRequest(ctx context.Context, location string, options *AvailableVersionsClientListByLocationOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.AppLink/locations/{location}/availableVersions" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if location == "" { + return nil, errors.New("parameter location cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{location}", url.PathEscape(location)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + if options != nil && options.KubernetesVersion != nil { + reqQP.Set("kubernetesVersion", *options.KubernetesVersion) + } + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listByLocationHandleResponse handles the ListByLocation response. +func (client *AvailableVersionsClient) listByLocationHandleResponse(resp *http.Response) (AvailableVersionsClientListByLocationResponse, error) { + result := AvailableVersionsClientListByLocationResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.AvailableVersionListResult); err != nil { + return AvailableVersionsClientListByLocationResponse{}, err + } + return result, nil +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/availableversions_client_example_test.go b/sdk/resourcemanager/appnetwork/armappnetwork/availableversions_client_example_test.go new file mode 100644 index 000000000000..94f29dc6bde3 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/availableversions_client_example_test.go @@ -0,0 +1,209 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork_test + +import ( + "context" + "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/appnetwork/armappnetwork" + "log" +) + +// Generated from example definition: 2025-08-01-preview/AvailableVersions_ListByLocation.json +func ExampleAvailableVersionsClient_NewListByLocationPager_availableVersionsListByLocation() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + pager := clientFactory.NewAvailableVersionsClient().NewListByLocationPager("westus2", 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 = armappnetwork.AvailableVersionsClientListByLocationResponse{ + // AvailableVersionListResult: armappnetwork.AvailableVersionListResult{ + // Value: []*armappnetwork.AvailableVersion{ + // { + // Properties: &armappnetwork.AvailableVersionProperties{ + // KubernetesVersion: to.Ptr("1.31"), + // FullyManagedVersions: &armappnetwork.FullyManagedVersions{ + // ReleaseChannels: []*armappnetwork.ReleaseChannelInfo{ + // { + // ReleaseChannel: to.Ptr("stable"), + // Version: to.Ptr("1.18.2"), + // }, + // { + // ReleaseChannel: to.Ptr("rapid"), + // Version: to.Ptr("1.19.1"), + // }, + // }, + // }, + // SelfManagedVersions: &armappnetwork.SelfManagedVersions{ + // Versions: []*armappnetwork.VersionInfo{ + // { + // Version: to.Ptr("1.17.8"), + // Upgrades: []*string{ + // to.Ptr("1.18.2"), + // to.Ptr("1.18.5"), + // }, + // }, + // { + // Version: to.Ptr("1.18.2"), + // Upgrades: []*string{ + // to.Ptr("1.18.5"), + // to.Ptr("1.19.1"), + // }, + // }, + // }, + // }, + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/providers/Microsoft.AppLink/locations/westus2/availableVersions/kubernetes-1.31"), + // Name: to.Ptr("kubernetes-1.31"), + // Type: to.Ptr("Microsoft.AppLink/locations/availableVersions"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("system"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeApplication), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("system"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeApplication), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // { + // Properties: &armappnetwork.AvailableVersionProperties{ + // KubernetesVersion: to.Ptr("1.30"), + // FullyManagedVersions: &armappnetwork.FullyManagedVersions{ + // ReleaseChannels: []*armappnetwork.ReleaseChannelInfo{ + // { + // ReleaseChannel: to.Ptr("stable"), + // Version: to.Ptr("1.17.5"), + // }, + // { + // ReleaseChannel: to.Ptr("rapid"), + // Version: to.Ptr("1.18.2"), + // }, + // }, + // }, + // SelfManagedVersions: &armappnetwork.SelfManagedVersions{ + // Versions: []*armappnetwork.VersionInfo{ + // { + // Version: to.Ptr("1.16.8"), + // Upgrades: []*string{ + // to.Ptr("1.17.5"), + // to.Ptr("1.18.2"), + // }, + // }, + // { + // Version: to.Ptr("1.17.5"), + // Upgrades: []*string{ + // to.Ptr("1.18.2"), + // }, + // }, + // }, + // }, + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/providers/Microsoft.AppLink/locations/westus2/availableVersions/kubernetes-1.30"), + // Name: to.Ptr("kubernetes-1.30"), + // Type: to.Ptr("Microsoft.AppLink/locations/availableVersions"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("system"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeApplication), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("system"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeApplication), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // }, + // }, + // } + } +} + +// Generated from example definition: 2025-08-01-preview/AvailableVersions_ListByLocationWithFilter.json +func ExampleAvailableVersionsClient_NewListByLocationPager_availableVersionsListByLocationWithFilter() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + pager := clientFactory.NewAvailableVersionsClient().NewListByLocationPager("westus2", &armappnetwork.AvailableVersionsClientListByLocationOptions{ + KubernetesVersion: to.Ptr("1.28")}) + 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 = armappnetwork.AvailableVersionsClientListByLocationResponse{ + // AvailableVersionListResult: armappnetwork.AvailableVersionListResult{ + // Value: []*armappnetwork.AvailableVersion{ + // { + // Properties: &armappnetwork.AvailableVersionProperties{ + // KubernetesVersion: to.Ptr("1.28"), + // FullyManagedVersions: &armappnetwork.FullyManagedVersions{ + // ReleaseChannels: []*armappnetwork.ReleaseChannelInfo{ + // { + // ReleaseChannel: to.Ptr("stable"), + // Version: to.Ptr("1.18.2"), + // }, + // { + // ReleaseChannel: to.Ptr("rapid"), + // Version: to.Ptr("1.19.1"), + // }, + // }, + // }, + // SelfManagedVersions: &armappnetwork.SelfManagedVersions{ + // Versions: []*armappnetwork.VersionInfo{ + // { + // Version: to.Ptr("1.18.2"), + // Upgrades: []*string{ + // to.Ptr("1.18.5"), + // to.Ptr("1.19.1"), + // }, + // }, + // }, + // }, + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/providers/Microsoft.AppLink/locations/westus2/availableVersions/kubernetes-1.28"), + // Name: to.Ptr("kubernetes-1.28"), + // Type: to.Ptr("Microsoft.AppLink/locations/availableVersions"), + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("system"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeApplication), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // LastModifiedBy: to.Ptr("system"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeApplication), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-05-19T00:28:48.610Z"); return t}()), + // }, + // }, + // }, + // }, + // } + } +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/ci.yml b/sdk/resourcemanager/appnetwork/armappnetwork/ci.yml new file mode 100644 index 000000000000..0ed10e252e6d --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/ci.yml @@ -0,0 +1,27 @@ +# NOTE: Please refer to https://aka.ms/azsdk/engsys/ci-yaml before editing this file. +trigger: + branches: + include: + - main + - feature/* + - hotfix/* + - release/* + paths: + include: + - sdk/resourcemanager/appnetwork/armappnetwork/ + +pr: + branches: + include: + - main + - feature/* + - hotfix/* + - release/* + paths: + include: + - sdk/resourcemanager/appnetwork/armappnetwork/ + +extends: + template: /eng/pipelines/templates/jobs/archetype-sdk-client.yml + parameters: + ServiceDirectory: 'resourcemanager/appnetwork/armappnetwork' diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/client_factory.go b/sdk/resourcemanager/appnetwork/armappnetwork/client_factory.go new file mode 100644 index 000000000000..3d977c952e7f --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/client_factory.go @@ -0,0 +1,72 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork + +import ( + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" +) + +// ClientFactory is a client factory used to create any client in this module. +// Don't use this type directly, use NewClientFactory instead. +type ClientFactory struct { + subscriptionID string + internal *arm.Client +} + +// 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 - The ID of the target subscription. The value must be an UUID. +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - pass nil to accept the default values. +func NewClientFactory(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error) { + internal, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + return &ClientFactory{ + subscriptionID: subscriptionID, + internal: internal, + }, nil +} + +// NewAppLinkMembersClient creates a new instance of AppLinkMembersClient. +func (c *ClientFactory) NewAppLinkMembersClient() *AppLinkMembersClient { + return &AppLinkMembersClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } +} + +// NewAppLinksClient creates a new instance of AppLinksClient. +func (c *ClientFactory) NewAppLinksClient() *AppLinksClient { + return &AppLinksClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } +} + +// NewAvailableVersionsClient creates a new instance of AvailableVersionsClient. +func (c *ClientFactory) NewAvailableVersionsClient() *AvailableVersionsClient { + return &AvailableVersionsClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } +} + +// NewOperationsClient creates a new instance of OperationsClient. +func (c *ClientFactory) NewOperationsClient() *OperationsClient { + return &OperationsClient{ + internal: c.internal, + } +} + +// NewUpgradeHistoriesClient creates a new instance of UpgradeHistoriesClient. +func (c *ClientFactory) NewUpgradeHistoriesClient() *UpgradeHistoriesClient { + return &UpgradeHistoriesClient{ + subscriptionID: c.subscriptionID, + internal: c.internal, + } +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/constants.go b/sdk/resourcemanager/appnetwork/armappnetwork/constants.go new file mode 100644 index 000000000000..13259c4d9f33 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/constants.go @@ -0,0 +1,192 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork + +// ActionType - Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. +type ActionType string + +const ( + // ActionTypeInternal - Actions are for internal-only APIs. + ActionTypeInternal ActionType = "Internal" +) + +// PossibleActionTypeValues returns the possible values for the ActionType const type. +func PossibleActionTypeValues() []ActionType { + return []ActionType{ + ActionTypeInternal, + } +} + +// ClusterType - AppLinkMember cluster type +type ClusterType string + +const ( + // ClusterTypeAKS - Azure Kubernetes Service + ClusterTypeAKS ClusterType = "AKS" +) + +// PossibleClusterTypeValues returns the possible values for the ClusterType const type. +func PossibleClusterTypeValues() []ClusterType { + return []ClusterType{ + ClusterTypeAKS, + } +} + +// CreatedByType - The kind of entity that created the resource. +type CreatedByType string + +const ( + // CreatedByTypeApplication - The entity was created by an application. + CreatedByTypeApplication CreatedByType = "Application" + // CreatedByTypeKey - The entity was created by a key. + CreatedByTypeKey CreatedByType = "Key" + // CreatedByTypeManagedIdentity - The entity was created by a managed identity. + CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity" + // CreatedByTypeUser - The entity was created by a user. + CreatedByTypeUser CreatedByType = "User" +) + +// PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type. +func PossibleCreatedByTypeValues() []CreatedByType { + return []CreatedByType{ + CreatedByTypeApplication, + CreatedByTypeKey, + CreatedByTypeManagedIdentity, + CreatedByTypeUser, + } +} + +// EastWestGatewayVisibility - East-West gateway visibility. +type EastWestGatewayVisibility string + +const ( + // EastWestGatewayVisibilityExternal - Use an external load balancer for the east-west gateway. + EastWestGatewayVisibilityExternal EastWestGatewayVisibility = "External" + // EastWestGatewayVisibilityInternal - Use an internal load balancer for the east-west gateway. + EastWestGatewayVisibilityInternal EastWestGatewayVisibility = "Internal" +) + +// PossibleEastWestGatewayVisibilityValues returns the possible values for the EastWestGatewayVisibility const type. +func PossibleEastWestGatewayVisibilityValues() []EastWestGatewayVisibility { + return []EastWestGatewayVisibility{ + EastWestGatewayVisibilityExternal, + EastWestGatewayVisibilityInternal, + } +} + +// ManagedServiceIdentityType - Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). +type ManagedServiceIdentityType string + +const ( + // ManagedServiceIdentityTypeNone - No managed identity. + ManagedServiceIdentityTypeNone ManagedServiceIdentityType = "None" + // ManagedServiceIdentityTypeSystemAssigned - System assigned managed identity. + ManagedServiceIdentityTypeSystemAssigned ManagedServiceIdentityType = "SystemAssigned" + // ManagedServiceIdentityTypeSystemAssignedUserAssigned - System and user assigned managed identity. + ManagedServiceIdentityTypeSystemAssignedUserAssigned ManagedServiceIdentityType = "SystemAssigned,UserAssigned" + // ManagedServiceIdentityTypeUserAssigned - User assigned managed identity. + ManagedServiceIdentityTypeUserAssigned ManagedServiceIdentityType = "UserAssigned" +) + +// PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type. +func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType { + return []ManagedServiceIdentityType{ + ManagedServiceIdentityTypeNone, + ManagedServiceIdentityTypeSystemAssigned, + ManagedServiceIdentityTypeSystemAssignedUserAssigned, + ManagedServiceIdentityTypeUserAssigned, + } +} + +// Origin - The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default +// value is "user,system" +type Origin string + +const ( + // OriginSystem - Indicates the operation is initiated by a system. + OriginSystem Origin = "system" + // OriginUser - Indicates the operation is initiated by a user. + OriginUser Origin = "user" + // OriginUserSystem - Indicates the operation is initiated by a user or system. + OriginUserSystem Origin = "user,system" +) + +// PossibleOriginValues returns the possible values for the Origin const type. +func PossibleOriginValues() []Origin { + return []Origin{ + OriginSystem, + OriginUser, + OriginUserSystem, + } +} + +// ProvisioningState - Provisioning state of the resource +type ProvisioningState string + +const ( + // ProvisioningStateAccepted - Resource has been Accepted. + ProvisioningStateAccepted ProvisioningState = "Accepted" + // ProvisioningStateCanceled - Resource creation was canceled. + ProvisioningStateCanceled ProvisioningState = "Canceled" + // ProvisioningStateDeleting - Resource is Deleting. + ProvisioningStateDeleting ProvisioningState = "Deleting" + // ProvisioningStateFailed - Resource creation failed. + ProvisioningStateFailed ProvisioningState = "Failed" + // ProvisioningStateProvisioning - Resource is getting provisioned. + ProvisioningStateProvisioning ProvisioningState = "Provisioning" + // ProvisioningStateSucceeded - Resource has been created. + ProvisioningStateSucceeded ProvisioningState = "Succeeded" + // ProvisioningStateUpdating - Resource is Updating. + ProvisioningStateUpdating ProvisioningState = "Updating" +) + +// PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type. +func PossibleProvisioningStateValues() []ProvisioningState { + return []ProvisioningState{ + ProvisioningStateAccepted, + ProvisioningStateCanceled, + ProvisioningStateDeleting, + ProvisioningStateFailed, + ProvisioningStateProvisioning, + ProvisioningStateSucceeded, + ProvisioningStateUpdating, + } +} + +// UpgradeMode - AppLinkMember upgrade mode +type UpgradeMode string + +const ( + // UpgradeModeFullyManaged - Fully managed upgrade mode + UpgradeModeFullyManaged UpgradeMode = "FullyManaged" + // UpgradeModeSelfManaged - Self managed upgrade mode + UpgradeModeSelfManaged UpgradeMode = "SelfManaged" +) + +// PossibleUpgradeModeValues returns the possible values for the UpgradeMode const type. +func PossibleUpgradeModeValues() []UpgradeMode { + return []UpgradeMode{ + UpgradeModeFullyManaged, + UpgradeModeSelfManaged, + } +} + +// UpgradeReleaseChannel - AppLinkMember upgrade release channel +type UpgradeReleaseChannel string + +const ( + // UpgradeReleaseChannelRapid - Rapid release channel + UpgradeReleaseChannelRapid UpgradeReleaseChannel = "Rapid" + // UpgradeReleaseChannelStable - Stable release channel + UpgradeReleaseChannelStable UpgradeReleaseChannel = "Stable" +) + +// PossibleUpgradeReleaseChannelValues returns the possible values for the UpgradeReleaseChannel const type. +func PossibleUpgradeReleaseChannelValues() []UpgradeReleaseChannel { + return []UpgradeReleaseChannel{ + UpgradeReleaseChannelRapid, + UpgradeReleaseChannelStable, + } +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/fake/applinkmembers_server.go b/sdk/resourcemanager/appnetwork/armappnetwork/fake/applinkmembers_server.go new file mode 100644 index 000000000000..3ed61f9e2eb6 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/fake/applinkmembers_server.go @@ -0,0 +1,353 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package fake + +import ( + "context" + "errors" + "fmt" + azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appnetwork/armappnetwork" + "net/http" + "net/url" + "regexp" +) + +// AppLinkMembersServer is a fake server for instances of the armappnetwork.AppLinkMembersClient type. +type AppLinkMembersServer struct { + // BeginCreateOrUpdate is the fake for method AppLinkMembersClient.BeginCreateOrUpdate + // HTTP status codes to indicate success: http.StatusOK, http.StatusCreated + BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, resource armappnetwork.AppLinkMember, options *armappnetwork.AppLinkMembersClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armappnetwork.AppLinkMembersClientCreateOrUpdateResponse], errResp azfake.ErrorResponder) + + // BeginDelete is the fake for method AppLinkMembersClient.BeginDelete + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent + BeginDelete func(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, options *armappnetwork.AppLinkMembersClientBeginDeleteOptions) (resp azfake.PollerResponder[armappnetwork.AppLinkMembersClientDeleteResponse], errResp azfake.ErrorResponder) + + // Get is the fake for method AppLinkMembersClient.Get + // HTTP status codes to indicate success: http.StatusOK + Get func(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, options *armappnetwork.AppLinkMembersClientGetOptions) (resp azfake.Responder[armappnetwork.AppLinkMembersClientGetResponse], errResp azfake.ErrorResponder) + + // NewListByAppLinkPager is the fake for method AppLinkMembersClient.NewListByAppLinkPager + // HTTP status codes to indicate success: http.StatusOK + NewListByAppLinkPager func(resourceGroupName string, appLinkName string, options *armappnetwork.AppLinkMembersClientListByAppLinkOptions) (resp azfake.PagerResponder[armappnetwork.AppLinkMembersClientListByAppLinkResponse]) + + // BeginUpdate is the fake for method AppLinkMembersClient.BeginUpdate + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted + BeginUpdate func(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, properties armappnetwork.AppLinkMemberUpdate, options *armappnetwork.AppLinkMembersClientBeginUpdateOptions) (resp azfake.PollerResponder[armappnetwork.AppLinkMembersClientUpdateResponse], errResp azfake.ErrorResponder) +} + +// NewAppLinkMembersServerTransport creates a new instance of AppLinkMembersServerTransport with the provided implementation. +// The returned AppLinkMembersServerTransport instance is connected to an instance of armappnetwork.AppLinkMembersClient via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewAppLinkMembersServerTransport(srv *AppLinkMembersServer) *AppLinkMembersServerTransport { + return &AppLinkMembersServerTransport{ + srv: srv, + beginCreateOrUpdate: newTracker[azfake.PollerResponder[armappnetwork.AppLinkMembersClientCreateOrUpdateResponse]](), + beginDelete: newTracker[azfake.PollerResponder[armappnetwork.AppLinkMembersClientDeleteResponse]](), + newListByAppLinkPager: newTracker[azfake.PagerResponder[armappnetwork.AppLinkMembersClientListByAppLinkResponse]](), + beginUpdate: newTracker[azfake.PollerResponder[armappnetwork.AppLinkMembersClientUpdateResponse]](), + } +} + +// AppLinkMembersServerTransport connects instances of armappnetwork.AppLinkMembersClient to instances of AppLinkMembersServer. +// Don't use this type directly, use NewAppLinkMembersServerTransport instead. +type AppLinkMembersServerTransport struct { + srv *AppLinkMembersServer + beginCreateOrUpdate *tracker[azfake.PollerResponder[armappnetwork.AppLinkMembersClientCreateOrUpdateResponse]] + beginDelete *tracker[azfake.PollerResponder[armappnetwork.AppLinkMembersClientDeleteResponse]] + newListByAppLinkPager *tracker[azfake.PagerResponder[armappnetwork.AppLinkMembersClientListByAppLinkResponse]] + beginUpdate *tracker[azfake.PollerResponder[armappnetwork.AppLinkMembersClientUpdateResponse]] +} + +// Do implements the policy.Transporter interface for AppLinkMembersServerTransport. +func (a *AppLinkMembersServerTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + return a.dispatchToMethodFake(req, method) +} + +func (a *AppLinkMembersServerTransport) dispatchToMethodFake(req *http.Request, method string) (*http.Response, error) { + resultChan := make(chan result) + defer close(resultChan) + + go func() { + var intercepted bool + var res result + if appLinkMembersServerTransportInterceptor != nil { + res.resp, res.err, intercepted = appLinkMembersServerTransportInterceptor.Do(req) + } + if !intercepted { + switch method { + case "AppLinkMembersClient.BeginCreateOrUpdate": + res.resp, res.err = a.dispatchBeginCreateOrUpdate(req) + case "AppLinkMembersClient.BeginDelete": + res.resp, res.err = a.dispatchBeginDelete(req) + case "AppLinkMembersClient.Get": + res.resp, res.err = a.dispatchGet(req) + case "AppLinkMembersClient.NewListByAppLinkPager": + res.resp, res.err = a.dispatchNewListByAppLinkPager(req) + case "AppLinkMembersClient.BeginUpdate": + res.resp, res.err = a.dispatchBeginUpdate(req) + default: + res.err = fmt.Errorf("unhandled API %s", method) + } + + } + select { + case resultChan <- res: + case <-req.Context().Done(): + } + }() + + select { + case <-req.Context().Done(): + return nil, req.Context().Err() + case res := <-resultChan: + return res.resp, res.err + } +} + +func (a *AppLinkMembersServerTransport) dispatchBeginCreateOrUpdate(req *http.Request) (*http.Response, error) { + if a.srv.BeginCreateOrUpdate == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginCreateOrUpdate not implemented")} + } + beginCreateOrUpdate := a.beginCreateOrUpdate.get(req) + if beginCreateOrUpdate == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AppLink/appLinks/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/appLinkMembers/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 5 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armappnetwork.AppLinkMember](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + appLinkNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkName")]) + if err != nil { + return nil, err + } + appLinkMemberNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkMemberName")]) + if err != nil { + return nil, err + } + respr, errRespr := a.srv.BeginCreateOrUpdate(req.Context(), resourceGroupNameParam, appLinkNameParam, appLinkMemberNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginCreateOrUpdate = &respr + a.beginCreateOrUpdate.add(req, beginCreateOrUpdate) + } + + resp, err := server.PollerResponderNext(beginCreateOrUpdate, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusCreated}, resp.StatusCode) { + a.beginCreateOrUpdate.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusCreated", resp.StatusCode)} + } + if !server.PollerResponderMore(beginCreateOrUpdate) { + a.beginCreateOrUpdate.remove(req) + } + + return resp, nil +} + +func (a *AppLinkMembersServerTransport) dispatchBeginDelete(req *http.Request) (*http.Response, error) { + if a.srv.BeginDelete == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginDelete not implemented")} + } + beginDelete := a.beginDelete.get(req) + if beginDelete == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AppLink/appLinks/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/appLinkMembers/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 5 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + appLinkNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkName")]) + if err != nil { + return nil, err + } + appLinkMemberNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkMemberName")]) + if err != nil { + return nil, err + } + respr, errRespr := a.srv.BeginDelete(req.Context(), resourceGroupNameParam, appLinkNameParam, appLinkMemberNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginDelete = &respr + a.beginDelete.add(req, beginDelete) + } + + resp, err := server.PollerResponderNext(beginDelete, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted, http.StatusNoContent}, resp.StatusCode) { + a.beginDelete.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted, http.StatusNoContent", resp.StatusCode)} + } + if !server.PollerResponderMore(beginDelete) { + a.beginDelete.remove(req) + } + + return resp, nil +} + +func (a *AppLinkMembersServerTransport) dispatchGet(req *http.Request) (*http.Response, error) { + if a.srv.Get == nil { + return nil, &nonRetriableError{errors.New("fake for method Get not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AppLink/appLinks/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/appLinkMembers/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 5 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + appLinkNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkName")]) + if err != nil { + return nil, err + } + appLinkMemberNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkMemberName")]) + if err != nil { + return nil, err + } + respr, errRespr := a.srv.Get(req.Context(), resourceGroupNameParam, appLinkNameParam, appLinkMemberNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).AppLinkMember, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (a *AppLinkMembersServerTransport) dispatchNewListByAppLinkPager(req *http.Request) (*http.Response, error) { + if a.srv.NewListByAppLinkPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListByAppLinkPager not implemented")} + } + newListByAppLinkPager := a.newListByAppLinkPager.get(req) + if newListByAppLinkPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AppLink/appLinks/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/appLinkMembers` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + appLinkNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkName")]) + if err != nil { + return nil, err + } + resp := a.srv.NewListByAppLinkPager(resourceGroupNameParam, appLinkNameParam, nil) + newListByAppLinkPager = &resp + a.newListByAppLinkPager.add(req, newListByAppLinkPager) + server.PagerResponderInjectNextLinks(newListByAppLinkPager, req, func(page *armappnetwork.AppLinkMembersClientListByAppLinkResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListByAppLinkPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + a.newListByAppLinkPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListByAppLinkPager) { + a.newListByAppLinkPager.remove(req) + } + return resp, nil +} + +func (a *AppLinkMembersServerTransport) dispatchBeginUpdate(req *http.Request) (*http.Response, error) { + if a.srv.BeginUpdate == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginUpdate not implemented")} + } + beginUpdate := a.beginUpdate.get(req) + if beginUpdate == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AppLink/appLinks/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/appLinkMembers/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 5 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armappnetwork.AppLinkMemberUpdate](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + appLinkNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkName")]) + if err != nil { + return nil, err + } + appLinkMemberNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkMemberName")]) + if err != nil { + return nil, err + } + respr, errRespr := a.srv.BeginUpdate(req.Context(), resourceGroupNameParam, appLinkNameParam, appLinkMemberNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginUpdate = &respr + a.beginUpdate.add(req, beginUpdate) + } + + resp, err := server.PollerResponderNext(beginUpdate, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted}, resp.StatusCode) { + a.beginUpdate.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted", resp.StatusCode)} + } + if !server.PollerResponderMore(beginUpdate) { + a.beginUpdate.remove(req) + } + + return resp, nil +} + +// set this to conditionally intercept incoming requests to AppLinkMembersServerTransport +var appLinkMembersServerTransportInterceptor interface { + // Do returns true if the server transport should use the returned response/error + Do(*http.Request) (*http.Response, error, bool) +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/fake/applinks_server.go b/sdk/resourcemanager/appnetwork/armappnetwork/fake/applinks_server.go new file mode 100644 index 000000000000..ad9122a5e427 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/fake/applinks_server.go @@ -0,0 +1,374 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package fake + +import ( + "context" + "errors" + "fmt" + azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appnetwork/armappnetwork" + "net/http" + "net/url" + "regexp" +) + +// AppLinksServer is a fake server for instances of the armappnetwork.AppLinksClient type. +type AppLinksServer struct { + // BeginCreateOrUpdate is the fake for method AppLinksClient.BeginCreateOrUpdate + // HTTP status codes to indicate success: http.StatusOK, http.StatusCreated + BeginCreateOrUpdate func(ctx context.Context, resourceGroupName string, appLinkName string, resource armappnetwork.AppLink, options *armappnetwork.AppLinksClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armappnetwork.AppLinksClientCreateOrUpdateResponse], errResp azfake.ErrorResponder) + + // BeginDelete is the fake for method AppLinksClient.BeginDelete + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted, http.StatusNoContent + BeginDelete func(ctx context.Context, resourceGroupName string, appLinkName string, options *armappnetwork.AppLinksClientBeginDeleteOptions) (resp azfake.PollerResponder[armappnetwork.AppLinksClientDeleteResponse], errResp azfake.ErrorResponder) + + // Get is the fake for method AppLinksClient.Get + // HTTP status codes to indicate success: http.StatusOK + Get func(ctx context.Context, resourceGroupName string, appLinkName string, options *armappnetwork.AppLinksClientGetOptions) (resp azfake.Responder[armappnetwork.AppLinksClientGetResponse], errResp azfake.ErrorResponder) + + // NewListByResourceGroupPager is the fake for method AppLinksClient.NewListByResourceGroupPager + // HTTP status codes to indicate success: http.StatusOK + NewListByResourceGroupPager func(resourceGroupName string, options *armappnetwork.AppLinksClientListByResourceGroupOptions) (resp azfake.PagerResponder[armappnetwork.AppLinksClientListByResourceGroupResponse]) + + // NewListBySubscriptionPager is the fake for method AppLinksClient.NewListBySubscriptionPager + // HTTP status codes to indicate success: http.StatusOK + NewListBySubscriptionPager func(options *armappnetwork.AppLinksClientListBySubscriptionOptions) (resp azfake.PagerResponder[armappnetwork.AppLinksClientListBySubscriptionResponse]) + + // BeginUpdate is the fake for method AppLinksClient.BeginUpdate + // HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted + BeginUpdate func(ctx context.Context, resourceGroupName string, appLinkName string, properties armappnetwork.AppLinkUpdate, options *armappnetwork.AppLinksClientBeginUpdateOptions) (resp azfake.PollerResponder[armappnetwork.AppLinksClientUpdateResponse], errResp azfake.ErrorResponder) +} + +// NewAppLinksServerTransport creates a new instance of AppLinksServerTransport with the provided implementation. +// The returned AppLinksServerTransport instance is connected to an instance of armappnetwork.AppLinksClient via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewAppLinksServerTransport(srv *AppLinksServer) *AppLinksServerTransport { + return &AppLinksServerTransport{ + srv: srv, + beginCreateOrUpdate: newTracker[azfake.PollerResponder[armappnetwork.AppLinksClientCreateOrUpdateResponse]](), + beginDelete: newTracker[azfake.PollerResponder[armappnetwork.AppLinksClientDeleteResponse]](), + newListByResourceGroupPager: newTracker[azfake.PagerResponder[armappnetwork.AppLinksClientListByResourceGroupResponse]](), + newListBySubscriptionPager: newTracker[azfake.PagerResponder[armappnetwork.AppLinksClientListBySubscriptionResponse]](), + beginUpdate: newTracker[azfake.PollerResponder[armappnetwork.AppLinksClientUpdateResponse]](), + } +} + +// AppLinksServerTransport connects instances of armappnetwork.AppLinksClient to instances of AppLinksServer. +// Don't use this type directly, use NewAppLinksServerTransport instead. +type AppLinksServerTransport struct { + srv *AppLinksServer + beginCreateOrUpdate *tracker[azfake.PollerResponder[armappnetwork.AppLinksClientCreateOrUpdateResponse]] + beginDelete *tracker[azfake.PollerResponder[armappnetwork.AppLinksClientDeleteResponse]] + newListByResourceGroupPager *tracker[azfake.PagerResponder[armappnetwork.AppLinksClientListByResourceGroupResponse]] + newListBySubscriptionPager *tracker[azfake.PagerResponder[armappnetwork.AppLinksClientListBySubscriptionResponse]] + beginUpdate *tracker[azfake.PollerResponder[armappnetwork.AppLinksClientUpdateResponse]] +} + +// Do implements the policy.Transporter interface for AppLinksServerTransport. +func (a *AppLinksServerTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + return a.dispatchToMethodFake(req, method) +} + +func (a *AppLinksServerTransport) dispatchToMethodFake(req *http.Request, method string) (*http.Response, error) { + resultChan := make(chan result) + defer close(resultChan) + + go func() { + var intercepted bool + var res result + if appLinksServerTransportInterceptor != nil { + res.resp, res.err, intercepted = appLinksServerTransportInterceptor.Do(req) + } + if !intercepted { + switch method { + case "AppLinksClient.BeginCreateOrUpdate": + res.resp, res.err = a.dispatchBeginCreateOrUpdate(req) + case "AppLinksClient.BeginDelete": + res.resp, res.err = a.dispatchBeginDelete(req) + case "AppLinksClient.Get": + res.resp, res.err = a.dispatchGet(req) + case "AppLinksClient.NewListByResourceGroupPager": + res.resp, res.err = a.dispatchNewListByResourceGroupPager(req) + case "AppLinksClient.NewListBySubscriptionPager": + res.resp, res.err = a.dispatchNewListBySubscriptionPager(req) + case "AppLinksClient.BeginUpdate": + res.resp, res.err = a.dispatchBeginUpdate(req) + default: + res.err = fmt.Errorf("unhandled API %s", method) + } + + } + select { + case resultChan <- res: + case <-req.Context().Done(): + } + }() + + select { + case <-req.Context().Done(): + return nil, req.Context().Err() + case res := <-resultChan: + return res.resp, res.err + } +} + +func (a *AppLinksServerTransport) dispatchBeginCreateOrUpdate(req *http.Request) (*http.Response, error) { + if a.srv.BeginCreateOrUpdate == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginCreateOrUpdate not implemented")} + } + beginCreateOrUpdate := a.beginCreateOrUpdate.get(req) + if beginCreateOrUpdate == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AppLink/appLinks/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armappnetwork.AppLink](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + appLinkNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkName")]) + if err != nil { + return nil, err + } + respr, errRespr := a.srv.BeginCreateOrUpdate(req.Context(), resourceGroupNameParam, appLinkNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginCreateOrUpdate = &respr + a.beginCreateOrUpdate.add(req, beginCreateOrUpdate) + } + + resp, err := server.PollerResponderNext(beginCreateOrUpdate, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusCreated}, resp.StatusCode) { + a.beginCreateOrUpdate.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusCreated", resp.StatusCode)} + } + if !server.PollerResponderMore(beginCreateOrUpdate) { + a.beginCreateOrUpdate.remove(req) + } + + return resp, nil +} + +func (a *AppLinksServerTransport) dispatchBeginDelete(req *http.Request) (*http.Response, error) { + if a.srv.BeginDelete == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginDelete not implemented")} + } + beginDelete := a.beginDelete.get(req) + if beginDelete == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AppLink/appLinks/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + appLinkNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkName")]) + if err != nil { + return nil, err + } + respr, errRespr := a.srv.BeginDelete(req.Context(), resourceGroupNameParam, appLinkNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginDelete = &respr + a.beginDelete.add(req, beginDelete) + } + + resp, err := server.PollerResponderNext(beginDelete, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted, http.StatusNoContent}, resp.StatusCode) { + a.beginDelete.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted, http.StatusNoContent", resp.StatusCode)} + } + if !server.PollerResponderMore(beginDelete) { + a.beginDelete.remove(req) + } + + return resp, nil +} + +func (a *AppLinksServerTransport) dispatchGet(req *http.Request) (*http.Response, error) { + if a.srv.Get == nil { + return nil, &nonRetriableError{errors.New("fake for method Get not implemented")} + } + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AppLink/appLinks/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + appLinkNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkName")]) + if err != nil { + return nil, err + } + respr, errRespr := a.srv.Get(req.Context(), resourceGroupNameParam, appLinkNameParam, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + respContent := server.GetResponseContent(respr) + if !contains([]int{http.StatusOK}, respContent.HTTPStatus) { + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", respContent.HTTPStatus)} + } + resp, err := server.MarshalResponseAsJSON(respContent, server.GetResponse(respr).AppLink, req) + if err != nil { + return nil, err + } + return resp, nil +} + +func (a *AppLinksServerTransport) dispatchNewListByResourceGroupPager(req *http.Request) (*http.Response, error) { + if a.srv.NewListByResourceGroupPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListByResourceGroupPager not implemented")} + } + newListByResourceGroupPager := a.newListByResourceGroupPager.get(req) + if newListByResourceGroupPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AppLink/appLinks` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + resp := a.srv.NewListByResourceGroupPager(resourceGroupNameParam, nil) + newListByResourceGroupPager = &resp + a.newListByResourceGroupPager.add(req, newListByResourceGroupPager) + server.PagerResponderInjectNextLinks(newListByResourceGroupPager, req, func(page *armappnetwork.AppLinksClientListByResourceGroupResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListByResourceGroupPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + a.newListByResourceGroupPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListByResourceGroupPager) { + a.newListByResourceGroupPager.remove(req) + } + return resp, nil +} + +func (a *AppLinksServerTransport) dispatchNewListBySubscriptionPager(req *http.Request) (*http.Response, error) { + if a.srv.NewListBySubscriptionPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListBySubscriptionPager not implemented")} + } + newListBySubscriptionPager := a.newListBySubscriptionPager.get(req) + if newListBySubscriptionPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AppLink/appLinks` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 2 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resp := a.srv.NewListBySubscriptionPager(nil) + newListBySubscriptionPager = &resp + a.newListBySubscriptionPager.add(req, newListBySubscriptionPager) + server.PagerResponderInjectNextLinks(newListBySubscriptionPager, req, func(page *armappnetwork.AppLinksClientListBySubscriptionResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListBySubscriptionPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + a.newListBySubscriptionPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListBySubscriptionPager) { + a.newListBySubscriptionPager.remove(req) + } + return resp, nil +} + +func (a *AppLinksServerTransport) dispatchBeginUpdate(req *http.Request) (*http.Response, error) { + if a.srv.BeginUpdate == nil { + return nil, &nonRetriableError{errors.New("fake for method BeginUpdate not implemented")} + } + beginUpdate := a.beginUpdate.get(req) + if beginUpdate == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AppLink/appLinks/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 4 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + body, err := server.UnmarshalRequestAsJSON[armappnetwork.AppLinkUpdate](req) + if err != nil { + return nil, err + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + appLinkNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkName")]) + if err != nil { + return nil, err + } + respr, errRespr := a.srv.BeginUpdate(req.Context(), resourceGroupNameParam, appLinkNameParam, body, nil) + if respErr := server.GetError(errRespr, req); respErr != nil { + return nil, respErr + } + beginUpdate = &respr + a.beginUpdate.add(req, beginUpdate) + } + + resp, err := server.PollerResponderNext(beginUpdate, req) + if err != nil { + return nil, err + } + + if !contains([]int{http.StatusOK, http.StatusAccepted}, resp.StatusCode) { + a.beginUpdate.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK, http.StatusAccepted", resp.StatusCode)} + } + if !server.PollerResponderMore(beginUpdate) { + a.beginUpdate.remove(req) + } + + return resp, nil +} + +// set this to conditionally intercept incoming requests to AppLinksServerTransport +var appLinksServerTransportInterceptor interface { + // Do returns true if the server transport should use the returned response/error + Do(*http.Request) (*http.Response, error, bool) +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/fake/availableversions_server.go b/sdk/resourcemanager/appnetwork/armappnetwork/fake/availableversions_server.go new file mode 100644 index 000000000000..11500bab6634 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/fake/availableversions_server.go @@ -0,0 +1,141 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package fake + +import ( + "errors" + "fmt" + azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appnetwork/armappnetwork" + "net/http" + "net/url" + "regexp" +) + +// AvailableVersionsServer is a fake server for instances of the armappnetwork.AvailableVersionsClient type. +type AvailableVersionsServer struct { + // NewListByLocationPager is the fake for method AvailableVersionsClient.NewListByLocationPager + // HTTP status codes to indicate success: http.StatusOK + NewListByLocationPager func(location string, options *armappnetwork.AvailableVersionsClientListByLocationOptions) (resp azfake.PagerResponder[armappnetwork.AvailableVersionsClientListByLocationResponse]) +} + +// NewAvailableVersionsServerTransport creates a new instance of AvailableVersionsServerTransport with the provided implementation. +// The returned AvailableVersionsServerTransport instance is connected to an instance of armappnetwork.AvailableVersionsClient via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewAvailableVersionsServerTransport(srv *AvailableVersionsServer) *AvailableVersionsServerTransport { + return &AvailableVersionsServerTransport{ + srv: srv, + newListByLocationPager: newTracker[azfake.PagerResponder[armappnetwork.AvailableVersionsClientListByLocationResponse]](), + } +} + +// AvailableVersionsServerTransport connects instances of armappnetwork.AvailableVersionsClient to instances of AvailableVersionsServer. +// Don't use this type directly, use NewAvailableVersionsServerTransport instead. +type AvailableVersionsServerTransport struct { + srv *AvailableVersionsServer + newListByLocationPager *tracker[azfake.PagerResponder[armappnetwork.AvailableVersionsClientListByLocationResponse]] +} + +// Do implements the policy.Transporter interface for AvailableVersionsServerTransport. +func (a *AvailableVersionsServerTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + return a.dispatchToMethodFake(req, method) +} + +func (a *AvailableVersionsServerTransport) dispatchToMethodFake(req *http.Request, method string) (*http.Response, error) { + resultChan := make(chan result) + defer close(resultChan) + + go func() { + var intercepted bool + var res result + if availableVersionsServerTransportInterceptor != nil { + res.resp, res.err, intercepted = availableVersionsServerTransportInterceptor.Do(req) + } + if !intercepted { + switch method { + case "AvailableVersionsClient.NewListByLocationPager": + res.resp, res.err = a.dispatchNewListByLocationPager(req) + default: + res.err = fmt.Errorf("unhandled API %s", method) + } + + } + select { + case resultChan <- res: + case <-req.Context().Done(): + } + }() + + select { + case <-req.Context().Done(): + return nil, req.Context().Err() + case res := <-resultChan: + return res.resp, res.err + } +} + +func (a *AvailableVersionsServerTransport) dispatchNewListByLocationPager(req *http.Request) (*http.Response, error) { + if a.srv.NewListByLocationPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListByLocationPager not implemented")} + } + newListByLocationPager := a.newListByLocationPager.get(req) + if newListByLocationPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AppLink/locations/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/availableVersions` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 3 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + qp := req.URL.Query() + locationParam, err := url.PathUnescape(matches[regex.SubexpIndex("location")]) + if err != nil { + return nil, err + } + kubernetesVersionUnescaped, err := url.QueryUnescape(qp.Get("kubernetesVersion")) + if err != nil { + return nil, err + } + kubernetesVersionParam := getOptional(kubernetesVersionUnescaped) + var options *armappnetwork.AvailableVersionsClientListByLocationOptions + if kubernetesVersionParam != nil { + options = &armappnetwork.AvailableVersionsClientListByLocationOptions{ + KubernetesVersion: kubernetesVersionParam, + } + } + resp := a.srv.NewListByLocationPager(locationParam, options) + newListByLocationPager = &resp + a.newListByLocationPager.add(req, newListByLocationPager) + server.PagerResponderInjectNextLinks(newListByLocationPager, req, func(page *armappnetwork.AvailableVersionsClientListByLocationResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListByLocationPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + a.newListByLocationPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListByLocationPager) { + a.newListByLocationPager.remove(req) + } + return resp, nil +} + +// set this to conditionally intercept incoming requests to AvailableVersionsServerTransport +var availableVersionsServerTransportInterceptor interface { + // Do returns true if the server transport should use the returned response/error + Do(*http.Request) (*http.Response, error, bool) +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/fake/internal.go b/sdk/resourcemanager/appnetwork/armappnetwork/fake/internal.go new file mode 100644 index 000000000000..df1504ed6a6a --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/fake/internal.go @@ -0,0 +1,81 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package fake + +import ( + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "net/http" + "reflect" + "sync" +) + +type result struct { + resp *http.Response + err error +} + +type nonRetriableError struct { + error +} + +func (nonRetriableError) NonRetriable() { + // marker method +} + +func contains[T comparable](s []T, v T) bool { + for _, vv := range s { + if vv == v { + return true + } + } + return false +} + +func getOptional[T any](v T) *T { + if reflect.ValueOf(v).IsZero() { + return nil + } + return &v +} + +func initServer[T any](mu *sync.Mutex, dst **T, src func() *T) { + mu.Lock() + if *dst == nil { + *dst = src() + } + mu.Unlock() +} + +func newTracker[T any]() *tracker[T] { + return &tracker[T]{ + items: map[string]*T{}, + } +} + +type tracker[T any] struct { + items map[string]*T + mu sync.Mutex +} + +func (p *tracker[T]) get(req *http.Request) *T { + p.mu.Lock() + defer p.mu.Unlock() + if item, ok := p.items[server.SanitizePagerPollerPath(req.URL.Path)]; ok { + return item + } + return nil +} + +func (p *tracker[T]) add(req *http.Request, item *T) { + p.mu.Lock() + defer p.mu.Unlock() + p.items[server.SanitizePagerPollerPath(req.URL.Path)] = item +} + +func (p *tracker[T]) remove(req *http.Request) { + p.mu.Lock() + defer p.mu.Unlock() + delete(p.items, server.SanitizePagerPollerPath(req.URL.Path)) +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/fake/operations_server.go b/sdk/resourcemanager/appnetwork/armappnetwork/fake/operations_server.go new file mode 100644 index 000000000000..8ac074356911 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/fake/operations_server.go @@ -0,0 +1,117 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package fake + +import ( + "errors" + "fmt" + azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appnetwork/armappnetwork" + "net/http" +) + +// OperationsServer is a fake server for instances of the armappnetwork.OperationsClient type. +type OperationsServer struct { + // NewListPager is the fake for method OperationsClient.NewListPager + // HTTP status codes to indicate success: http.StatusOK + NewListPager func(options *armappnetwork.OperationsClientListOptions) (resp azfake.PagerResponder[armappnetwork.OperationsClientListResponse]) +} + +// NewOperationsServerTransport creates a new instance of OperationsServerTransport with the provided implementation. +// The returned OperationsServerTransport instance is connected to an instance of armappnetwork.OperationsClient via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewOperationsServerTransport(srv *OperationsServer) *OperationsServerTransport { + return &OperationsServerTransport{ + srv: srv, + newListPager: newTracker[azfake.PagerResponder[armappnetwork.OperationsClientListResponse]](), + } +} + +// OperationsServerTransport connects instances of armappnetwork.OperationsClient to instances of OperationsServer. +// Don't use this type directly, use NewOperationsServerTransport instead. +type OperationsServerTransport struct { + srv *OperationsServer + newListPager *tracker[azfake.PagerResponder[armappnetwork.OperationsClientListResponse]] +} + +// Do implements the policy.Transporter interface for OperationsServerTransport. +func (o *OperationsServerTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + return o.dispatchToMethodFake(req, method) +} + +func (o *OperationsServerTransport) dispatchToMethodFake(req *http.Request, method string) (*http.Response, error) { + resultChan := make(chan result) + defer close(resultChan) + + go func() { + var intercepted bool + var res result + if operationsServerTransportInterceptor != nil { + res.resp, res.err, intercepted = operationsServerTransportInterceptor.Do(req) + } + if !intercepted { + switch method { + case "OperationsClient.NewListPager": + res.resp, res.err = o.dispatchNewListPager(req) + default: + res.err = fmt.Errorf("unhandled API %s", method) + } + + } + select { + case resultChan <- res: + case <-req.Context().Done(): + } + }() + + select { + case <-req.Context().Done(): + return nil, req.Context().Err() + case res := <-resultChan: + return res.resp, res.err + } +} + +func (o *OperationsServerTransport) dispatchNewListPager(req *http.Request) (*http.Response, error) { + if o.srv.NewListPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListPager not implemented")} + } + newListPager := o.newListPager.get(req) + if newListPager == nil { + resp := o.srv.NewListPager(nil) + newListPager = &resp + o.newListPager.add(req, newListPager) + server.PagerResponderInjectNextLinks(newListPager, req, func(page *armappnetwork.OperationsClientListResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + o.newListPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListPager) { + o.newListPager.remove(req) + } + return resp, nil +} + +// set this to conditionally intercept incoming requests to OperationsServerTransport +var operationsServerTransportInterceptor interface { + // Do returns true if the server transport should use the returned response/error + Do(*http.Request) (*http.Response, error, bool) +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/fake/server_factory.go b/sdk/resourcemanager/appnetwork/armappnetwork/fake/server_factory.go new file mode 100644 index 000000000000..2f2c94688417 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/fake/server_factory.go @@ -0,0 +1,98 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package fake + +import ( + "errors" + "fmt" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "strings" + "sync" +) + +// ServerFactory is a fake server for instances of the armappnetwork.ClientFactory type. +type ServerFactory struct { + // AppLinkMembersServer contains the fakes for client AppLinkMembersClient + AppLinkMembersServer AppLinkMembersServer + + // AppLinksServer contains the fakes for client AppLinksClient + AppLinksServer AppLinksServer + + // AvailableVersionsServer contains the fakes for client AvailableVersionsClient + AvailableVersionsServer AvailableVersionsServer + + // OperationsServer contains the fakes for client OperationsClient + OperationsServer OperationsServer + + // UpgradeHistoriesServer contains the fakes for client UpgradeHistoriesClient + UpgradeHistoriesServer UpgradeHistoriesServer +} + +// NewServerFactoryTransport creates a new instance of ServerFactoryTransport with the provided implementation. +// The returned ServerFactoryTransport instance is connected to an instance of armappnetwork.ClientFactory via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewServerFactoryTransport(srv *ServerFactory) *ServerFactoryTransport { + return &ServerFactoryTransport{ + srv: srv, + } +} + +// ServerFactoryTransport connects instances of armappnetwork.ClientFactory to instances of ServerFactory. +// Don't use this type directly, use NewServerFactoryTransport instead. +type ServerFactoryTransport struct { + srv *ServerFactory + trMu sync.Mutex + trAppLinkMembersServer *AppLinkMembersServerTransport + trAppLinksServer *AppLinksServerTransport + trAvailableVersionsServer *AvailableVersionsServerTransport + trOperationsServer *OperationsServerTransport + trUpgradeHistoriesServer *UpgradeHistoriesServerTransport +} + +// Do implements the policy.Transporter interface for ServerFactoryTransport. +func (s *ServerFactoryTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + client := method[:strings.Index(method, ".")] + var resp *http.Response + var err error + + switch client { + case "AppLinkMembersClient": + initServer(&s.trMu, &s.trAppLinkMembersServer, func() *AppLinkMembersServerTransport { + return NewAppLinkMembersServerTransport(&s.srv.AppLinkMembersServer) + }) + resp, err = s.trAppLinkMembersServer.Do(req) + case "AppLinksClient": + initServer(&s.trMu, &s.trAppLinksServer, func() *AppLinksServerTransport { return NewAppLinksServerTransport(&s.srv.AppLinksServer) }) + resp, err = s.trAppLinksServer.Do(req) + case "AvailableVersionsClient": + initServer(&s.trMu, &s.trAvailableVersionsServer, func() *AvailableVersionsServerTransport { + return NewAvailableVersionsServerTransport(&s.srv.AvailableVersionsServer) + }) + resp, err = s.trAvailableVersionsServer.Do(req) + case "OperationsClient": + initServer(&s.trMu, &s.trOperationsServer, func() *OperationsServerTransport { return NewOperationsServerTransport(&s.srv.OperationsServer) }) + resp, err = s.trOperationsServer.Do(req) + case "UpgradeHistoriesClient": + initServer(&s.trMu, &s.trUpgradeHistoriesServer, func() *UpgradeHistoriesServerTransport { + return NewUpgradeHistoriesServerTransport(&s.srv.UpgradeHistoriesServer) + }) + resp, err = s.trUpgradeHistoriesServer.Do(req) + default: + err = fmt.Errorf("unhandled client %s", client) + } + + if err != nil { + return nil, err + } + + return resp, nil +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/fake/upgradehistories_server.go b/sdk/resourcemanager/appnetwork/armappnetwork/fake/upgradehistories_server.go new file mode 100644 index 000000000000..ab9047e455b3 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/fake/upgradehistories_server.go @@ -0,0 +1,137 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package fake + +import ( + "errors" + "fmt" + azfake "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/to" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appnetwork/armappnetwork" + "net/http" + "net/url" + "regexp" +) + +// UpgradeHistoriesServer is a fake server for instances of the armappnetwork.UpgradeHistoriesClient type. +type UpgradeHistoriesServer struct { + // NewListByAppLinkMemberPager is the fake for method UpgradeHistoriesClient.NewListByAppLinkMemberPager + // HTTP status codes to indicate success: http.StatusOK + NewListByAppLinkMemberPager func(resourceGroupName string, appLinkName string, appLinkMemberName string, options *armappnetwork.UpgradeHistoriesClientListByAppLinkMemberOptions) (resp azfake.PagerResponder[armappnetwork.UpgradeHistoriesClientListByAppLinkMemberResponse]) +} + +// NewUpgradeHistoriesServerTransport creates a new instance of UpgradeHistoriesServerTransport with the provided implementation. +// The returned UpgradeHistoriesServerTransport instance is connected to an instance of armappnetwork.UpgradeHistoriesClient via the +// azcore.ClientOptions.Transporter field in the client's constructor parameters. +func NewUpgradeHistoriesServerTransport(srv *UpgradeHistoriesServer) *UpgradeHistoriesServerTransport { + return &UpgradeHistoriesServerTransport{ + srv: srv, + newListByAppLinkMemberPager: newTracker[azfake.PagerResponder[armappnetwork.UpgradeHistoriesClientListByAppLinkMemberResponse]](), + } +} + +// UpgradeHistoriesServerTransport connects instances of armappnetwork.UpgradeHistoriesClient to instances of UpgradeHistoriesServer. +// Don't use this type directly, use NewUpgradeHistoriesServerTransport instead. +type UpgradeHistoriesServerTransport struct { + srv *UpgradeHistoriesServer + newListByAppLinkMemberPager *tracker[azfake.PagerResponder[armappnetwork.UpgradeHistoriesClientListByAppLinkMemberResponse]] +} + +// Do implements the policy.Transporter interface for UpgradeHistoriesServerTransport. +func (u *UpgradeHistoriesServerTransport) Do(req *http.Request) (*http.Response, error) { + rawMethod := req.Context().Value(runtime.CtxAPINameKey{}) + method, ok := rawMethod.(string) + if !ok { + return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")} + } + + return u.dispatchToMethodFake(req, method) +} + +func (u *UpgradeHistoriesServerTransport) dispatchToMethodFake(req *http.Request, method string) (*http.Response, error) { + resultChan := make(chan result) + defer close(resultChan) + + go func() { + var intercepted bool + var res result + if upgradeHistoriesServerTransportInterceptor != nil { + res.resp, res.err, intercepted = upgradeHistoriesServerTransportInterceptor.Do(req) + } + if !intercepted { + switch method { + case "UpgradeHistoriesClient.NewListByAppLinkMemberPager": + res.resp, res.err = u.dispatchNewListByAppLinkMemberPager(req) + default: + res.err = fmt.Errorf("unhandled API %s", method) + } + + } + select { + case resultChan <- res: + case <-req.Context().Done(): + } + }() + + select { + case <-req.Context().Done(): + return nil, req.Context().Err() + case res := <-resultChan: + return res.resp, res.err + } +} + +func (u *UpgradeHistoriesServerTransport) dispatchNewListByAppLinkMemberPager(req *http.Request) (*http.Response, error) { + if u.srv.NewListByAppLinkMemberPager == nil { + return nil, &nonRetriableError{errors.New("fake for method NewListByAppLinkMemberPager not implemented")} + } + newListByAppLinkMemberPager := u.newListByAppLinkMemberPager.get(req) + if newListByAppLinkMemberPager == nil { + const regexStr = `/subscriptions/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/resourceGroups/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/providers/Microsoft\.AppLink/appLinks/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/appLinkMembers/(?P[!#&$-;=?-\[\]_a-zA-Z0-9~%@]+)/upgradeHistories` + regex := regexp.MustCompile(regexStr) + matches := regex.FindStringSubmatch(req.URL.EscapedPath()) + if len(matches) < 5 { + return nil, fmt.Errorf("failed to parse path %s", req.URL.Path) + } + resourceGroupNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("resourceGroupName")]) + if err != nil { + return nil, err + } + appLinkNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkName")]) + if err != nil { + return nil, err + } + appLinkMemberNameParam, err := url.PathUnescape(matches[regex.SubexpIndex("appLinkMemberName")]) + if err != nil { + return nil, err + } + resp := u.srv.NewListByAppLinkMemberPager(resourceGroupNameParam, appLinkNameParam, appLinkMemberNameParam, nil) + newListByAppLinkMemberPager = &resp + u.newListByAppLinkMemberPager.add(req, newListByAppLinkMemberPager) + server.PagerResponderInjectNextLinks(newListByAppLinkMemberPager, req, func(page *armappnetwork.UpgradeHistoriesClientListByAppLinkMemberResponse, createLink func() string) { + page.NextLink = to.Ptr(createLink()) + }) + } + resp, err := server.PagerResponderNext(newListByAppLinkMemberPager, req) + if err != nil { + return nil, err + } + if !contains([]int{http.StatusOK}, resp.StatusCode) { + u.newListByAppLinkMemberPager.remove(req) + return nil, &nonRetriableError{fmt.Errorf("unexpected status code %d. acceptable values are http.StatusOK", resp.StatusCode)} + } + if !server.PagerResponderMore(newListByAppLinkMemberPager) { + u.newListByAppLinkMemberPager.remove(req) + } + return resp, nil +} + +// set this to conditionally intercept incoming requests to UpgradeHistoriesServerTransport +var upgradeHistoriesServerTransportInterceptor interface { + // Do returns true if the server transport should use the returned response/error + Do(*http.Request) (*http.Response, error, bool) +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/go.mod b/sdk/resourcemanager/appnetwork/armappnetwork/go.mod new file mode 100644 index 000000000000..13da360fd1cf --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/go.mod @@ -0,0 +1,21 @@ +module github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appnetwork/armappnetwork + +go 1.24.0 + +require ( + github.com/Azure/azure-sdk-for-go/sdk/azcore v1.21.0 + github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1 +) + +require ( + github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 // indirect + github.com/AzureAD/microsoft-authentication-library-for-go v1.6.0 // indirect + github.com/golang-jwt/jwt/v5 v5.3.0 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/kylelemons/godebug v1.1.0 // indirect + github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect + golang.org/x/crypto v0.47.0 // indirect + golang.org/x/net v0.49.0 // indirect + golang.org/x/sys v0.40.0 // indirect + golang.org/x/text v0.33.0 // indirect +) diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/go.sum b/sdk/resourcemanager/appnetwork/armappnetwork/go.sum new file mode 100644 index 000000000000..668beb5b462e --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/go.sum @@ -0,0 +1,39 @@ +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.21.0 h1:fou+2+WFTib47nS+nz/ozhEBnvU96bKHy6LjRsY4E28= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.21.0/go.mod h1:t76Ruy8AHvUAC8GfMWJMa0ElSbuIcO03NLpynfbgsPA= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1 h1:Hk5QBxZQC1jb2Fwj6mpzme37xbCDdNTxU7O9eb5+LB4= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1/go.mod h1:IYus9qsFobWIc2YVwe/WPjcnyCkPKtnHAqUYeebc8z0= +github.com/Azure/azure-sdk-for-go/sdk/azidentity/cache v0.3.2 h1:yz1bePFlP5Vws5+8ez6T3HWXPmwOK7Yvq8QxDBD3SKY= +github.com/Azure/azure-sdk-for-go/sdk/azidentity/cache v0.3.2/go.mod h1:Pa9ZNPuoNu/GztvBSKk9J1cDJW6vk/n0zLtV4mgd8N8= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 h1:9iefClla7iYpfYWdzPCRDozdmndjTm8DXdpCzPajMgA= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2/go.mod h1:XtLgD3ZD34DAaVIIAyG3objl5DynM3CQ/vMcbBNJZGI= +github.com/AzureAD/microsoft-authentication-extensions-for-go/cache v0.1.1 h1:WJTmL004Abzc5wDB5VtZG2PJk5ndYDgVacGqfirKxjM= +github.com/AzureAD/microsoft-authentication-extensions-for-go/cache v0.1.1/go.mod h1:tCcJZ0uHAmvjsVYzEFivsRTN00oz5BEsRgQHu5JZ9WE= +github.com/AzureAD/microsoft-authentication-library-for-go v1.6.0 h1:XRzhVemXdgvJqCH0sFfrBUTnUJSBrBf7++ypk+twtRs= +github.com/AzureAD/microsoft-authentication-library-for-go v1.6.0/go.mod h1:HKpQxkWaGLJ+D/5H8QRpyQXA1eKjxkFlOMwck5+33Jk= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo= +github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/keybase/go-keychain v0.0.1 h1:way+bWYa6lDppZoZcgMbYsvC7GxljxrskdNInRtuthU= +github.com/keybase/go-keychain v0.0.1/go.mod h1:PdEILRW3i9D8JcdM+FmY6RwkHGnhHxXwkPPMeUgOK1k= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= +github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8= +golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A= +golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o= +golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ= +golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= +golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE= +golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/models.go b/sdk/resourcemanager/appnetwork/armappnetwork/models.go new file mode 100644 index 000000000000..fb22241d9123 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/models.go @@ -0,0 +1,410 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork + +import "time" + +// AppLink resource +type AppLink struct { + // REQUIRED; The geo-location where the resource lives + Location *string + + // The managed service identities assigned to this resource. + Identity *ManagedServiceIdentity + + // The resource-specific properties for this resource. + Properties *AppLinkProperties + + // Resource tags. + Tags map[string]*string + + // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string + + // READ-ONLY; The name of the resource + Name *string + + // READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information. + SystemData *SystemData + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string +} + +// AppLinkListResult - The response of a AppLink list operation. +type AppLinkListResult struct { + // REQUIRED; The AppLink items on this page + Value []*AppLink + + // The link to the next page of items + NextLink *string +} + +// AppLinkMember - AppLink Member resource +type AppLinkMember struct { + // REQUIRED; The geo-location where the resource lives + Location *string + + // The resource-specific properties for this resource. + Properties *AppLinkMemberProperties + + // Resource tags. + Tags map[string]*string + + // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string + + // READ-ONLY; The name of the resource + Name *string + + // READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information. + SystemData *SystemData + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string +} + +// AppLinkMemberListResult - The response of a AppLinkMember list operation. +type AppLinkMemberListResult struct { + // REQUIRED; The AppLinkMember items on this page + Value []*AppLinkMember + + // The link to the next page of items + NextLink *string +} + +// AppLinkMemberProperties - AppLink Member properties +type AppLinkMemberProperties struct { + // REQUIRED; AppLink Member Metadata + Metadata *Metadata + + // Cluster type + ClusterType *ClusterType + + // Connectivity profile. + ConnectivityProfile *ConnectivityProfile + + // Observability profile + ObservabilityProfile *ObservabilityProfile + + // Upgrade profile. + UpgradeProfile *UpgradeProfile + + // READ-ONLY; Provisioning state + ProvisioningState *ProvisioningState +} + +// AppLinkMemberUpdate - The type used for update operations of the AppLinkMember. +type AppLinkMemberUpdate struct { + // The resource-specific properties for this resource. + Properties *AppLinkMemberUpdateProperties + + // Resource tags. + Tags map[string]*string +} + +// AppLinkMemberUpdateProperties - The updatable properties of the AppLinkMember. +type AppLinkMemberUpdateProperties struct { + // Connectivity profile. + ConnectivityProfile *ConnectivityProfile + + // Observability profile + ObservabilityProfile *ObservabilityProfile + + // Upgrade profile. + UpgradeProfile *UpgradeProfile +} + +// AppLinkProperties - AppLink properties +type AppLinkProperties struct { + // READ-ONLY; Provisioning state + ProvisioningState *ProvisioningState +} + +// AppLinkUpdate - The type used for update operations of the AppLink. +type AppLinkUpdate struct { + // Resource tags. + Tags map[string]*string +} + +// AvailableVersion - AppLink available version resource +type AvailableVersion struct { + // The resource-specific properties for this resource. + Properties *AvailableVersionProperties + + // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string + + // READ-ONLY; The name of the resource + Name *string + + // READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information. + SystemData *SystemData + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string +} + +// AvailableVersionListResult - The response of a AvailableVersion list operation. +type AvailableVersionListResult struct { + // REQUIRED; The AvailableVersion items on this page + Value []*AvailableVersion + + // The link to the next page of items + NextLink *string +} + +// AvailableVersionProperties - AppLink available version properties +type AvailableVersionProperties struct { + // REQUIRED; Fully managed versions + FullyManagedVersions *FullyManagedVersions + + // REQUIRED; Kubernetes version + KubernetesVersion *string + + // REQUIRED; Self managed versions + SelfManagedVersions *SelfManagedVersions + + // READ-ONLY; Provisioning state + ProvisioningState *ProvisioningState +} + +// ConnectivityProfile - AppLinkMember connectivity profile. +type ConnectivityProfile struct { + // East-West gateway profile. + EastWestGateway *EastWestGatewayProfile + + // Private connect profile. + PrivateConnect *PrivateConnectProfile +} + +// EastWestGatewayProfile - AppLinkMember east-west gateway profile. +type EastWestGatewayProfile struct { + // REQUIRED; East-West gateway visibility. + Visibility *EastWestGatewayVisibility +} + +// FullyManagedUpgradeProfile - AppLinkMember fully managed upgrade profile +type FullyManagedUpgradeProfile struct { + // REQUIRED; Release channel + ReleaseChannel *UpgradeReleaseChannel +} + +// FullyManagedVersions - Fully managed versions +type FullyManagedVersions struct { + // REQUIRED; Release channels + ReleaseChannels []*ReleaseChannelInfo +} + +// ManagedServiceIdentity - Managed service identity (system assigned and/or user assigned identities) +type ManagedServiceIdentity struct { + // REQUIRED; The type of managed identity assigned to this resource. + Type *ManagedServiceIdentityType + + // The identities assigned to this resource by the user. + UserAssignedIdentities map[string]*UserAssignedIdentity + + // READ-ONLY; The service principal ID of the system assigned identity. This property will only be provided for a system assigned + // identity. + PrincipalID *string + + // READ-ONLY; The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity. + TenantID *string +} + +// Metadata - AppLinkMember metadata +type Metadata struct { + // REQUIRED; Resource ID + ResourceID *string +} + +// MetricsProfile - AppLinkMember metrics profile +type MetricsProfile struct { + // READ-ONLY; Metrics endpoint URL + MetricsEndpoint *string +} + +// ObservabilityProfile - AppLinkMember observability profile +type ObservabilityProfile struct { + // Metrics configuration + Metrics *MetricsProfile +} + +// Operation - REST API Operation +// +// Details of a REST API operation, returned from the Resource Provider Operations API +type Operation struct { + // Localized display information for this particular operation. + Display *OperationDisplay + + // READ-ONLY; Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. + ActionType *ActionType + + // READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for Azure + // Resource Manager/control-plane operations. + IsDataAction *bool + + // READ-ONLY; The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write", + // "Microsoft.Compute/virtualMachines/capture/action" + Name *string + + // READ-ONLY; The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default + // value is "user,system" + Origin *Origin +} + +// OperationDisplay - Localized display information for an operation. +type OperationDisplay struct { + // READ-ONLY; The short, localized friendly description of the operation; suitable for tool tips and detailed views. + Description *string + + // READ-ONLY; The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual + // Machine", "Restart Virtual Machine". + Operation *string + + // READ-ONLY; The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft + // Compute". + Provider *string + + // READ-ONLY; The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job + // Schedule Collections". + Resource *string +} + +// OperationListResult - A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to +// get the next set of results. +type OperationListResult struct { + // REQUIRED; The Operation items on this page + Value []*Operation + + // The link to the next page of items + NextLink *string +} + +// PrivateConnectProfile - AppLinkMember private connect profile. +type PrivateConnectProfile struct { + // REQUIRED; Delegated Subnet to AppLink. + SubnetResourceID *string +} + +// ReleaseChannelInfo - Release channel information +type ReleaseChannelInfo struct { + // REQUIRED; Release channel + ReleaseChannel *string + + // REQUIRED; Istio version behind release channel + Version *string +} + +// SelfManagedUpgradeProfile - AppLinkMember self managed upgrade profile +type SelfManagedUpgradeProfile struct { + // REQUIRED; Istio version + Version *string +} + +// SelfManagedVersions - Self managed versions +type SelfManagedVersions struct { + // REQUIRED; Istio versions + Versions []*VersionInfo +} + +// SystemData - Metadata pertaining to creation and last modification of the resource. +type SystemData struct { + // The timestamp of resource creation (UTC). + CreatedAt *time.Time + + // The identity that created the resource. + CreatedBy *string + + // The type of identity that created the resource. + CreatedByType *CreatedByType + + // The timestamp of resource last modification (UTC) + LastModifiedAt *time.Time + + // The identity that last modified the resource. + LastModifiedBy *string + + // The type of identity that last modified the resource. + LastModifiedByType *CreatedByType +} + +// UpgradeHistory - AppLinkMember upgrade history +type UpgradeHistory struct { + // The resource-specific properties for this resource. + Properties *UpgradeHistoryProperties + + // READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} + ID *string + + // READ-ONLY; The name of the resource + Name *string + + // READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information. + SystemData *SystemData + + // READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" + Type *string +} + +// UpgradeHistoryListResult - The response of a UpgradeHistory list operation. +type UpgradeHistoryListResult struct { + // REQUIRED; The UpgradeHistory items on this page + Value []*UpgradeHistory + + // The link to the next page of items + NextLink *string +} + +// UpgradeHistoryProperties - AppLinkMember upgrade history properties +type UpgradeHistoryProperties struct { + // REQUIRED; Version upgraded from + FromVersion *string + + // REQUIRED; Upgrade initiator + InitiatedBy *string + + // REQUIRED; Start timestamp + StartTimestamp *time.Time + + // REQUIRED; Version upgraded to + ToVersion *string + + // End timestamp + EndTimestamp *time.Time + + // READ-ONLY; Provisioning state + ProvisioningState *ProvisioningState +} + +// UpgradeProfile - AppLinkMember upgrade profile. +type UpgradeProfile struct { + // REQUIRED; Upgrade mode. + Mode *UpgradeMode + + // Fully managed upgrade profile. + FullyManagedUpgradeProfile *FullyManagedUpgradeProfile + + // Self managed upgrade profile. + SelfManagedUpgradeProfile *SelfManagedUpgradeProfile +} + +// UserAssignedIdentity - User assigned identity properties +type UserAssignedIdentity struct { + // READ-ONLY; The client ID of the assigned identity. + ClientID *string + + // READ-ONLY; The principal ID of the assigned identity. + PrincipalID *string +} + +// VersionInfo - Version information +type VersionInfo struct { + // REQUIRED; Available upgrades + Upgrades []*string + + // REQUIRED; Istio version + Version *string +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/models_serde.go b/sdk/resourcemanager/appnetwork/armappnetwork/models_serde.go new file mode 100644 index 000000000000..a19ce3bc0f30 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/models_serde.go @@ -0,0 +1,1232 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork + +import ( + "encoding/json" + "fmt" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime" + "reflect" + "time" +) + +// MarshalJSON implements the json.Marshaller interface for type AppLink. +func (a AppLink) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", a.ID) + populate(objectMap, "identity", a.Identity) + populate(objectMap, "location", a.Location) + populate(objectMap, "name", a.Name) + populate(objectMap, "properties", a.Properties) + populate(objectMap, "systemData", a.SystemData) + populate(objectMap, "tags", a.Tags) + populate(objectMap, "type", a.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AppLink. +func (a *AppLink) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &a.ID) + delete(rawMsg, key) + case "identity": + err = unpopulate(val, "Identity", &a.Identity) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &a.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &a.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &a.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &a.SystemData) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &a.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &a.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AppLinkListResult. +func (a AppLinkListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", a.NextLink) + populate(objectMap, "value", a.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AppLinkListResult. +func (a *AppLinkListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &a.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &a.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AppLinkMember. +func (a AppLinkMember) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", a.ID) + populate(objectMap, "location", a.Location) + populate(objectMap, "name", a.Name) + populate(objectMap, "properties", a.Properties) + populate(objectMap, "systemData", a.SystemData) + populate(objectMap, "tags", a.Tags) + populate(objectMap, "type", a.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AppLinkMember. +func (a *AppLinkMember) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &a.ID) + delete(rawMsg, key) + case "location": + err = unpopulate(val, "Location", &a.Location) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &a.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &a.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &a.SystemData) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &a.Tags) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &a.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AppLinkMemberListResult. +func (a AppLinkMemberListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", a.NextLink) + populate(objectMap, "value", a.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AppLinkMemberListResult. +func (a *AppLinkMemberListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &a.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &a.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AppLinkMemberProperties. +func (a AppLinkMemberProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "clusterType", a.ClusterType) + populate(objectMap, "connectivityProfile", a.ConnectivityProfile) + populate(objectMap, "metadata", a.Metadata) + populate(objectMap, "observabilityProfile", a.ObservabilityProfile) + populate(objectMap, "provisioningState", a.ProvisioningState) + populate(objectMap, "upgradeProfile", a.UpgradeProfile) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AppLinkMemberProperties. +func (a *AppLinkMemberProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "clusterType": + err = unpopulate(val, "ClusterType", &a.ClusterType) + delete(rawMsg, key) + case "connectivityProfile": + err = unpopulate(val, "ConnectivityProfile", &a.ConnectivityProfile) + delete(rawMsg, key) + case "metadata": + err = unpopulate(val, "Metadata", &a.Metadata) + delete(rawMsg, key) + case "observabilityProfile": + err = unpopulate(val, "ObservabilityProfile", &a.ObservabilityProfile) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &a.ProvisioningState) + delete(rawMsg, key) + case "upgradeProfile": + err = unpopulate(val, "UpgradeProfile", &a.UpgradeProfile) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AppLinkMemberUpdate. +func (a AppLinkMemberUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "properties", a.Properties) + populate(objectMap, "tags", a.Tags) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AppLinkMemberUpdate. +func (a *AppLinkMemberUpdate) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "properties": + err = unpopulate(val, "Properties", &a.Properties) + delete(rawMsg, key) + case "tags": + err = unpopulate(val, "Tags", &a.Tags) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AppLinkMemberUpdateProperties. +func (a AppLinkMemberUpdateProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "connectivityProfile", a.ConnectivityProfile) + populate(objectMap, "observabilityProfile", a.ObservabilityProfile) + populate(objectMap, "upgradeProfile", a.UpgradeProfile) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AppLinkMemberUpdateProperties. +func (a *AppLinkMemberUpdateProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "connectivityProfile": + err = unpopulate(val, "ConnectivityProfile", &a.ConnectivityProfile) + delete(rawMsg, key) + case "observabilityProfile": + err = unpopulate(val, "ObservabilityProfile", &a.ObservabilityProfile) + delete(rawMsg, key) + case "upgradeProfile": + err = unpopulate(val, "UpgradeProfile", &a.UpgradeProfile) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AppLinkProperties. +func (a AppLinkProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "provisioningState", a.ProvisioningState) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AppLinkProperties. +func (a *AppLinkProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &a.ProvisioningState) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AppLinkUpdate. +func (a AppLinkUpdate) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "tags", a.Tags) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AppLinkUpdate. +func (a *AppLinkUpdate) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "tags": + err = unpopulate(val, "Tags", &a.Tags) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AvailableVersion. +func (a AvailableVersion) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", a.ID) + populate(objectMap, "name", a.Name) + populate(objectMap, "properties", a.Properties) + populate(objectMap, "systemData", a.SystemData) + populate(objectMap, "type", a.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AvailableVersion. +func (a *AvailableVersion) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &a.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &a.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &a.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &a.SystemData) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &a.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AvailableVersionListResult. +func (a AvailableVersionListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", a.NextLink) + populate(objectMap, "value", a.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AvailableVersionListResult. +func (a *AvailableVersionListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &a.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &a.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type AvailableVersionProperties. +func (a AvailableVersionProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "fullyManagedVersions", a.FullyManagedVersions) + populate(objectMap, "kubernetesVersion", a.KubernetesVersion) + populate(objectMap, "provisioningState", a.ProvisioningState) + populate(objectMap, "selfManagedVersions", a.SelfManagedVersions) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type AvailableVersionProperties. +func (a *AvailableVersionProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "fullyManagedVersions": + err = unpopulate(val, "FullyManagedVersions", &a.FullyManagedVersions) + delete(rawMsg, key) + case "kubernetesVersion": + err = unpopulate(val, "KubernetesVersion", &a.KubernetesVersion) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &a.ProvisioningState) + delete(rawMsg, key) + case "selfManagedVersions": + err = unpopulate(val, "SelfManagedVersions", &a.SelfManagedVersions) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", a, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ConnectivityProfile. +func (c ConnectivityProfile) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "eastWestGateway", c.EastWestGateway) + populate(objectMap, "privateConnect", c.PrivateConnect) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ConnectivityProfile. +func (c *ConnectivityProfile) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", c, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "eastWestGateway": + err = unpopulate(val, "EastWestGateway", &c.EastWestGateway) + delete(rawMsg, key) + case "privateConnect": + err = unpopulate(val, "PrivateConnect", &c.PrivateConnect) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", c, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type EastWestGatewayProfile. +func (e EastWestGatewayProfile) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "visibility", e.Visibility) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type EastWestGatewayProfile. +func (e *EastWestGatewayProfile) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "visibility": + err = unpopulate(val, "Visibility", &e.Visibility) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", e, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type FullyManagedUpgradeProfile. +func (f FullyManagedUpgradeProfile) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "releaseChannel", f.ReleaseChannel) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type FullyManagedUpgradeProfile. +func (f *FullyManagedUpgradeProfile) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", f, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "releaseChannel": + err = unpopulate(val, "ReleaseChannel", &f.ReleaseChannel) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", f, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type FullyManagedVersions. +func (f FullyManagedVersions) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "releaseChannels", f.ReleaseChannels) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type FullyManagedVersions. +func (f *FullyManagedVersions) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", f, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "releaseChannels": + err = unpopulate(val, "ReleaseChannels", &f.ReleaseChannels) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", f, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentity. +func (m ManagedServiceIdentity) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "principalId", m.PrincipalID) + populate(objectMap, "tenantId", m.TenantID) + populate(objectMap, "type", m.Type) + populate(objectMap, "userAssignedIdentities", m.UserAssignedIdentities) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ManagedServiceIdentity. +func (m *ManagedServiceIdentity) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "principalId": + err = unpopulate(val, "PrincipalID", &m.PrincipalID) + delete(rawMsg, key) + case "tenantId": + err = unpopulate(val, "TenantID", &m.TenantID) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &m.Type) + delete(rawMsg, key) + case "userAssignedIdentities": + err = unpopulate(val, "UserAssignedIdentities", &m.UserAssignedIdentities) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type Metadata. +func (m Metadata) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "resourceId", m.ResourceID) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type Metadata. +func (m *Metadata) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "resourceId": + err = unpopulate(val, "ResourceID", &m.ResourceID) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type MetricsProfile. +func (m MetricsProfile) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "metricsEndpoint", m.MetricsEndpoint) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type MetricsProfile. +func (m *MetricsProfile) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "metricsEndpoint": + err = unpopulate(val, "MetricsEndpoint", &m.MetricsEndpoint) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", m, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ObservabilityProfile. +func (o ObservabilityProfile) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "metrics", o.Metrics) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ObservabilityProfile. +func (o *ObservabilityProfile) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "metrics": + err = unpopulate(val, "Metrics", &o.Metrics) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type Operation. +func (o Operation) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "actionType", o.ActionType) + populate(objectMap, "display", o.Display) + populate(objectMap, "isDataAction", o.IsDataAction) + populate(objectMap, "name", o.Name) + populate(objectMap, "origin", o.Origin) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type Operation. +func (o *Operation) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "actionType": + err = unpopulate(val, "ActionType", &o.ActionType) + delete(rawMsg, key) + case "display": + err = unpopulate(val, "Display", &o.Display) + delete(rawMsg, key) + case "isDataAction": + err = unpopulate(val, "IsDataAction", &o.IsDataAction) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &o.Name) + delete(rawMsg, key) + case "origin": + err = unpopulate(val, "Origin", &o.Origin) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type OperationDisplay. +func (o OperationDisplay) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "description", o.Description) + populate(objectMap, "operation", o.Operation) + populate(objectMap, "provider", o.Provider) + populate(objectMap, "resource", o.Resource) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay. +func (o *OperationDisplay) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "description": + err = unpopulate(val, "Description", &o.Description) + delete(rawMsg, key) + case "operation": + err = unpopulate(val, "Operation", &o.Operation) + delete(rawMsg, key) + case "provider": + err = unpopulate(val, "Provider", &o.Provider) + delete(rawMsg, key) + case "resource": + err = unpopulate(val, "Resource", &o.Resource) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type OperationListResult. +func (o OperationListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", o.NextLink) + populate(objectMap, "value", o.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult. +func (o *OperationListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &o.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &o.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", o, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type PrivateConnectProfile. +func (p PrivateConnectProfile) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "subnetResourceId", p.SubnetResourceID) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type PrivateConnectProfile. +func (p *PrivateConnectProfile) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "subnetResourceId": + err = unpopulate(val, "SubnetResourceID", &p.SubnetResourceID) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", p, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type ReleaseChannelInfo. +func (r ReleaseChannelInfo) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "releaseChannel", r.ReleaseChannel) + populate(objectMap, "version", r.Version) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type ReleaseChannelInfo. +func (r *ReleaseChannelInfo) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "releaseChannel": + err = unpopulate(val, "ReleaseChannel", &r.ReleaseChannel) + delete(rawMsg, key) + case "version": + err = unpopulate(val, "Version", &r.Version) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", r, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SelfManagedUpgradeProfile. +func (s SelfManagedUpgradeProfile) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "version", s.Version) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SelfManagedUpgradeProfile. +func (s *SelfManagedUpgradeProfile) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "version": + err = unpopulate(val, "Version", &s.Version) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SelfManagedVersions. +func (s SelfManagedVersions) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "versions", s.Versions) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SelfManagedVersions. +func (s *SelfManagedVersions) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "versions": + err = unpopulate(val, "Versions", &s.Versions) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type SystemData. +func (s SystemData) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populateTime[datetime.RFC3339](objectMap, "createdAt", s.CreatedAt) + populate(objectMap, "createdBy", s.CreatedBy) + populate(objectMap, "createdByType", s.CreatedByType) + populateTime[datetime.RFC3339](objectMap, "lastModifiedAt", s.LastModifiedAt) + populate(objectMap, "lastModifiedBy", s.LastModifiedBy) + populate(objectMap, "lastModifiedByType", s.LastModifiedByType) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type SystemData. +func (s *SystemData) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "createdAt": + err = unpopulateTime[datetime.RFC3339](val, "CreatedAt", &s.CreatedAt) + delete(rawMsg, key) + case "createdBy": + err = unpopulate(val, "CreatedBy", &s.CreatedBy) + delete(rawMsg, key) + case "createdByType": + err = unpopulate(val, "CreatedByType", &s.CreatedByType) + delete(rawMsg, key) + case "lastModifiedAt": + err = unpopulateTime[datetime.RFC3339](val, "LastModifiedAt", &s.LastModifiedAt) + delete(rawMsg, key) + case "lastModifiedBy": + err = unpopulate(val, "LastModifiedBy", &s.LastModifiedBy) + delete(rawMsg, key) + case "lastModifiedByType": + err = unpopulate(val, "LastModifiedByType", &s.LastModifiedByType) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", s, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type UpgradeHistory. +func (u UpgradeHistory) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "id", u.ID) + populate(objectMap, "name", u.Name) + populate(objectMap, "properties", u.Properties) + populate(objectMap, "systemData", u.SystemData) + populate(objectMap, "type", u.Type) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type UpgradeHistory. +func (u *UpgradeHistory) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", u, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "id": + err = unpopulate(val, "ID", &u.ID) + delete(rawMsg, key) + case "name": + err = unpopulate(val, "Name", &u.Name) + delete(rawMsg, key) + case "properties": + err = unpopulate(val, "Properties", &u.Properties) + delete(rawMsg, key) + case "systemData": + err = unpopulate(val, "SystemData", &u.SystemData) + delete(rawMsg, key) + case "type": + err = unpopulate(val, "Type", &u.Type) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", u, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type UpgradeHistoryListResult. +func (u UpgradeHistoryListResult) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "nextLink", u.NextLink) + populate(objectMap, "value", u.Value) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type UpgradeHistoryListResult. +func (u *UpgradeHistoryListResult) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", u, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "nextLink": + err = unpopulate(val, "NextLink", &u.NextLink) + delete(rawMsg, key) + case "value": + err = unpopulate(val, "Value", &u.Value) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", u, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type UpgradeHistoryProperties. +func (u UpgradeHistoryProperties) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populateTime[datetime.RFC3339](objectMap, "endTimestamp", u.EndTimestamp) + populate(objectMap, "fromVersion", u.FromVersion) + populate(objectMap, "initiatedBy", u.InitiatedBy) + populate(objectMap, "provisioningState", u.ProvisioningState) + populateTime[datetime.RFC3339](objectMap, "startTimestamp", u.StartTimestamp) + populate(objectMap, "toVersion", u.ToVersion) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type UpgradeHistoryProperties. +func (u *UpgradeHistoryProperties) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", u, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "endTimestamp": + err = unpopulateTime[datetime.RFC3339](val, "EndTimestamp", &u.EndTimestamp) + delete(rawMsg, key) + case "fromVersion": + err = unpopulate(val, "FromVersion", &u.FromVersion) + delete(rawMsg, key) + case "initiatedBy": + err = unpopulate(val, "InitiatedBy", &u.InitiatedBy) + delete(rawMsg, key) + case "provisioningState": + err = unpopulate(val, "ProvisioningState", &u.ProvisioningState) + delete(rawMsg, key) + case "startTimestamp": + err = unpopulateTime[datetime.RFC3339](val, "StartTimestamp", &u.StartTimestamp) + delete(rawMsg, key) + case "toVersion": + err = unpopulate(val, "ToVersion", &u.ToVersion) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", u, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type UpgradeProfile. +func (u UpgradeProfile) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "fullyManagedUpgradeProfile", u.FullyManagedUpgradeProfile) + populate(objectMap, "mode", u.Mode) + populate(objectMap, "selfManagedUpgradeProfile", u.SelfManagedUpgradeProfile) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type UpgradeProfile. +func (u *UpgradeProfile) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", u, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "fullyManagedUpgradeProfile": + err = unpopulate(val, "FullyManagedUpgradeProfile", &u.FullyManagedUpgradeProfile) + delete(rawMsg, key) + case "mode": + err = unpopulate(val, "Mode", &u.Mode) + delete(rawMsg, key) + case "selfManagedUpgradeProfile": + err = unpopulate(val, "SelfManagedUpgradeProfile", &u.SelfManagedUpgradeProfile) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", u, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity. +func (u UserAssignedIdentity) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "clientId", u.ClientID) + populate(objectMap, "principalId", u.PrincipalID) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity. +func (u *UserAssignedIdentity) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", u, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "clientId": + err = unpopulate(val, "ClientID", &u.ClientID) + delete(rawMsg, key) + case "principalId": + err = unpopulate(val, "PrincipalID", &u.PrincipalID) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", u, err) + } + } + return nil +} + +// MarshalJSON implements the json.Marshaller interface for type VersionInfo. +func (v VersionInfo) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]any) + populate(objectMap, "upgrades", v.Upgrades) + populate(objectMap, "version", v.Version) + return json.Marshal(objectMap) +} + +// UnmarshalJSON implements the json.Unmarshaller interface for type VersionInfo. +func (v *VersionInfo) UnmarshalJSON(data []byte) error { + var rawMsg map[string]json.RawMessage + if err := json.Unmarshal(data, &rawMsg); err != nil { + return fmt.Errorf("unmarshalling type %T: %v", v, err) + } + for key, val := range rawMsg { + var err error + switch key { + case "upgrades": + err = unpopulate(val, "Upgrades", &v.Upgrades) + delete(rawMsg, key) + case "version": + err = unpopulate(val, "Version", &v.Version) + delete(rawMsg, key) + } + if err != nil { + return fmt.Errorf("unmarshalling type %T: %v", v, err) + } + } + return nil +} + +func populate(m map[string]any, k string, v any) { + if v == nil { + return + } else if azcore.IsNullValue(v) { + m[k] = nil + } else if !reflect.ValueOf(v).IsNil() { + m[k] = v + } +} + +func populateTime[T dateTimeConstraints](m map[string]any, k string, t *time.Time) { + if t == nil { + return + } else if azcore.IsNullValue(t) { + m[k] = nil + } else if !reflect.ValueOf(t).IsNil() { + newTime := T(*t) + m[k] = (*T)(&newTime) + } +} + +func unpopulate(data json.RawMessage, fn string, v any) error { + if data == nil || string(data) == "null" { + return nil + } + if err := json.Unmarshal(data, v); err != nil { + return fmt.Errorf("struct field %s: %v", fn, err) + } + return nil +} + +func unpopulateTime[T dateTimeConstraints](data json.RawMessage, fn string, t **time.Time) error { + if data == nil || string(data) == "null" { + return nil + } + var aux T + if err := json.Unmarshal(data, &aux); err != nil { + return fmt.Errorf("struct field %s: %v", fn, err) + } + newTime := time.Time(aux) + *t = &newTime + return nil +} + +type dateTimeConstraints interface { + datetime.PlainDate | datetime.PlainTime | datetime.RFC1123 | datetime.RFC3339 | datetime.Unix +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/operations_client.go b/sdk/resourcemanager/appnetwork/armappnetwork/operations_client.go new file mode 100644 index 000000000000..afe88340c30f --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/operations_client.go @@ -0,0 +1,84 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork + +import ( + "context" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" +) + +// OperationsClient contains the methods for the Operations group. +// Don't use this type directly, use NewOperationsClient() instead. +type OperationsClient struct { + internal *arm.Client +} + +// NewOperationsClient creates a new instance of OperationsClient with the specified values. +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - Contains optional client configuration. Pass nil to accept the default values. +func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error) { + cl, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &OperationsClient{ + internal: cl, + } + return client, nil +} + +// NewListPager - List the operations for the provider +// +// Generated from API version 2025-08-01-preview +// - options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method. +func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse] { + return runtime.NewPager(runtime.PagingHandler[OperationsClientListResponse]{ + More: func(page OperationsClientListResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *OperationsClientListResponse) (OperationsClientListResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "OperationsClient.NewListPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listCreateRequest(ctx, options) + }, nil) + if err != nil { + return OperationsClientListResponse{}, err + } + return client.listHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listCreateRequest creates the List request. +func (client *OperationsClient) listCreateRequest(ctx context.Context, _ *OperationsClientListOptions) (*policy.Request, error) { + urlPath := "/providers/Microsoft.AppLink/operations" + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listHandleResponse handles the List response. +func (client *OperationsClient) listHandleResponse(resp *http.Response) (OperationsClientListResponse, error) { + result := OperationsClientListResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.OperationListResult); err != nil { + return OperationsClientListResponse{}, err + } + return result, nil +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/operations_client_example_test.go b/sdk/resourcemanager/appnetwork/armappnetwork/operations_client_example_test.go new file mode 100644 index 000000000000..1ea495322c4d --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/operations_client_example_test.go @@ -0,0 +1,164 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork_test + +import ( + "context" + "github.com/Azure/azure-sdk-for-go/sdk/azidentity" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appnetwork/armappnetwork" + "log" +) + +// Generated from example definition: 2025-08-01-preview/Operations_List.json +func ExampleOperationsClient_NewListPager() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + pager := clientFactory.NewOperationsClient().NewListPager(nil) + for pager.More() { + page, err := pager.NextPage(ctx) + if err != nil { + log.Fatalf("failed to advance page: %v", err) + } + for _, v := range page.Value { + // You could use page here. We use blank identifier for just demo purposes. + _ = v + } + // If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes. + // page = armappnetwork.OperationsClientListResponse{ + // OperationListResult: armappnetwork.OperationListResult{ + // Value: []*armappnetwork.Operation{ + // { + // Name: to.Ptr("Microsoft.AppLink/register/action"), + // IsDataAction: to.Ptr(false), + // Display: &armappnetwork.OperationDisplay{ + // Provider: to.Ptr("Microsoft AppLink"), + // Resource: to.Ptr("Microsoft.AppLink"), + // Operation: to.Ptr("Register the subscription for Microsoft.AppLink"), + // Description: to.Ptr("Register the subscription for Microsoft.AppLink"), + // }, + // Origin: to.Ptr(armappnetwork.OriginUserSystem), + // }, + // { + // Name: to.Ptr("Microsoft.AppLink/unregister/action"), + // IsDataAction: to.Ptr(false), + // Display: &armappnetwork.OperationDisplay{ + // Provider: to.Ptr("Microsoft AppLink"), + // Resource: to.Ptr("Microsoft.AppLink"), + // Operation: to.Ptr("Unregister the subscription for Microsoft.AppLink"), + // Description: to.Ptr("Unregister the subscription for Microsoft.AppLink"), + // }, + // Origin: to.Ptr(armappnetwork.OriginUserSystem), + // }, + // { + // Name: to.Ptr("Microsoft.AppLink/operations/read"), + // IsDataAction: to.Ptr(false), + // Display: &armappnetwork.OperationDisplay{ + // Provider: to.Ptr("Microsoft AppLink"), + // Resource: to.Ptr("Operations"), + // Operation: to.Ptr("List available operations"), + // Description: to.Ptr("List the available operations for the Microsoft.AppLink resource provider"), + // }, + // Origin: to.Ptr(armappnetwork.OriginUserSystem), + // }, + // { + // Name: to.Ptr("Microsoft.AppLink/appLinks/read"), + // IsDataAction: to.Ptr(false), + // Display: &armappnetwork.OperationDisplay{ + // Provider: to.Ptr("Microsoft AppLink"), + // Resource: to.Ptr("AppLinks"), + // Operation: to.Ptr("Get AppLink"), + // Description: to.Ptr("Get an AppLink or list AppLinks"), + // }, + // Origin: to.Ptr(armappnetwork.OriginUserSystem), + // }, + // { + // Name: to.Ptr("Microsoft.AppLink/appLinks/write"), + // IsDataAction: to.Ptr(false), + // Display: &armappnetwork.OperationDisplay{ + // Provider: to.Ptr("Microsoft AppLink"), + // Resource: to.Ptr("AppLinks"), + // Operation: to.Ptr("Create or Update AppLink"), + // Description: to.Ptr("Create or update an AppLink"), + // }, + // Origin: to.Ptr(armappnetwork.OriginUser), + // }, + // { + // Name: to.Ptr("Microsoft.AppLink/appLinks/delete"), + // IsDataAction: to.Ptr(false), + // Display: &armappnetwork.OperationDisplay{ + // Provider: to.Ptr("Microsoft AppLink"), + // Resource: to.Ptr("AppLinks"), + // Operation: to.Ptr("Delete AppLink"), + // Description: to.Ptr("Delete an AppLink"), + // }, + // Origin: to.Ptr(armappnetwork.OriginUser), + // }, + // { + // Name: to.Ptr("Microsoft.AppLink/appLinks/appLinkMembers/read"), + // IsDataAction: to.Ptr(false), + // Display: &armappnetwork.OperationDisplay{ + // Provider: to.Ptr("Microsoft AppLink"), + // Resource: to.Ptr("AppLink Members"), + // Operation: to.Ptr("Get AppLink Member"), + // Description: to.Ptr("Get an AppLink Member or list AppLink Members"), + // }, + // Origin: to.Ptr(armappnetwork.OriginUserSystem), + // }, + // { + // Name: to.Ptr("Microsoft.AppLink/appLinks/appLinkMembers/write"), + // IsDataAction: to.Ptr(false), + // Display: &armappnetwork.OperationDisplay{ + // Provider: to.Ptr("Microsoft AppLink"), + // Resource: to.Ptr("AppLink Members"), + // Operation: to.Ptr("Create or Update AppLink Member"), + // Description: to.Ptr("Create or update an AppLink Member"), + // }, + // Origin: to.Ptr(armappnetwork.OriginUser), + // }, + // { + // Name: to.Ptr("Microsoft.AppLink/appLinks/appLinkMembers/delete"), + // IsDataAction: to.Ptr(false), + // Display: &armappnetwork.OperationDisplay{ + // Provider: to.Ptr("Microsoft AppLink"), + // Resource: to.Ptr("AppLink Members"), + // Operation: to.Ptr("Delete AppLink Member"), + // Description: to.Ptr("Delete an AppLink Member"), + // }, + // Origin: to.Ptr(armappnetwork.OriginUser), + // }, + // { + // Name: to.Ptr("Microsoft.AppLink/appLinks/appLinkMembers/upgradeHistories/read"), + // IsDataAction: to.Ptr(false), + // Display: &armappnetwork.OperationDisplay{ + // Provider: to.Ptr("Microsoft AppLink"), + // Resource: to.Ptr("Upgrade Histories"), + // Operation: to.Ptr("List Upgrade Histories"), + // Description: to.Ptr("List upgrade histories for an AppLink Member"), + // }, + // Origin: to.Ptr(armappnetwork.OriginUserSystem), + // }, + // { + // Name: to.Ptr("Microsoft.AppLink/locations/availableVersions/read"), + // IsDataAction: to.Ptr(false), + // Display: &armappnetwork.OperationDisplay{ + // Provider: to.Ptr("Microsoft AppLink"), + // Resource: to.Ptr("Available Versions"), + // Operation: to.Ptr("List Available Versions"), + // Description: to.Ptr("List available versions for a location"), + // }, + // Origin: to.Ptr(armappnetwork.OriginUserSystem), + // }, + // }, + // }, + // } + } +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/options.go b/sdk/resourcemanager/appnetwork/armappnetwork/options.go new file mode 100644 index 000000000000..4bc039c89843 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/options.go @@ -0,0 +1,88 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork + +// AppLinkMembersClientBeginCreateOrUpdateOptions contains the optional parameters for the AppLinkMembersClient.BeginCreateOrUpdate +// method. +type AppLinkMembersClientBeginCreateOrUpdateOptions struct { + // Resumes the long-running operation from the provided token. + ResumeToken string +} + +// AppLinkMembersClientBeginDeleteOptions contains the optional parameters for the AppLinkMembersClient.BeginDelete method. +type AppLinkMembersClientBeginDeleteOptions struct { + // Resumes the long-running operation from the provided token. + ResumeToken string +} + +// AppLinkMembersClientBeginUpdateOptions contains the optional parameters for the AppLinkMembersClient.BeginUpdate method. +type AppLinkMembersClientBeginUpdateOptions struct { + // Resumes the long-running operation from the provided token. + ResumeToken string +} + +// AppLinkMembersClientGetOptions contains the optional parameters for the AppLinkMembersClient.Get method. +type AppLinkMembersClientGetOptions struct { + // placeholder for future optional parameters +} + +// AppLinkMembersClientListByAppLinkOptions contains the optional parameters for the AppLinkMembersClient.NewListByAppLinkPager +// method. +type AppLinkMembersClientListByAppLinkOptions struct { + // placeholder for future optional parameters +} + +// AppLinksClientBeginCreateOrUpdateOptions contains the optional parameters for the AppLinksClient.BeginCreateOrUpdate method. +type AppLinksClientBeginCreateOrUpdateOptions struct { + // Resumes the long-running operation from the provided token. + ResumeToken string +} + +// AppLinksClientBeginDeleteOptions contains the optional parameters for the AppLinksClient.BeginDelete method. +type AppLinksClientBeginDeleteOptions struct { + // Resumes the long-running operation from the provided token. + ResumeToken string +} + +// AppLinksClientBeginUpdateOptions contains the optional parameters for the AppLinksClient.BeginUpdate method. +type AppLinksClientBeginUpdateOptions struct { + // Resumes the long-running operation from the provided token. + ResumeToken string +} + +// AppLinksClientGetOptions contains the optional parameters for the AppLinksClient.Get method. +type AppLinksClientGetOptions struct { + // placeholder for future optional parameters +} + +// AppLinksClientListByResourceGroupOptions contains the optional parameters for the AppLinksClient.NewListByResourceGroupPager +// method. +type AppLinksClientListByResourceGroupOptions struct { + // placeholder for future optional parameters +} + +// AppLinksClientListBySubscriptionOptions contains the optional parameters for the AppLinksClient.NewListBySubscriptionPager +// method. +type AppLinksClientListBySubscriptionOptions struct { + // placeholder for future optional parameters +} + +// AvailableVersionsClientListByLocationOptions contains the optional parameters for the AvailableVersionsClient.NewListByLocationPager +// method. +type AvailableVersionsClientListByLocationOptions struct { + // Kubernetes version to filter profiles + KubernetesVersion *string +} + +// OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method. +type OperationsClientListOptions struct { + // placeholder for future optional parameters +} + +// UpgradeHistoriesClientListByAppLinkMemberOptions contains the optional parameters for the UpgradeHistoriesClient.NewListByAppLinkMemberPager +// method. +type UpgradeHistoriesClientListByAppLinkMemberOptions struct { + // placeholder for future optional parameters +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/responses.go b/sdk/resourcemanager/appnetwork/armappnetwork/responses.go new file mode 100644 index 000000000000..7f69bd3af7eb --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/responses.go @@ -0,0 +1,87 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork + +// AppLinkMembersClientCreateOrUpdateResponse contains the response from method AppLinkMembersClient.BeginCreateOrUpdate. +type AppLinkMembersClientCreateOrUpdateResponse struct { + // AppLink Member resource + AppLinkMember +} + +// AppLinkMembersClientDeleteResponse contains the response from method AppLinkMembersClient.BeginDelete. +type AppLinkMembersClientDeleteResponse struct { + // placeholder for future response values +} + +// AppLinkMembersClientGetResponse contains the response from method AppLinkMembersClient.Get. +type AppLinkMembersClientGetResponse struct { + // AppLink Member resource + AppLinkMember +} + +// AppLinkMembersClientListByAppLinkResponse contains the response from method AppLinkMembersClient.NewListByAppLinkPager. +type AppLinkMembersClientListByAppLinkResponse struct { + // The response of a AppLinkMember list operation. + AppLinkMemberListResult +} + +// AppLinkMembersClientUpdateResponse contains the response from method AppLinkMembersClient.BeginUpdate. +type AppLinkMembersClientUpdateResponse struct { + // AppLink Member resource + AppLinkMember +} + +// AppLinksClientCreateOrUpdateResponse contains the response from method AppLinksClient.BeginCreateOrUpdate. +type AppLinksClientCreateOrUpdateResponse struct { + // AppLink resource + AppLink +} + +// AppLinksClientDeleteResponse contains the response from method AppLinksClient.BeginDelete. +type AppLinksClientDeleteResponse struct { + // placeholder for future response values +} + +// AppLinksClientGetResponse contains the response from method AppLinksClient.Get. +type AppLinksClientGetResponse struct { + // AppLink resource + AppLink +} + +// AppLinksClientListByResourceGroupResponse contains the response from method AppLinksClient.NewListByResourceGroupPager. +type AppLinksClientListByResourceGroupResponse struct { + // The response of a AppLink list operation. + AppLinkListResult +} + +// AppLinksClientListBySubscriptionResponse contains the response from method AppLinksClient.NewListBySubscriptionPager. +type AppLinksClientListBySubscriptionResponse struct { + // The response of a AppLink list operation. + AppLinkListResult +} + +// AppLinksClientUpdateResponse contains the response from method AppLinksClient.BeginUpdate. +type AppLinksClientUpdateResponse struct { + // AppLink resource + AppLink +} + +// AvailableVersionsClientListByLocationResponse contains the response from method AvailableVersionsClient.NewListByLocationPager. +type AvailableVersionsClientListByLocationResponse struct { + // The response of a AvailableVersion list operation. + AvailableVersionListResult +} + +// OperationsClientListResponse contains the response from method OperationsClient.NewListPager. +type OperationsClientListResponse struct { + // A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results. + OperationListResult +} + +// UpgradeHistoriesClientListByAppLinkMemberResponse contains the response from method UpgradeHistoriesClient.NewListByAppLinkMemberPager. +type UpgradeHistoriesClientListByAppLinkMemberResponse struct { + // The response of a UpgradeHistory list operation. + UpgradeHistoryListResult +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/testdata/_metadata.json b/sdk/resourcemanager/appnetwork/armappnetwork/testdata/_metadata.json new file mode 100644 index 000000000000..f735dd1d9454 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/testdata/_metadata.json @@ -0,0 +1,6 @@ +{ + "apiVersions": { + "Microsoft.AppLink": "2025-08-01-preview" + }, + "emitterVersion": "0.10.3" +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/tsp-location.yaml b/sdk/resourcemanager/appnetwork/armappnetwork/tsp-location.yaml new file mode 100644 index 000000000000..e0b55507434f --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/tsp-location.yaml @@ -0,0 +1,4 @@ +directory: specification/applink/AppLink.Management +commit: bf394b468f3f3cf9d0c678282d7efdf9b3411132 +repo: Azure/azure-rest-api-specs +additionalDirectories: diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/upgradehistories_client.go b/sdk/resourcemanager/appnetwork/armappnetwork/upgradehistories_client.go new file mode 100644 index 000000000000..48f0ef070fc0 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/upgradehistories_client.go @@ -0,0 +1,110 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork + +import ( + "context" + "errors" + "github.com/Azure/azure-sdk-for-go/sdk/azcore" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/arm" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" + "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime" + "net/http" + "net/url" + "strings" +) + +// UpgradeHistoriesClient contains the methods for the UpgradeHistories group. +// Don't use this type directly, use NewUpgradeHistoriesClient() instead. +type UpgradeHistoriesClient struct { + internal *arm.Client + subscriptionID string +} + +// NewUpgradeHistoriesClient creates a new instance of UpgradeHistoriesClient with the specified values. +// - subscriptionID - The ID of the target subscription. The value must be an UUID. +// - credential - used to authorize requests. Usually a credential from azidentity. +// - options - Contains optional client configuration. Pass nil to accept the default values. +func NewUpgradeHistoriesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*UpgradeHistoriesClient, error) { + cl, err := arm.NewClient(moduleName, moduleVersion, credential, options) + if err != nil { + return nil, err + } + client := &UpgradeHistoriesClient{ + subscriptionID: subscriptionID, + internal: cl, + } + return client, nil +} + +// NewListByAppLinkMemberPager - List UpgradeHistory resources by AppLinkMember. +// +// Generated from API version 2025-08-01-preview +// - resourceGroupName - The name of the resource group. The name is case insensitive. +// - appLinkName - The name of the AppLink +// - appLinkMemberName - The name of the AppLinkMember +// - options - UpgradeHistoriesClientListByAppLinkMemberOptions contains the optional parameters for the UpgradeHistoriesClient.NewListByAppLinkMemberPager +// method. +func (client *UpgradeHistoriesClient) NewListByAppLinkMemberPager(resourceGroupName string, appLinkName string, appLinkMemberName string, options *UpgradeHistoriesClientListByAppLinkMemberOptions) *runtime.Pager[UpgradeHistoriesClientListByAppLinkMemberResponse] { + return runtime.NewPager(runtime.PagingHandler[UpgradeHistoriesClientListByAppLinkMemberResponse]{ + More: func(page UpgradeHistoriesClientListByAppLinkMemberResponse) bool { + return page.NextLink != nil && len(*page.NextLink) > 0 + }, + Fetcher: func(ctx context.Context, page *UpgradeHistoriesClientListByAppLinkMemberResponse) (UpgradeHistoriesClientListByAppLinkMemberResponse, error) { + ctx = context.WithValue(ctx, runtime.CtxAPINameKey{}, "UpgradeHistoriesClient.NewListByAppLinkMemberPager") + nextLink := "" + if page != nil { + nextLink = *page.NextLink + } + resp, err := runtime.FetcherForNextLink(ctx, client.internal.Pipeline(), nextLink, func(ctx context.Context) (*policy.Request, error) { + return client.listByAppLinkMemberCreateRequest(ctx, resourceGroupName, appLinkName, appLinkMemberName, options) + }, nil) + if err != nil { + return UpgradeHistoriesClientListByAppLinkMemberResponse{}, err + } + return client.listByAppLinkMemberHandleResponse(resp) + }, + Tracer: client.internal.Tracer(), + }) +} + +// listByAppLinkMemberCreateRequest creates the ListByAppLinkMember request. +func (client *UpgradeHistoriesClient) listByAppLinkMemberCreateRequest(ctx context.Context, resourceGroupName string, appLinkName string, appLinkMemberName string, _ *UpgradeHistoriesClientListByAppLinkMemberOptions) (*policy.Request, error) { + urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AppLink/appLinks/{appLinkName}/appLinkMembers/{appLinkMemberName}/upgradeHistories" + if client.subscriptionID == "" { + return nil, errors.New("parameter client.subscriptionID cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID)) + if resourceGroupName == "" { + return nil, errors.New("parameter resourceGroupName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName)) + if appLinkName == "" { + return nil, errors.New("parameter appLinkName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkName}", url.PathEscape(appLinkName)) + if appLinkMemberName == "" { + return nil, errors.New("parameter appLinkMemberName cannot be empty") + } + urlPath = strings.ReplaceAll(urlPath, "{appLinkMemberName}", url.PathEscape(appLinkMemberName)) + req, err := runtime.NewRequest(ctx, http.MethodGet, runtime.JoinPaths(client.internal.Endpoint(), urlPath)) + if err != nil { + return nil, err + } + reqQP := req.Raw().URL.Query() + reqQP.Set("api-version", "2025-08-01-preview") + req.Raw().URL.RawQuery = reqQP.Encode() + req.Raw().Header["Accept"] = []string{"application/json"} + return req, nil +} + +// listByAppLinkMemberHandleResponse handles the ListByAppLinkMember response. +func (client *UpgradeHistoriesClient) listByAppLinkMemberHandleResponse(resp *http.Response) (UpgradeHistoriesClientListByAppLinkMemberResponse, error) { + result := UpgradeHistoriesClientListByAppLinkMemberResponse{} + if err := runtime.UnmarshalAsJSON(resp, &result.UpgradeHistoryListResult); err != nil { + return UpgradeHistoriesClientListByAppLinkMemberResponse{}, err + } + return result, nil +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/upgradehistories_client_example_test.go b/sdk/resourcemanager/appnetwork/armappnetwork/upgradehistories_client_example_test.go new file mode 100644 index 000000000000..fd0d29c1e210 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/upgradehistories_client_example_test.go @@ -0,0 +1,86 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. DO NOT EDIT. + +package armappnetwork_test + +import ( + "context" + "github.com/Azure/azure-sdk-for-go/sdk/azidentity" + "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appnetwork/armappnetwork" + "log" +) + +// Generated from example definition: 2025-08-01-preview/UpgradeHistories_ListByAppLinkMember.json +func ExampleUpgradeHistoriesClient_NewListByAppLinkMemberPager() { + cred, err := azidentity.NewDefaultAzureCredential(nil) + if err != nil { + log.Fatalf("failed to obtain a credential: %v", err) + } + ctx := context.Background() + clientFactory, err := armappnetwork.NewClientFactory("11809CA1-E126-4017-945E-AA795CD5C5A9", cred, nil) + if err != nil { + log.Fatalf("failed to create client: %v", err) + } + pager := clientFactory.NewUpgradeHistoriesClient().NewListByAppLinkMemberPager("test_rg", "applink-test-01", "member-01", 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 = armappnetwork.UpgradeHistoriesClientListByAppLinkMemberResponse{ + // UpgradeHistoryListResult: armappnetwork.UpgradeHistoryListResult{ + // Value: []*armappnetwork.UpgradeHistory{ + // { + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-01/appLinkMembers/member-01/upgradeHistories/upgrade-20231201"), + // Name: to.Ptr("upgrade-20231201"), + // Type: to.Ptr("Microsoft.AppLink/appLinks/appLinkMembers/upgradeHistories"), + // Properties: &armappnetwork.UpgradeHistoryProperties{ + // StartTimestamp: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-12-01T10:00:00.000Z"); return t}()), + // EndTimestamp: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-12-01T10:15:00.000Z"); return t}()), + // InitiatedBy: to.Ptr("user@example.com"), + // FromVersion: to.Ptr("1.18"), + // ToVersion: to.Ptr("1.19"), + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("system"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeApplication), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-12-01T10:00:00.000Z"); return t}()), + // LastModifiedBy: to.Ptr("system"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeApplication), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-12-01T10:15:00.000Z"); return t}()), + // }, + // }, + // { + // ID: to.Ptr("/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-01/appLinkMembers/member-01/upgradeHistories/upgrade-20231115"), + // Name: to.Ptr("upgrade-20231115"), + // Type: to.Ptr("Microsoft.AppLink/appLinks/appLinkMembers/upgradeHistories"), + // Properties: &armappnetwork.UpgradeHistoryProperties{ + // StartTimestamp: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-11-15T14:30:00.000Z"); return t}()), + // EndTimestamp: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-11-15T14:45:00.000Z"); return t}()), + // InitiatedBy: to.Ptr("Azure Portal"), + // FromVersion: to.Ptr("1.17"), + // ToVersion: to.Ptr("1.18"), + // ProvisioningState: to.Ptr(armappnetwork.ProvisioningStateSucceeded), + // }, + // SystemData: &armappnetwork.SystemData{ + // CreatedBy: to.Ptr("system"), + // CreatedByType: to.Ptr(armappnetwork.CreatedByTypeApplication), + // CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-11-15T14:30:00.000Z"); return t}()), + // LastModifiedBy: to.Ptr("system"), + // LastModifiedByType: to.Ptr(armappnetwork.CreatedByTypeApplication), + // LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-11-15T14:45:00.000Z"); return t}()), + // }, + // }, + // }, + // NextLink: to.Ptr("https://management.azure.com/subscriptions/11809CA1-E126-4017-945E-AA795CD5C5A9/resourceGroups/test_rg/providers/Microsoft.AppLink/appLinks/applink-test-01/appLinkMembers/member-01/upgradeHistories?api-version=2025-08-01-preview&$skiptoken=eyJjb250aW51YXRpb24iOiAiMjAyMzEwMDEifQ%3D%3D"), + // }, + // } + } +} diff --git a/sdk/resourcemanager/appnetwork/armappnetwork/version.go b/sdk/resourcemanager/appnetwork/armappnetwork/version.go new file mode 100644 index 000000000000..62fa3f3d4712 --- /dev/null +++ b/sdk/resourcemanager/appnetwork/armappnetwork/version.go @@ -0,0 +1,10 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. See License.txt in the project root for license information. +// Code generated by Microsoft (R) Go Code Generator. + +package armappnetwork + +const ( + moduleName = "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appnetwork/armappnetwork" + moduleVersion = "v0.1.0" +)