armsitemanager

package module
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Sep 29, 2025 License: MIT Imports: 14 Imported by: 0

README

Azure Site Manager Module for Go

The armsitemanager module provides operations for working with Azure Site Manager.

Source code

Getting started

Prerequisites

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

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Site Manager module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sitemanager/armsitemanager

Authorization

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

cred, err := azidentity.NewDefaultAzureCredential(nil)

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

Client Factory

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

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

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

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

Clients

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

client := clientFactory.NewSitesBySubscriptionClient()

Fakes

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

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

Provide Feedback

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

Contributing

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

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

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

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ClientFactory 

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

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

func NewClientFactory 

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

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

  • subscriptionID - 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 (*ClientFactory) NewSitesByServiceGroupClient 

func (c *ClientFactory) NewSitesByServiceGroupClient() *SitesByServiceGroupClient

NewSitesByServiceGroupClient creates a new instance of SitesByServiceGroupClient.

func (*ClientFactory) NewSitesBySubscriptionClient 

func (c *ClientFactory) NewSitesBySubscriptionClient() *SitesBySubscriptionClient

NewSitesBySubscriptionClient creates a new instance of SitesBySubscriptionClient.

func (*ClientFactory) NewSitesClient 

func (c *ClientFactory) NewSitesClient() *SitesClient

NewSitesClient creates a new instance of SitesClient.

type CreatedByType 

type CreatedByType string

CreatedByType - The kind of entity that created the resource. 

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"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type ResourceProvisioningState 

type ResourceProvisioningState string

ResourceProvisioningState - The provisioning state of a resource type. 

const (
	// ResourceProvisioningStateCanceled - Resource creation was canceled.
	ResourceProvisioningStateCanceled ResourceProvisioningState = "Canceled"
	// ResourceProvisioningStateFailed - Resource creation failed.
	ResourceProvisioningStateFailed ResourceProvisioningState = "Failed"
	// ResourceProvisioningStateSucceeded - Resource has been created.
	ResourceProvisioningStateSucceeded ResourceProvisioningState = "Succeeded"
)

func PossibleResourceProvisioningStateValues 

func PossibleResourceProvisioningStateValues() []ResourceProvisioningState

PossibleResourceProvisioningStateValues returns the possible values for the ResourceProvisioningState const type.

type Site 

type Site struct {
	// The resource-specific properties for this resource.
	Properties *SiteProperties

	// 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
}

Site as ARM Resource

func (Site) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Site.

func (*Site) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Site.

type SiteAddressProperties 

type SiteAddressProperties struct {
	// City of the address
	City *string

	// Country of the address
	Country *string

	// Postal or ZIP code of the address
	PostalCode *string

	// State or province of the address
	StateOrProvince *string

	// First line of the street address
	StreetAddress1 *string

	// Second line of the street address
	StreetAddress2 *string
}

SiteAddressProperties - Site address properties

func (SiteAddressProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SiteAddressProperties.

func (*SiteAddressProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SiteAddressProperties.

type SiteListResult 

type SiteListResult struct {
	// REQUIRED; The Site items on this page
	Value []*Site

	// The link to the next page of items
	NextLink *string
}

SiteListResult - The response of a Site list operation.

func (SiteListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SiteListResult.

func (*SiteListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SiteListResult.

type SiteProperties 

type SiteProperties struct {
	// Description of Site resource
	Description *string

	// displayName of Site resource
	DisplayName *string

	// Key-value pairs for labeling the site resource.
	Labels map[string]*string

	// Physical address of the site
	SiteAddress *SiteAddressProperties

	// READ-ONLY; Provisioning state of last operation
	ProvisioningState *ResourceProvisioningState
}

SiteProperties - Site properties

func (SiteProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SiteProperties.

func (*SiteProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SiteProperties.

type SiteUpdate 

type SiteUpdate struct {
	// The updatable properties of the Site.
	Properties *SiteUpdateProperties
}

SiteUpdate - The type used for update operations of the Site.

func (SiteUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SiteUpdate.

func (*SiteUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SiteUpdate.

type SiteUpdateProperties 

type SiteUpdateProperties struct {
	// Description of Site resource
	Description *string

	// displayName of Site resource
	DisplayName *string

	// Key-value pairs for labeling the site resource.
	Labels map[string]*string

	// Physical address of the site
	SiteAddress *SiteAddressProperties
}

SiteUpdateProperties - The updatable properties of the Site.

func (SiteUpdateProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SiteUpdateProperties.

func (*SiteUpdateProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SiteUpdateProperties.

type SitesByServiceGroupClient 

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

SitesByServiceGroupClient contains the methods for the SitesByServiceGroup group. Don't use this type directly, use NewSitesByServiceGroupClient() instead.

func NewSitesByServiceGroupClient 

func NewSitesByServiceGroupClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*SitesByServiceGroupClient, error)

NewSitesByServiceGroupClient creates a new instance of SitesByServiceGroupClient with the specified values.

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

func (*SitesByServiceGroupClient) BeginCreateOrUpdate 

func (client *SitesByServiceGroupClient) BeginCreateOrUpdate(ctx context.Context, servicegroupName string, siteName string, resource Site, options *SitesByServiceGroupClientBeginCreateOrUpdateOptions) (*runtime.Poller[SitesByServiceGroupClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - create or update Site at SG scope If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-06-01

  • servicegroupName - The name of the service group
  • siteName - The name of the site
  • resource - The properties of the site
  • options - SitesByServiceGroupClientBeginCreateOrUpdateOptions contains the optional parameters for the SitesByServiceGroupClient.BeginCreateOrUpdate method.
Example

Generated from example definition: 2025-06-01/SitesByServiceGroup_CreateOrUpdate_MaximumSet_Gen.json 

package main

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/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("<subscriptionID>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewSitesByServiceGroupClient().BeginCreateOrUpdate(ctx, "string", "string", armsitemanager.Site{
		Properties: &armsitemanager.SiteProperties{
			DisplayName: to.Ptr("string"),
			Labels: map[string]*string{
				"key8188": to.Ptr("mcgnu"),
			},
			Description: to.Ptr("enxcmpvfvadbapo"),
			SiteAddress: &armsitemanager.SiteAddressProperties{
				StreetAddress1:  to.Ptr("fodimymrxbhrfslsmzfhmitn"),
				StreetAddress2:  to.Ptr("widjg"),
				City:            to.Ptr("zkcbzjkatafo"),
				StateOrProvince: to.Ptr("wk"),
				Country:         to.Ptr("xeevcfvimlfzsfuxtyujw"),
				PostalCode:      to.Ptr("qbrhqk"),
			},
		},
	}, 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 = armsitemanager.SitesByServiceGroupClientCreateOrUpdateResponse{
	// 	Site: &armsitemanager.Site{
	// 		Properties: &armsitemanager.SiteProperties{
	// 			DisplayName: to.Ptr("string"),
	// 			Labels: map[string]*string{
	// 				"key8188": to.Ptr("mcgnu"),
	// 			},
	// 			Description: to.Ptr("enxcmpvfvadbapo"),
	// 			SiteAddress: &armsitemanager.SiteAddressProperties{
	// 				StreetAddress1: to.Ptr("fodimymrxbhrfslsmzfhmitn"),
	// 				StreetAddress2: to.Ptr("widjg"),
	// 				City: to.Ptr("zkcbzjkatafo"),
	// 				StateOrProvince: to.Ptr("wk"),
	// 				Country: to.Ptr("xeevcfvimlfzsfuxtyujw"),
	// 				PostalCode: to.Ptr("qbrhqk"),
	// 			},
	// 			ProvisioningState: to.Ptr(armsitemanager.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/providers/Microsoft.Management/serviceGroups/SGSites/providers/Microsoft.Edge/Sites/Rome"),
	// 		Name: to.Ptr("string"),
	// 		Type: to.Ptr("string"),
	// 		SystemData: &armsitemanager.SystemData{
	// 			CreatedBy: to.Ptr("julxbiyjzi"),
	// 			CreatedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("bceneuzzvzqmiocbrfef"),
	// 			LastModifiedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*SitesByServiceGroupClient) Delete 

func (client *SitesByServiceGroupClient) Delete(ctx context.Context, servicegroupName string, siteName string, options *SitesByServiceGroupClientDeleteOptions) (SitesByServiceGroupClientDeleteResponse, error)

Delete - delete Site at SG scope If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-06-01

  • servicegroupName - The name of the service group
  • siteName - The name of the site
  • options - SitesByServiceGroupClientDeleteOptions contains the optional parameters for the SitesByServiceGroupClient.Delete method.
Example

Generated from example definition: 2025-06-01/SitesByServiceGroup_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("<subscriptionID>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSitesByServiceGroupClient().Delete(ctx, "string", "string", 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 = armsitemanager.SitesByServiceGroupClientDeleteResponse{
	// }
}

func (*SitesByServiceGroupClient) Get 

func (client *SitesByServiceGroupClient) Get(ctx context.Context, servicegroupName string, siteName string, options *SitesByServiceGroupClientGetOptions) (SitesByServiceGroupClientGetResponse, error)

Get - Get Site at SG scope If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-06-01

  • servicegroupName - The name of the service group
  • siteName - The name of the site
  • options - SitesByServiceGroupClientGetOptions contains the optional parameters for the SitesByServiceGroupClient.Get method.
Example

Generated from example definition: 2025-06-01/SitesByServiceGroup_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("<subscriptionID>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSitesByServiceGroupClient().Get(ctx, "string", "string", 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 = armsitemanager.SitesByServiceGroupClientGetResponse{
	// 	Site: &armsitemanager.Site{
	// 		Properties: &armsitemanager.SiteProperties{
	// 			DisplayName: to.Ptr("string"),
	// 			Labels: map[string]*string{
	// 				"key8188": to.Ptr("mcgnu"),
	// 			},
	// 			Description: to.Ptr("enxcmpvfvadbapo"),
	// 			SiteAddress: &armsitemanager.SiteAddressProperties{
	// 				StreetAddress1: to.Ptr("fodimymrxbhrfslsmzfhmitn"),
	// 				StreetAddress2: to.Ptr("widjg"),
	// 				City: to.Ptr("zkcbzjkatafo"),
	// 				StateOrProvince: to.Ptr("wk"),
	// 				Country: to.Ptr("xeevcfvimlfzsfuxtyujw"),
	// 				PostalCode: to.Ptr("qbrhqk"),
	// 			},
	// 			ProvisioningState: to.Ptr(armsitemanager.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/providers/Microsoft.Management/serviceGroups/SGSites/providers/Microsoft.Edge/Sites/Rome"),
	// 		Name: to.Ptr("string"),
	// 		Type: to.Ptr("string"),
	// 		SystemData: &armsitemanager.SystemData{
	// 			CreatedBy: to.Ptr("julxbiyjzi"),
	// 			CreatedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("bceneuzzvzqmiocbrfef"),
	// 			LastModifiedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*SitesByServiceGroupClient) NewListByServiceGroupPager 

func (client *SitesByServiceGroupClient) NewListByServiceGroupPager(servicegroupName string, options *SitesByServiceGroupClientListByServiceGroupOptions) *runtime.Pager[SitesByServiceGroupClientListByServiceGroupResponse]

NewListByServiceGroupPager - list Site at SG scope

Generated from API version 2025-06-01

  • servicegroupName - The name of the service group
  • options - SitesByServiceGroupClientListByServiceGroupOptions contains the optional parameters for the SitesByServiceGroupClient.NewListByServiceGroupPager method.
Example

Generated from example definition: 2025-06-01/SitesByServiceGroup_ListByServiceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("<subscriptionID>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewSitesByServiceGroupClient().NewListByServiceGroupPager("string", 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 = armsitemanager.SitesByServiceGroupClientListByServiceGroupResponse{
		// 	SiteListResult: armsitemanager.SiteListResult{
		// 		Value: []*armsitemanager.Site{
		// 			{
		// 				Properties: &armsitemanager.SiteProperties{
		// 					DisplayName: to.Ptr("string"),
		// 					ProvisioningState: to.Ptr(armsitemanager.ResourceProvisioningStateSucceeded),
		// 					Description: to.Ptr("mazbpkzbkvvntk"),
		// 					SiteAddress: &armsitemanager.SiteAddressProperties{
		// 						StreetAddress1: to.Ptr("fodimymrxbhrfslsmzfhmitn"),
		// 						StreetAddress2: to.Ptr("widjg"),
		// 						City: to.Ptr("zkcbzjkatafo"),
		// 						StateOrProvince: to.Ptr("wk"),
		// 						Country: to.Ptr("xeevcfvimlfzsfuxtyujw"),
		// 						PostalCode: to.Ptr("qbrhqk"),
		// 					},
		// 					Labels: map[string]*string{
		// 						"key8188": to.Ptr("mcgnu"),
		// 					},
		// 				},
		// 				ID: to.Ptr("/providers/Microsoft.Management/serviceGroups/SGSites/providers/Microsoft.Edge/Sites/Rome"),
		// 				Name: to.Ptr("string"),
		// 				Type: to.Ptr("string"),
		// 				SystemData: &armsitemanager.SystemData{
		// 					CreatedBy: to.Ptr("julxbiyjzi"),
		// 					CreatedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("bceneuzzvzqmiocbrfef"),
		// 					LastModifiedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

func (*SitesByServiceGroupClient) Update 

func (client *SitesByServiceGroupClient) Update(ctx context.Context, servicegroupName string, siteName string, properties SiteUpdate, options *SitesByServiceGroupClientUpdateOptions) (SitesByServiceGroupClientUpdateResponse, error)

Update - update Site at SG scope If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-06-01

  • servicegroupName - The name of the service group
  • siteName - The name of the site
  • properties - The properties of the site
  • options - SitesByServiceGroupClientUpdateOptions contains the optional parameters for the SitesByServiceGroupClient.Update method.
Example

Generated from example definition: 2025-06-01/SitesByServiceGroup_Update_MaximumSet_Gen.json 

package main

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/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("<subscriptionID>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSitesByServiceGroupClient().Update(ctx, "string", "string", armsitemanager.SiteUpdate{
		Properties: &armsitemanager.SiteUpdateProperties{
			DisplayName: to.Ptr("string"),
			Description: to.Ptr("zztr"),
			SiteAddress: &armsitemanager.SiteAddressProperties{
				StreetAddress1:  to.Ptr("fodimymrxbhrfslsmzfhmitn"),
				StreetAddress2:  to.Ptr("widjg"),
				City:            to.Ptr("zkcbzjkatafo"),
				StateOrProvince: to.Ptr("wk"),
				Country:         to.Ptr("xeevcfvimlfzsfuxtyujw"),
				PostalCode:      to.Ptr("qbrhqk"),
			},
			Labels: map[string]*string{
				"key9939": to.Ptr("jdlzxcvcfqmruq"),
			},
		},
	}, 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 = armsitemanager.SitesByServiceGroupClientUpdateResponse{
	// 	Site: &armsitemanager.Site{
	// 		Properties: &armsitemanager.SiteProperties{
	// 			DisplayName: to.Ptr("string"),
	// 			Labels: map[string]*string{
	// 				"key8188": to.Ptr("mcgnu"),
	// 			},
	// 			Description: to.Ptr("enxcmpvfvadbapo"),
	// 			SiteAddress: &armsitemanager.SiteAddressProperties{
	// 				StreetAddress1: to.Ptr("fodimymrxbhrfslsmzfhmitn"),
	// 				StreetAddress2: to.Ptr("widjg"),
	// 				City: to.Ptr("zkcbzjkatafo"),
	// 				StateOrProvince: to.Ptr("wk"),
	// 				Country: to.Ptr("xeevcfvimlfzsfuxtyujw"),
	// 				PostalCode: to.Ptr("qbrhqk"),
	// 			},
	// 			ProvisioningState: to.Ptr(armsitemanager.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/providers/Microsoft.Management/serviceGroups/SGSites/providers/Microsoft.Edge/Sites/Rome"),
	// 		Name: to.Ptr("string"),
	// 		Type: to.Ptr("string"),
	// 		SystemData: &armsitemanager.SystemData{
	// 			CreatedBy: to.Ptr("julxbiyjzi"),
	// 			CreatedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("bceneuzzvzqmiocbrfef"),
	// 			LastModifiedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 		},
	// 	},
	// }
}

type SitesByServiceGroupClientBeginCreateOrUpdateOptions 

type SitesByServiceGroupClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

SitesByServiceGroupClientBeginCreateOrUpdateOptions contains the optional parameters for the SitesByServiceGroupClient.BeginCreateOrUpdate method.

type SitesByServiceGroupClientCreateOrUpdateResponse 

type SitesByServiceGroupClientCreateOrUpdateResponse struct {
	// Site as ARM Resource
	Site
}

SitesByServiceGroupClientCreateOrUpdateResponse contains the response from method SitesByServiceGroupClient.BeginCreateOrUpdate.

type SitesByServiceGroupClientDeleteOptions 

type SitesByServiceGroupClientDeleteOptions struct {
}

SitesByServiceGroupClientDeleteOptions contains the optional parameters for the SitesByServiceGroupClient.Delete method.

type SitesByServiceGroupClientDeleteResponse 

type SitesByServiceGroupClientDeleteResponse struct {
}

SitesByServiceGroupClientDeleteResponse contains the response from method SitesByServiceGroupClient.Delete.

type SitesByServiceGroupClientGetOptions 

type SitesByServiceGroupClientGetOptions struct {
}

SitesByServiceGroupClientGetOptions contains the optional parameters for the SitesByServiceGroupClient.Get method.

type SitesByServiceGroupClientGetResponse 

type SitesByServiceGroupClientGetResponse struct {
	// Site as ARM Resource
	Site
}

SitesByServiceGroupClientGetResponse contains the response from method SitesByServiceGroupClient.Get.

type SitesByServiceGroupClientListByServiceGroupOptions 

type SitesByServiceGroupClientListByServiceGroupOptions struct {
}

SitesByServiceGroupClientListByServiceGroupOptions contains the optional parameters for the SitesByServiceGroupClient.NewListByServiceGroupPager method.

type SitesByServiceGroupClientListByServiceGroupResponse 

type SitesByServiceGroupClientListByServiceGroupResponse struct {
	// The response of a Site list operation.
	SiteListResult
}

SitesByServiceGroupClientListByServiceGroupResponse contains the response from method SitesByServiceGroupClient.NewListByServiceGroupPager.

type SitesByServiceGroupClientUpdateOptions 

type SitesByServiceGroupClientUpdateOptions struct {
}

SitesByServiceGroupClientUpdateOptions contains the optional parameters for the SitesByServiceGroupClient.Update method.

type SitesByServiceGroupClientUpdateResponse 

type SitesByServiceGroupClientUpdateResponse struct {
	// Site as ARM Resource
	Site
}

SitesByServiceGroupClientUpdateResponse contains the response from method SitesByServiceGroupClient.Update.

type SitesBySubscriptionClient 

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

SitesBySubscriptionClient contains the methods for the SitesBySubscription group. Don't use this type directly, use NewSitesBySubscriptionClient() instead.

func NewSitesBySubscriptionClient 

func NewSitesBySubscriptionClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SitesBySubscriptionClient, error)

NewSitesBySubscriptionClient creates a new instance of SitesBySubscriptionClient 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 - pass nil to accept the default values.

func (*SitesBySubscriptionClient) BeginCreateOrUpdate 

func (client *SitesBySubscriptionClient) BeginCreateOrUpdate(ctx context.Context, siteName string, resource Site, options *SitesBySubscriptionClientBeginCreateOrUpdateOptions) (*runtime.Poller[SitesBySubscriptionClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a Site If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-06-01

  • siteName - Name of Site resource
  • resource - Resource create parameters.
  • options - SitesBySubscriptionClientBeginCreateOrUpdateOptions contains the optional parameters for the SitesBySubscriptionClient.BeginCreateOrUpdate method.
Example

Generated from example definition: 2025-06-01/SitesBySubscription_CreateOrUpdate_MaximumSet_Gen.json 

package main

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/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("0154f7fe-df09-4981-bf82-7ad5c1f596eb", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewSitesBySubscriptionClient().BeginCreateOrUpdate(ctx, "string", armsitemanager.Site{
		Properties: &armsitemanager.SiteProperties{
			DisplayName: to.Ptr("string"),
			Labels: map[string]*string{
				"key8188": to.Ptr("mcgnu"),
			},
			Description: to.Ptr("enxcmpvfvadbapo"),
			SiteAddress: &armsitemanager.SiteAddressProperties{
				StreetAddress1:  to.Ptr("fodimymrxbhrfslsmzfhmitn"),
				StreetAddress2:  to.Ptr("widjg"),
				City:            to.Ptr("zkcbzjkatafo"),
				StateOrProvince: to.Ptr("wk"),
				Country:         to.Ptr("xeevcfvimlfzsfuxtyujw"),
				PostalCode:      to.Ptr("qbrhqk"),
			},
		},
	}, 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 = armsitemanager.SitesBySubscriptionClientCreateOrUpdateResponse{
	// 	Site: &armsitemanager.Site{
	// 		Properties: &armsitemanager.SiteProperties{
	// 			DisplayName: to.Ptr("string"),
	// 			Labels: map[string]*string{
	// 				"key8188": to.Ptr("mcgnu"),
	// 			},
	// 			Description: to.Ptr("enxcmpvfvadbapo"),
	// 			SiteAddress: &armsitemanager.SiteAddressProperties{
	// 				StreetAddress1: to.Ptr("fodimymrxbhrfslsmzfhmitn"),
	// 				StreetAddress2: to.Ptr("widjg"),
	// 				City: to.Ptr("zkcbzjkatafo"),
	// 				StateOrProvince: to.Ptr("wk"),
	// 				Country: to.Ptr("xeevcfvimlfzsfuxtyujw"),
	// 				PostalCode: to.Ptr("qbrhqk"),
	// 			},
	// 			ProvisioningState: to.Ptr(armsitemanager.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/providers/Microsoft.Management/serviceGroups/SGSites/providers/Microsoft.Edge/Sites/Rome"),
	// 		Name: to.Ptr("string"),
	// 		Type: to.Ptr("string"),
	// 		SystemData: &armsitemanager.SystemData{
	// 			CreatedBy: to.Ptr("julxbiyjzi"),
	// 			CreatedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("bceneuzzvzqmiocbrfef"),
	// 			LastModifiedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*SitesBySubscriptionClient) Delete 

func (client *SitesBySubscriptionClient) Delete(ctx context.Context, siteName string, options *SitesBySubscriptionClientDeleteOptions) (SitesBySubscriptionClientDeleteResponse, error)

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

Generated from API version 2025-06-01

  • siteName - Name of Site resource
  • options - SitesBySubscriptionClientDeleteOptions contains the optional parameters for the SitesBySubscriptionClient.Delete method.
Example

Generated from example definition: 2025-06-01/SitesBySubscription_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("0154f7fe-df09-4981-bf82-7ad5c1f596eb", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSitesBySubscriptionClient().Delete(ctx, "string", 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 = armsitemanager.SitesBySubscriptionClientDeleteResponse{
	// }
}

func (*SitesBySubscriptionClient) Get 

func (client *SitesBySubscriptionClient) Get(ctx context.Context, siteName string, options *SitesBySubscriptionClientGetOptions) (SitesBySubscriptionClientGetResponse, error)

Get - Get a Site If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-06-01

  • siteName - Name of Site resource
  • options - SitesBySubscriptionClientGetOptions contains the optional parameters for the SitesBySubscriptionClient.Get method.
Example

Generated from example definition: 2025-06-01/SitesBySubscription_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("0154f7fe-df09-4981-bf82-7ad5c1f596eb", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSitesBySubscriptionClient().Get(ctx, "string", 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 = armsitemanager.SitesBySubscriptionClientGetResponse{
	// 	Site: &armsitemanager.Site{
	// 		Properties: &armsitemanager.SiteProperties{
	// 			DisplayName: to.Ptr("string"),
	// 			Labels: map[string]*string{
	// 				"key8188": to.Ptr("mcgnu"),
	// 			},
	// 			Description: to.Ptr("enxcmpvfvadbapo"),
	// 			SiteAddress: &armsitemanager.SiteAddressProperties{
	// 				StreetAddress1: to.Ptr("fodimymrxbhrfslsmzfhmitn"),
	// 				StreetAddress2: to.Ptr("widjg"),
	// 				City: to.Ptr("zkcbzjkatafo"),
	// 				StateOrProvince: to.Ptr("wk"),
	// 				Country: to.Ptr("xeevcfvimlfzsfuxtyujw"),
	// 				PostalCode: to.Ptr("qbrhqk"),
	// 			},
	// 			ProvisioningState: to.Ptr(armsitemanager.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/providers/Microsoft.Management/serviceGroups/SGSites/providers/Microsoft.Edge/Sites/Rome"),
	// 		Name: to.Ptr("string"),
	// 		Type: to.Ptr("string"),
	// 		SystemData: &armsitemanager.SystemData{
	// 			CreatedBy: to.Ptr("julxbiyjzi"),
	// 			CreatedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("bceneuzzvzqmiocbrfef"),
	// 			LastModifiedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*SitesBySubscriptionClient) NewListPager 

func (client *SitesBySubscriptionClient) NewListPager(options *SitesBySubscriptionClientListOptions) *runtime.Pager[SitesBySubscriptionClientListResponse]

NewListPager - List Site resources by subscription ID

Generated from API version 2025-06-01

  • options - SitesBySubscriptionClientListOptions contains the optional parameters for the SitesBySubscriptionClient.NewListPager method.
Example

Generated from example definition: 2025-06-01/SitesBySubscription_List_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("0154f7fe-df09-4981-bf82-7ad5c1f596eb", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewSitesBySubscriptionClient().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 = armsitemanager.SitesBySubscriptionClientListResponse{
		// 	SiteListResult: armsitemanager.SiteListResult{
		// 		Value: []*armsitemanager.Site{
		// 			{
		// 				Properties: &armsitemanager.SiteProperties{
		// 					DisplayName: to.Ptr("string"),
		// 					ProvisioningState: to.Ptr(armsitemanager.ResourceProvisioningStateSucceeded),
		// 					Description: to.Ptr("mazbpkzbkvvntk"),
		// 					SiteAddress: &armsitemanager.SiteAddressProperties{
		// 						StreetAddress1: to.Ptr("fodimymrxbhrfslsmzfhmitn"),
		// 						StreetAddress2: to.Ptr("widjg"),
		// 						City: to.Ptr("zkcbzjkatafo"),
		// 						StateOrProvince: to.Ptr("wk"),
		// 						Country: to.Ptr("xeevcfvimlfzsfuxtyujw"),
		// 						PostalCode: to.Ptr("qbrhqk"),
		// 					},
		// 					Labels: map[string]*string{
		// 						"key8188": to.Ptr("mcgnu"),
		// 					},
		// 				},
		// 				ID: to.Ptr("/providers/Microsoft.Management/serviceGroups/SGSites/providers/Microsoft.Edge/Sites/Rome"),
		// 				Name: to.Ptr("string"),
		// 				Type: to.Ptr("string"),
		// 				SystemData: &armsitemanager.SystemData{
		// 					CreatedBy: to.Ptr("julxbiyjzi"),
		// 					CreatedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("bceneuzzvzqmiocbrfef"),
		// 					LastModifiedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

func (*SitesBySubscriptionClient) Update 

func (client *SitesBySubscriptionClient) Update(ctx context.Context, siteName string, properties SiteUpdate, options *SitesBySubscriptionClientUpdateOptions) (SitesBySubscriptionClientUpdateResponse, error)

Update - Update a Site If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-06-01

  • siteName - Name of Site resource
  • properties - The resource properties to be updated.
  • options - SitesBySubscriptionClientUpdateOptions contains the optional parameters for the SitesBySubscriptionClient.Update method.
Example

Generated from example definition: 2025-06-01/SitesBySubscription_Update_MaximumSet_Gen.json 

package main

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/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("0154f7fe-df09-4981-bf82-7ad5c1f596eb", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSitesBySubscriptionClient().Update(ctx, "string", armsitemanager.SiteUpdate{
		Properties: &armsitemanager.SiteUpdateProperties{
			DisplayName: to.Ptr("string"),
			Description: to.Ptr("zztr"),
			SiteAddress: &armsitemanager.SiteAddressProperties{
				StreetAddress1:  to.Ptr("fodimymrxbhrfslsmzfhmitn"),
				StreetAddress2:  to.Ptr("widjg"),
				City:            to.Ptr("zkcbzjkatafo"),
				StateOrProvince: to.Ptr("wk"),
				Country:         to.Ptr("xeevcfvimlfzsfuxtyujw"),
				PostalCode:      to.Ptr("qbrhqk"),
			},
			Labels: map[string]*string{
				"key9939": to.Ptr("jdlzxcvcfqmruq"),
			},
		},
	}, 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 = armsitemanager.SitesBySubscriptionClientUpdateResponse{
	// 	Site: &armsitemanager.Site{
	// 		Properties: &armsitemanager.SiteProperties{
	// 			DisplayName: to.Ptr("string"),
	// 			Labels: map[string]*string{
	// 				"key8188": to.Ptr("mcgnu"),
	// 			},
	// 			Description: to.Ptr("enxcmpvfvadbapo"),
	// 			SiteAddress: &armsitemanager.SiteAddressProperties{
	// 				StreetAddress1: to.Ptr("fodimymrxbhrfslsmzfhmitn"),
	// 				StreetAddress2: to.Ptr("widjg"),
	// 				City: to.Ptr("zkcbzjkatafo"),
	// 				StateOrProvince: to.Ptr("wk"),
	// 				Country: to.Ptr("xeevcfvimlfzsfuxtyujw"),
	// 				PostalCode: to.Ptr("qbrhqk"),
	// 			},
	// 			ProvisioningState: to.Ptr(armsitemanager.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/providers/Microsoft.Management/serviceGroups/SGSites/providers/Microsoft.Edge/Sites/Rome"),
	// 		Name: to.Ptr("string"),
	// 		Type: to.Ptr("string"),
	// 		SystemData: &armsitemanager.SystemData{
	// 			CreatedBy: to.Ptr("julxbiyjzi"),
	// 			CreatedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("bceneuzzvzqmiocbrfef"),
	// 			LastModifiedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 		},
	// 	},
	// }
}

type SitesBySubscriptionClientBeginCreateOrUpdateOptions 

type SitesBySubscriptionClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

SitesBySubscriptionClientBeginCreateOrUpdateOptions contains the optional parameters for the SitesBySubscriptionClient.BeginCreateOrUpdate method.

type SitesBySubscriptionClientCreateOrUpdateResponse 

type SitesBySubscriptionClientCreateOrUpdateResponse struct {
	// Site as ARM Resource
	Site
}

SitesBySubscriptionClientCreateOrUpdateResponse contains the response from method SitesBySubscriptionClient.BeginCreateOrUpdate.

type SitesBySubscriptionClientDeleteOptions 

type SitesBySubscriptionClientDeleteOptions struct {
}

SitesBySubscriptionClientDeleteOptions contains the optional parameters for the SitesBySubscriptionClient.Delete method.

type SitesBySubscriptionClientDeleteResponse 

type SitesBySubscriptionClientDeleteResponse struct {
}

SitesBySubscriptionClientDeleteResponse contains the response from method SitesBySubscriptionClient.Delete.

type SitesBySubscriptionClientGetOptions 

type SitesBySubscriptionClientGetOptions struct {
}

SitesBySubscriptionClientGetOptions contains the optional parameters for the SitesBySubscriptionClient.Get method.

type SitesBySubscriptionClientGetResponse 

type SitesBySubscriptionClientGetResponse struct {
	// Site as ARM Resource
	Site
}

SitesBySubscriptionClientGetResponse contains the response from method SitesBySubscriptionClient.Get.

type SitesBySubscriptionClientListOptions 

type SitesBySubscriptionClientListOptions struct {
}

SitesBySubscriptionClientListOptions contains the optional parameters for the SitesBySubscriptionClient.NewListPager method.

type SitesBySubscriptionClientListResponse 

type SitesBySubscriptionClientListResponse struct {
	// The response of a Site list operation.
	SiteListResult
}

SitesBySubscriptionClientListResponse contains the response from method SitesBySubscriptionClient.NewListPager.

type SitesBySubscriptionClientUpdateOptions 

type SitesBySubscriptionClientUpdateOptions struct {
}

SitesBySubscriptionClientUpdateOptions contains the optional parameters for the SitesBySubscriptionClient.Update method.

type SitesBySubscriptionClientUpdateResponse 

type SitesBySubscriptionClientUpdateResponse struct {
	// Site as ARM Resource
	Site
}

SitesBySubscriptionClientUpdateResponse contains the response from method SitesBySubscriptionClient.Update.

type SitesClient 

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

SitesClient contains the methods for the Sites group. Don't use this type directly, use NewSitesClient() instead.

func NewSitesClient 

func NewSitesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SitesClient, error)

NewSitesClient creates a new instance of SitesClient 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 - pass nil to accept the default values.

func (*SitesClient) BeginCreateOrUpdate 

func (client *SitesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, siteName string, resource Site, options *SitesClientBeginCreateOrUpdateOptions) (*runtime.Poller[SitesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a Site If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-06-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • siteName - Name of Site resource
  • resource - Resource create parameters.
  • options - SitesClientBeginCreateOrUpdateOptions contains the optional parameters for the SitesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: 2025-06-01/Sites_CreateOrUpdate_MaximumSet_Gen.json 

package main

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/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("0154f7fe-df09-4981-bf82-7ad5c1f596eb", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewSitesClient().BeginCreateOrUpdate(ctx, "rgsites", "string", armsitemanager.Site{
		Properties: &armsitemanager.SiteProperties{
			DisplayName: to.Ptr("string"),
			Labels: map[string]*string{
				"key8188": to.Ptr("mcgnu"),
			},
			Description: to.Ptr("enxcmpvfvadbapo"),
			SiteAddress: &armsitemanager.SiteAddressProperties{
				StreetAddress1:  to.Ptr("fodimymrxbhrfslsmzfhmitn"),
				StreetAddress2:  to.Ptr("widjg"),
				City:            to.Ptr("zkcbzjkatafo"),
				StateOrProvince: to.Ptr("wk"),
				Country:         to.Ptr("xeevcfvimlfzsfuxtyujw"),
				PostalCode:      to.Ptr("qbrhqk"),
			},
		},
	}, 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 = armsitemanager.SitesClientCreateOrUpdateResponse{
	// 	Site: &armsitemanager.Site{
	// 		Properties: &armsitemanager.SiteProperties{
	// 			DisplayName: to.Ptr("string"),
	// 			Labels: map[string]*string{
	// 				"key8188": to.Ptr("mcgnu"),
	// 			},
	// 			Description: to.Ptr("enxcmpvfvadbapo"),
	// 			SiteAddress: &armsitemanager.SiteAddressProperties{
	// 				StreetAddress1: to.Ptr("fodimymrxbhrfslsmzfhmitn"),
	// 				StreetAddress2: to.Ptr("widjg"),
	// 				City: to.Ptr("zkcbzjkatafo"),
	// 				StateOrProvince: to.Ptr("wk"),
	// 				Country: to.Ptr("xeevcfvimlfzsfuxtyujw"),
	// 				PostalCode: to.Ptr("qbrhqk"),
	// 			},
	// 			ProvisioningState: to.Ptr(armsitemanager.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/providers/Microsoft.Management/serviceGroups/SGSites/providers/Microsoft.Edge/Sites/Rome"),
	// 		Name: to.Ptr("string"),
	// 		Type: to.Ptr("string"),
	// 		SystemData: &armsitemanager.SystemData{
	// 			CreatedBy: to.Ptr("julxbiyjzi"),
	// 			CreatedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("bceneuzzvzqmiocbrfef"),
	// 			LastModifiedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*SitesClient) Delete 

func (client *SitesClient) Delete(ctx context.Context, resourceGroupName string, siteName string, options *SitesClientDeleteOptions) (SitesClientDeleteResponse, error)

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

Generated from API version 2025-06-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • siteName - Name of Site resource
  • options - SitesClientDeleteOptions contains the optional parameters for the SitesClient.Delete method.
Example

Generated from example definition: 2025-06-01/Sites_Delete_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("0154f7fe-df09-4981-bf82-7ad5c1f596eb", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSitesClient().Delete(ctx, "rgsites", "string", 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 = armsitemanager.SitesClientDeleteResponse{
	// }
}

func (*SitesClient) Get 

func (client *SitesClient) Get(ctx context.Context, resourceGroupName string, siteName string, options *SitesClientGetOptions) (SitesClientGetResponse, error)

Get - Get a Site If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-06-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • siteName - Name of Site resource
  • options - SitesClientGetOptions contains the optional parameters for the SitesClient.Get method.
Example

Generated from example definition: 2025-06-01/Sites_Get_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("0154f7fe-df09-4981-bf82-7ad5c1f596eb", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSitesClient().Get(ctx, "rgsites", "string", 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 = armsitemanager.SitesClientGetResponse{
	// 	Site: &armsitemanager.Site{
	// 		Properties: &armsitemanager.SiteProperties{
	// 			DisplayName: to.Ptr("string"),
	// 			Labels: map[string]*string{
	// 				"key8188": to.Ptr("mcgnu"),
	// 			},
	// 			Description: to.Ptr("enxcmpvfvadbapo"),
	// 			SiteAddress: &armsitemanager.SiteAddressProperties{
	// 				StreetAddress1: to.Ptr("fodimymrxbhrfslsmzfhmitn"),
	// 				StreetAddress2: to.Ptr("widjg"),
	// 				City: to.Ptr("zkcbzjkatafo"),
	// 				StateOrProvince: to.Ptr("wk"),
	// 				Country: to.Ptr("xeevcfvimlfzsfuxtyujw"),
	// 				PostalCode: to.Ptr("qbrhqk"),
	// 			},
	// 			ProvisioningState: to.Ptr(armsitemanager.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/providers/Microsoft.Management/serviceGroups/SGSites/providers/Microsoft.Edge/Sites/Rome"),
	// 		Name: to.Ptr("string"),
	// 		Type: to.Ptr("string"),
	// 		SystemData: &armsitemanager.SystemData{
	// 			CreatedBy: to.Ptr("julxbiyjzi"),
	// 			CreatedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("bceneuzzvzqmiocbrfef"),
	// 			LastModifiedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*SitesClient) NewListByResourceGroupPager 

func (client *SitesClient) NewListByResourceGroupPager(resourceGroupName string, options *SitesClientListByResourceGroupOptions) *runtime.Pager[SitesClientListByResourceGroupResponse]

NewListByResourceGroupPager - List Site resources by resource group

Generated from API version 2025-06-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - SitesClientListByResourceGroupOptions contains the optional parameters for the SitesClient.NewListByResourceGroupPager method.
Example

Generated from example definition: 2025-06-01/Sites_ListByResourceGroup_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("0154f7fe-df09-4981-bf82-7ad5c1f596eb", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewSitesClient().NewListByResourceGroupPager("rgsites", 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 = armsitemanager.SitesClientListByResourceGroupResponse{
		// 	SiteListResult: armsitemanager.SiteListResult{
		// 		Value: []*armsitemanager.Site{
		// 			{
		// 				Properties: &armsitemanager.SiteProperties{
		// 					DisplayName: to.Ptr("string"),
		// 					ProvisioningState: to.Ptr(armsitemanager.ResourceProvisioningStateSucceeded),
		// 					Description: to.Ptr("mazbpkzbkvvntk"),
		// 					SiteAddress: &armsitemanager.SiteAddressProperties{
		// 						StreetAddress1: to.Ptr("fodimymrxbhrfslsmzfhmitn"),
		// 						StreetAddress2: to.Ptr("widjg"),
		// 						City: to.Ptr("zkcbzjkatafo"),
		// 						StateOrProvince: to.Ptr("wk"),
		// 						Country: to.Ptr("xeevcfvimlfzsfuxtyujw"),
		// 						PostalCode: to.Ptr("qbrhqk"),
		// 					},
		// 					Labels: map[string]*string{
		// 						"key8188": to.Ptr("mcgnu"),
		// 					},
		// 				},
		// 				ID: to.Ptr("/providers/Microsoft.Management/serviceGroups/SGSites/providers/Microsoft.Edge/Sites/Rome"),
		// 				Name: to.Ptr("string"),
		// 				Type: to.Ptr("string"),
		// 				SystemData: &armsitemanager.SystemData{
		// 					CreatedBy: to.Ptr("julxbiyjzi"),
		// 					CreatedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("bceneuzzvzqmiocbrfef"),
		// 					LastModifiedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

func (*SitesClient) Update 

func (client *SitesClient) Update(ctx context.Context, resourceGroupName string, siteName string, properties SiteUpdate, options *SitesClientUpdateOptions) (SitesClientUpdateResponse, error)

Update - Update a Site If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-06-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • siteName - Name of Site resource
  • properties - The resource properties to be updated.
  • options - SitesClientUpdateOptions contains the optional parameters for the SitesClient.Update method.
Example

Generated from example definition: 2025-06-01/Sites_Update_MaximumSet_Gen.json 

package main

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/sitemanager/armsitemanager"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armsitemanager.NewClientFactory("0154f7fe-df09-4981-bf82-7ad5c1f596eb", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewSitesClient().Update(ctx, "rgsites", "string", armsitemanager.SiteUpdate{
		Properties: &armsitemanager.SiteUpdateProperties{
			DisplayName: to.Ptr("string"),
			Description: to.Ptr("zztr"),
			SiteAddress: &armsitemanager.SiteAddressProperties{
				StreetAddress1:  to.Ptr("fodimymrxbhrfslsmzfhmitn"),
				StreetAddress2:  to.Ptr("widjg"),
				City:            to.Ptr("zkcbzjkatafo"),
				StateOrProvince: to.Ptr("wk"),
				Country:         to.Ptr("xeevcfvimlfzsfuxtyujw"),
				PostalCode:      to.Ptr("qbrhqk"),
			},
			Labels: map[string]*string{
				"key9939": to.Ptr("jdlzxcvcfqmruq"),
			},
		},
	}, 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 = armsitemanager.SitesClientUpdateResponse{
	// 	Site: &armsitemanager.Site{
	// 		Properties: &armsitemanager.SiteProperties{
	// 			DisplayName: to.Ptr("string"),
	// 			Labels: map[string]*string{
	// 				"key8188": to.Ptr("mcgnu"),
	// 			},
	// 			Description: to.Ptr("enxcmpvfvadbapo"),
	// 			SiteAddress: &armsitemanager.SiteAddressProperties{
	// 				StreetAddress1: to.Ptr("fodimymrxbhrfslsmzfhmitn"),
	// 				StreetAddress2: to.Ptr("widjg"),
	// 				City: to.Ptr("zkcbzjkatafo"),
	// 				StateOrProvince: to.Ptr("wk"),
	// 				Country: to.Ptr("xeevcfvimlfzsfuxtyujw"),
	// 				PostalCode: to.Ptr("qbrhqk"),
	// 			},
	// 			ProvisioningState: to.Ptr(armsitemanager.ResourceProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/providers/Microsoft.Management/serviceGroups/SGSites/providers/Microsoft.Edge/Sites/Rome"),
	// 		Name: to.Ptr("string"),
	// 		Type: to.Ptr("string"),
	// 		SystemData: &armsitemanager.SystemData{
	// 			CreatedBy: to.Ptr("julxbiyjzi"),
	// 			CreatedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("bceneuzzvzqmiocbrfef"),
	// 			LastModifiedByType: to.Ptr(armsitemanager.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-12-30T07:53:03.972Z"); return t}()),
	// 		},
	// 	},
	// }
}

type SitesClientBeginCreateOrUpdateOptions 

type SitesClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

SitesClientBeginCreateOrUpdateOptions contains the optional parameters for the SitesClient.BeginCreateOrUpdate method.

type SitesClientCreateOrUpdateResponse 

type SitesClientCreateOrUpdateResponse struct {
	// Site as ARM Resource
	Site
}

SitesClientCreateOrUpdateResponse contains the response from method SitesClient.BeginCreateOrUpdate.

type SitesClientDeleteOptions 

type SitesClientDeleteOptions struct {
}

SitesClientDeleteOptions contains the optional parameters for the SitesClient.Delete method.

type SitesClientDeleteResponse 

type SitesClientDeleteResponse struct {
}

SitesClientDeleteResponse contains the response from method SitesClient.Delete.

type SitesClientGetOptions 

type SitesClientGetOptions struct {
}

SitesClientGetOptions contains the optional parameters for the SitesClient.Get method.

type SitesClientGetResponse 

type SitesClientGetResponse struct {
	// Site as ARM Resource
	Site
}

SitesClientGetResponse contains the response from method SitesClient.Get.

type SitesClientListByResourceGroupOptions 

type SitesClientListByResourceGroupOptions struct {
}

SitesClientListByResourceGroupOptions contains the optional parameters for the SitesClient.NewListByResourceGroupPager method.

type SitesClientListByResourceGroupResponse 

type SitesClientListByResourceGroupResponse struct {
	// The response of a Site list operation.
	SiteListResult
}

SitesClientListByResourceGroupResponse contains the response from method SitesClient.NewListByResourceGroupPager.

type SitesClientUpdateOptions 

type SitesClientUpdateOptions struct {
}

SitesClientUpdateOptions contains the optional parameters for the SitesClient.Update method.

type SitesClientUpdateResponse 

type SitesClientUpdateResponse struct {
	// Site as ARM Resource
	Site
}

SitesClientUpdateResponse contains the response from method SitesClient.Update.

type SystemData 

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

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

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

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

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

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

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

func (SystemData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.