armmobilenetwork

package module
v2.1.1 Latest Latest
Warning

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

 Go to latest Published: Apr 14, 2023 License: MIT Imports: 14 Imported by: 1

README

Azure Private 5G Core Module for Go

PkgGoDev

The armmobilenetwork module provides operations for working with Azure Private 5G Core.

Source code

Getting started

Prerequisites

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

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Private 5G Core module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mobilenetwork/armmobilenetwork

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Private 5G Core. 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 Private 5G Core 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 := armmobilenetwork.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 := armmobilenetwork.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.NewMobileNetworksClient()

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Private 5G Core 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 Ambr 

type Ambr struct {
	// REQUIRED; Downlink bit rate.
	Downlink *string

	// REQUIRED; Uplink bit rate.
	Uplink *string
}

Ambr - Aggregate maximum bit rate.

func (Ambr) MarshalJSON 

func (a Ambr) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Ambr.

func (*Ambr) UnmarshalJSON 

func (a *Ambr) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Ambr.

type Arp 

type Arp struct {
	// REQUIRED; ARP preemption capability.
	PreemptCap *PreemptionCapability

	// REQUIRED; ARP preemption vulnerability
	PreemptVuln *PreemptionVulnerability

	// REQUIRED; ARP priority level.
	PriorityLevel *int32
}

Arp - Allocation and Retention Priority (ARP) parameters.

func (Arp) MarshalJSON 

func (a Arp) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Arp.

func (*Arp) UnmarshalJSON 

func (a *Arp) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Arp.

type AsyncOperationID 

type AsyncOperationID struct {
	// REQUIRED; Azure Async Operation ID.
	ID *string
}

AsyncOperationID - Reference to an Azure Async Operation ID.

func (AsyncOperationID) MarshalJSON 

func (a AsyncOperationID) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AsyncOperationID.

func (*AsyncOperationID) UnmarshalJSON 

func (a *AsyncOperationID) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AsyncOperationID.

type AsyncOperationStatus 

type AsyncOperationStatus struct {
	// REQUIRED; The operation status.
	Status *string

	// The end time of the operation.
	EndTime *time.Time

	// If present, details of the operation error.
	Error *ErrorDetail

	// Fully qualified ID for the async operation.
	ID *string

	// Name of the async operation.
	Name *string

	// Percentage of the operation that is complete.
	PercentComplete *float64

	// Properties returned by the resource provider on a successful operation
	Properties any

	// Fully qualified ID for the resource that this async operation status relates to.
	ResourceID *string

	// The start time of the operation.
	StartTime *time.Time
}

AsyncOperationStatus - The current status of an async operation.

func (AsyncOperationStatus) MarshalJSON 

func (a AsyncOperationStatus) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AsyncOperationStatus.

func (*AsyncOperationStatus) UnmarshalJSON 

func (a *AsyncOperationStatus) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AsyncOperationStatus.

type AttachedDataNetwork 

type AttachedDataNetwork struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Attached data network properties.
	Properties *AttachedDataNetworkPropertiesFormat

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

AttachedDataNetwork - Attached data network resource. Must be created in the same location as its parent packet core data plane.

func (AttachedDataNetwork) MarshalJSON 

func (a AttachedDataNetwork) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AttachedDataNetwork.

func (*AttachedDataNetwork) UnmarshalJSON 

func (a *AttachedDataNetwork) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AttachedDataNetwork.

type AttachedDataNetworkListResult 

type AttachedDataNetworkListResult struct {
	// A list of data networks in a resource group.
	Value []*AttachedDataNetwork

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

AttachedDataNetworkListResult - Response for attached data network API service call.

func (AttachedDataNetworkListResult) MarshalJSON 

func (a AttachedDataNetworkListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AttachedDataNetworkListResult.

func (*AttachedDataNetworkListResult) UnmarshalJSON 

func (a *AttachedDataNetworkListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AttachedDataNetworkListResult.

type AttachedDataNetworkPropertiesFormat 

type AttachedDataNetworkPropertiesFormat struct {
	// REQUIRED; The DNS servers to signal to UEs to use for this attached data network. This configuration is mandatory - if
	// you don't want DNS servers, you must provide an empty array.
	DNSAddresses []*string

	// REQUIRED; The user plane interface on the data network. For 5G networks, this is the N6 interface. For 4G networks, this
	// is the SGi interface.
	UserPlaneDataInterface *InterfaceProperties

	// The network address and port translation (NAPT) configuration. If this is not specified, the attached data network will
	// use a default NAPT configuration with NAPT enabled.
	NaptConfiguration *NaptConfiguration

	// The user equipment (UE) address pool prefixes for the attached data network from which the packet core instance will dynamically
	// assign IP addresses to UEs. The packet core instance assigns an IP
	// address to a UE when the UE sets up a PDU session. You must define at least one of userEquipmentAddressPoolPrefix and userEquipmentStaticAddressPoolPrefix.
	// If you define both, they must be of the same
	// size.
	UserEquipmentAddressPoolPrefix []*string

	// The user equipment (UE) address pool prefixes for the attached data network from which the packet core instance will assign
	// static IP addresses to UEs. The packet core instance assigns an IP address
	// to a UE when the UE sets up a PDU session. The static IP address for a specific UE is set in StaticIPConfiguration on the
	// corresponding SIM resource. At least one of userEquipmentAddressPoolPrefix and
	// userEquipmentStaticAddressPoolPrefix must be defined. If both are defined, they must be of the same size.
	UserEquipmentStaticAddressPoolPrefix []*string

	// READ-ONLY; The provisioning state of the attached data network resource.
	ProvisioningState *ProvisioningState
}

AttachedDataNetworkPropertiesFormat - Data network properties.

func (AttachedDataNetworkPropertiesFormat) MarshalJSON 

func (a AttachedDataNetworkPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AttachedDataNetworkPropertiesFormat.

func (*AttachedDataNetworkPropertiesFormat) UnmarshalJSON 

func (a *AttachedDataNetworkPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AttachedDataNetworkPropertiesFormat.

type AttachedDataNetworkResourceID 

type AttachedDataNetworkResourceID struct {
	// REQUIRED; Attached data network resource ID.
	ID *string
}

AttachedDataNetworkResourceID - Reference to an attached data network resource.

func (AttachedDataNetworkResourceID) MarshalJSON 

func (a AttachedDataNetworkResourceID) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AttachedDataNetworkResourceID.

func (*AttachedDataNetworkResourceID) UnmarshalJSON 

func (a *AttachedDataNetworkResourceID) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AttachedDataNetworkResourceID.

type AttachedDataNetworksClient 

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

AttachedDataNetworksClient contains the methods for the AttachedDataNetworks group. Don't use this type directly, use NewAttachedDataNetworksClient() instead.

func NewAttachedDataNetworksClient 

func NewAttachedDataNetworksClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AttachedDataNetworksClient, error)

NewAttachedDataNetworksClient creates a new instance of AttachedDataNetworksClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AttachedDataNetworksClient) BeginCreateOrUpdate 

func (client *AttachedDataNetworksClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, packetCoreDataPlaneName string, attachedDataNetworkName string, parameters AttachedDataNetwork, options *AttachedDataNetworksClientBeginCreateOrUpdateOptions) (*runtime.Poller[AttachedDataNetworksClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates an attached data network. Must be created in the same location as its parent packet core data plane. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • packetCoreDataPlaneName - The name of the packet core data plane.
  • attachedDataNetworkName - The name of the attached data network.
  • parameters - Parameters supplied to the create or update attached data network operation.
  • options - AttachedDataNetworksClientBeginCreateOrUpdateOptions contains the optional parameters for the AttachedDataNetworksClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/AttachedDataNetworkCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAttachedDataNetworksClient().BeginCreateOrUpdate(ctx, "rg1", "TestPacketCoreCP", "TestPacketCoreDP", "TestAttachedDataNetwork", armmobilenetwork.AttachedDataNetwork{
	Location: to.Ptr("eastus"),
	Properties: &armmobilenetwork.AttachedDataNetworkPropertiesFormat{
		DNSAddresses: []*string{
			to.Ptr("1.1.1.1")},
		NaptConfiguration: &armmobilenetwork.NaptConfiguration{
			Enabled:       to.Ptr(armmobilenetwork.NaptEnabledEnabled),
			PinholeLimits: to.Ptr[int32](65536),
			PinholeTimeouts: &armmobilenetwork.PinholeTimeouts{
				Icmp: to.Ptr[int32](30),
				TCP:  to.Ptr[int32](180),
				UDP:  to.Ptr[int32](30),
			},
			PortRange: &armmobilenetwork.PortRange{
				MaxPort: to.Ptr[int32](49999),
				MinPort: to.Ptr[int32](1024),
			},
			PortReuseHoldTime: &armmobilenetwork.PortReuseHoldTimes{
				TCP: to.Ptr[int32](120),
				UDP: to.Ptr[int32](60),
			},
		},
		UserEquipmentAddressPoolPrefix: []*string{
			to.Ptr("2.2.0.0/16")},
		UserEquipmentStaticAddressPoolPrefix: []*string{
			to.Ptr("2.4.0.0/16")},
		UserPlaneDataInterface: &armmobilenetwork.InterfaceProperties{
			Name: to.Ptr("N6"),
		},
	},
}, 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.AttachedDataNetwork = armmobilenetwork.AttachedDataNetwork{
// 	Name: to.Ptr("TestAttachedDataNetwork"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/attachedDataNetwork"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.AttachedDataNetworkPropertiesFormat{
// 		DNSAddresses: []*string{
// 			to.Ptr("1.1.1.1")},
// 			NaptConfiguration: &armmobilenetwork.NaptConfiguration{
// 				Enabled: to.Ptr(armmobilenetwork.NaptEnabledEnabled),
// 				PinholeLimits: to.Ptr[int32](65536),
// 				PinholeTimeouts: &armmobilenetwork.PinholeTimeouts{
// 					Icmp: to.Ptr[int32](30),
// 					TCP: to.Ptr[int32](180),
// 					UDP: to.Ptr[int32](30),
// 				},
// 				PortRange: &armmobilenetwork.PortRange{
// 					MaxPort: to.Ptr[int32](49999),
// 					MinPort: to.Ptr[int32](1024),
// 				},
// 				PortReuseHoldTime: &armmobilenetwork.PortReuseHoldTimes{
// 					TCP: to.Ptr[int32](120),
// 					UDP: to.Ptr[int32](60),
// 				},
// 			},
// 			ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 			UserEquipmentAddressPoolPrefix: []*string{
// 				to.Ptr("2.2.0.0/16")},
// 				UserEquipmentStaticAddressPoolPrefix: []*string{
// 					to.Ptr("2.4.0.0/16")},
// 					UserPlaneDataInterface: &armmobilenetwork.InterfaceProperties{
// 						Name: to.Ptr("N6"),
// 					},
// 				},
// 			}

Output:

func (*AttachedDataNetworksClient) BeginDelete 

func (client *AttachedDataNetworksClient) BeginDelete(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, packetCoreDataPlaneName string, attachedDataNetworkName string, options *AttachedDataNetworksClientBeginDeleteOptions) (*runtime.Poller[AttachedDataNetworksClientDeleteResponse], error)

BeginDelete - Deletes the specified attached data network. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • packetCoreDataPlaneName - The name of the packet core data plane.
  • attachedDataNetworkName - The name of the attached data network.
  • options - AttachedDataNetworksClientBeginDeleteOptions contains the optional parameters for the AttachedDataNetworksClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/AttachedDataNetworkDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAttachedDataNetworksClient().BeginDelete(ctx, "rg1", "TestPacketCoreCP", "TestPacketCoreDP", "TestAttachedDataNetwork", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*AttachedDataNetworksClient) Get 

func (client *AttachedDataNetworksClient) Get(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, packetCoreDataPlaneName string, attachedDataNetworkName string, options *AttachedDataNetworksClientGetOptions) (AttachedDataNetworksClientGetResponse, error)

Get - Gets information about the specified attached data network. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • packetCoreDataPlaneName - The name of the packet core data plane.
  • attachedDataNetworkName - The name of the attached data network.
  • options - AttachedDataNetworksClientGetOptions contains the optional parameters for the AttachedDataNetworksClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/AttachedDataNetworkGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAttachedDataNetworksClient().Get(ctx, "rg1", "TestPacketCoreCP", "TestPacketCoreDP", "TestAttachedDataNetwork", 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.AttachedDataNetwork = armmobilenetwork.AttachedDataNetwork{
// 	Name: to.Ptr("TestAttachedDataNetwork"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/attachedDataNetwork"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.AttachedDataNetworkPropertiesFormat{
// 		DNSAddresses: []*string{
// 			to.Ptr("1.1.1.1")},
// 			NaptConfiguration: &armmobilenetwork.NaptConfiguration{
// 				Enabled: to.Ptr(armmobilenetwork.NaptEnabledEnabled),
// 				PinholeLimits: to.Ptr[int32](65536),
// 				PinholeTimeouts: &armmobilenetwork.PinholeTimeouts{
// 					Icmp: to.Ptr[int32](30),
// 					TCP: to.Ptr[int32](180),
// 					UDP: to.Ptr[int32](30),
// 				},
// 				PortRange: &armmobilenetwork.PortRange{
// 					MaxPort: to.Ptr[int32](49999),
// 					MinPort: to.Ptr[int32](1024),
// 				},
// 				PortReuseHoldTime: &armmobilenetwork.PortReuseHoldTimes{
// 					TCP: to.Ptr[int32](120),
// 					UDP: to.Ptr[int32](60),
// 				},
// 			},
// 			ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 			UserEquipmentAddressPoolPrefix: []*string{
// 				to.Ptr("2.2.0.0/16")},
// 				UserEquipmentStaticAddressPoolPrefix: []*string{
// 					to.Ptr("2.4.0.0/16")},
// 					UserPlaneDataInterface: &armmobilenetwork.InterfaceProperties{
// 						Name: to.Ptr("N6"),
// 					},
// 				},
// 			}

Output:

func (*AttachedDataNetworksClient) NewListByPacketCoreDataPlanePager 

func (client *AttachedDataNetworksClient) NewListByPacketCoreDataPlanePager(resourceGroupName string, packetCoreControlPlaneName string, packetCoreDataPlaneName string, options *AttachedDataNetworksClientListByPacketCoreDataPlaneOptions) *runtime.Pager[AttachedDataNetworksClientListByPacketCoreDataPlaneResponse]

NewListByPacketCoreDataPlanePager - Gets all the attached data networks associated with a packet core data plane.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • packetCoreDataPlaneName - The name of the packet core data plane.
  • options - AttachedDataNetworksClientListByPacketCoreDataPlaneOptions contains the optional parameters for the AttachedDataNetworksClient.NewListByPacketCoreDataPlanePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/AttachedDataNetworkListByPacketCoreDataPlane.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAttachedDataNetworksClient().NewListByPacketCoreDataPlanePager("rg1", "TestPacketCoreCP", "TestPacketCoreDP", 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.AttachedDataNetworkListResult = armmobilenetwork.AttachedDataNetworkListResult{
	// 	Value: []*armmobilenetwork.AttachedDataNetwork{
	// 		{
	// 			Name: to.Ptr("TestAttachedDataNetwork"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/attachedDataNetworks"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("eastus"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armmobilenetwork.AttachedDataNetworkPropertiesFormat{
	// 				DNSAddresses: []*string{
	// 					to.Ptr("1.1.1.1")},
	// 					NaptConfiguration: &armmobilenetwork.NaptConfiguration{
	// 						Enabled: to.Ptr(armmobilenetwork.NaptEnabledEnabled),
	// 						PinholeLimits: to.Ptr[int32](65536),
	// 						PinholeTimeouts: &armmobilenetwork.PinholeTimeouts{
	// 							Icmp: to.Ptr[int32](30),
	// 							TCP: to.Ptr[int32](180),
	// 							UDP: to.Ptr[int32](30),
	// 						},
	// 						PortRange: &armmobilenetwork.PortRange{
	// 							MaxPort: to.Ptr[int32](49999),
	// 							MinPort: to.Ptr[int32](1024),
	// 						},
	// 						PortReuseHoldTime: &armmobilenetwork.PortReuseHoldTimes{
	// 							TCP: to.Ptr[int32](120),
	// 							UDP: to.Ptr[int32](60),
	// 						},
	// 					},
	// 					ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 					UserEquipmentAddressPoolPrefix: []*string{
	// 						to.Ptr("2.2.0.0/16")},
	// 						UserEquipmentStaticAddressPoolPrefix: []*string{
	// 							to.Ptr("2.4.0.0/16")},
	// 							UserPlaneDataInterface: &armmobilenetwork.InterfaceProperties{
	// 								Name: to.Ptr("N6"),
	// 							},
	// 						},
	// 				}},
	// 			}
}

Output:

func (*AttachedDataNetworksClient) UpdateTags 

func (client *AttachedDataNetworksClient) UpdateTags(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, packetCoreDataPlaneName string, attachedDataNetworkName string, parameters TagsObject, options *AttachedDataNetworksClientUpdateTagsOptions) (AttachedDataNetworksClientUpdateTagsResponse, error)

UpdateTags - Updates an attached data network tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • packetCoreDataPlaneName - The name of the packet core data plane.
  • attachedDataNetworkName - The name of the attached data network.
  • parameters - Parameters supplied to update attached data network tags.
  • options - AttachedDataNetworksClientUpdateTagsOptions contains the optional parameters for the AttachedDataNetworksClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/AttachedDataNetworkUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAttachedDataNetworksClient().UpdateTags(ctx, "rg1", "TestPacketCoreCP", "TestPacketCoreDP", "TestAttachedDataNetwork", armmobilenetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, 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.AttachedDataNetwork = armmobilenetwork.AttachedDataNetwork{
// 	Name: to.Ptr("TestAccessPoint"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/attachedDataNetwork"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Properties: &armmobilenetwork.AttachedDataNetworkPropertiesFormat{
// 		DNSAddresses: []*string{
// 			to.Ptr("1.1.1.1")},
// 			NaptConfiguration: &armmobilenetwork.NaptConfiguration{
// 				Enabled: to.Ptr(armmobilenetwork.NaptEnabledEnabled),
// 				PinholeLimits: to.Ptr[int32](65536),
// 				PinholeTimeouts: &armmobilenetwork.PinholeTimeouts{
// 					Icmp: to.Ptr[int32](30),
// 					TCP: to.Ptr[int32](180),
// 					UDP: to.Ptr[int32](30),
// 				},
// 				PortRange: &armmobilenetwork.PortRange{
// 					MaxPort: to.Ptr[int32](49999),
// 					MinPort: to.Ptr[int32](1024),
// 				},
// 				PortReuseHoldTime: &armmobilenetwork.PortReuseHoldTimes{
// 					TCP: to.Ptr[int32](120),
// 					UDP: to.Ptr[int32](60),
// 				},
// 			},
// 			ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 			UserEquipmentAddressPoolPrefix: []*string{
// 				to.Ptr("2.2.0.0/16")},
// 				UserEquipmentStaticAddressPoolPrefix: []*string{
// 					to.Ptr("2.4.0.0/16")},
// 					UserPlaneDataInterface: &armmobilenetwork.InterfaceProperties{
// 						Name: to.Ptr("N6"),
// 					},
// 				},
// 			}

Output:

type AttachedDataNetworksClientBeginCreateOrUpdateOptions 

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

AttachedDataNetworksClientBeginCreateOrUpdateOptions contains the optional parameters for the AttachedDataNetworksClient.BeginCreateOrUpdate method.

type AttachedDataNetworksClientBeginDeleteOptions 

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

AttachedDataNetworksClientBeginDeleteOptions contains the optional parameters for the AttachedDataNetworksClient.BeginDelete method.

type AttachedDataNetworksClientCreateOrUpdateResponse 

type AttachedDataNetworksClientCreateOrUpdateResponse struct {
	AttachedDataNetwork
}

AttachedDataNetworksClientCreateOrUpdateResponse contains the response from method AttachedDataNetworksClient.BeginCreateOrUpdate.

type AttachedDataNetworksClientDeleteResponse 

type AttachedDataNetworksClientDeleteResponse struct {
}

AttachedDataNetworksClientDeleteResponse contains the response from method AttachedDataNetworksClient.BeginDelete.

type AttachedDataNetworksClientGetOptions 

type AttachedDataNetworksClientGetOptions struct {
}

AttachedDataNetworksClientGetOptions contains the optional parameters for the AttachedDataNetworksClient.Get method.

type AttachedDataNetworksClientGetResponse 

type AttachedDataNetworksClientGetResponse struct {
	AttachedDataNetwork
}

AttachedDataNetworksClientGetResponse contains the response from method AttachedDataNetworksClient.Get.

type AttachedDataNetworksClientListByPacketCoreDataPlaneOptions 

type AttachedDataNetworksClientListByPacketCoreDataPlaneOptions struct {
}

AttachedDataNetworksClientListByPacketCoreDataPlaneOptions contains the optional parameters for the AttachedDataNetworksClient.NewListByPacketCoreDataPlanePager method.

type AttachedDataNetworksClientListByPacketCoreDataPlaneResponse 

type AttachedDataNetworksClientListByPacketCoreDataPlaneResponse struct {
	AttachedDataNetworkListResult
}

AttachedDataNetworksClientListByPacketCoreDataPlaneResponse contains the response from method AttachedDataNetworksClient.NewListByPacketCoreDataPlanePager.

type AttachedDataNetworksClientUpdateTagsOptions 

type AttachedDataNetworksClientUpdateTagsOptions struct {
}

AttachedDataNetworksClientUpdateTagsOptions contains the optional parameters for the AttachedDataNetworksClient.UpdateTags method.

type AttachedDataNetworksClientUpdateTagsResponse 

type AttachedDataNetworksClientUpdateTagsResponse struct {
	AttachedDataNetwork
}

AttachedDataNetworksClientUpdateTagsResponse contains the response from method AttachedDataNetworksClient.UpdateTags.

type AuthenticationType 

type AuthenticationType string

AuthenticationType - How to authenticate users who access local diagnostics APIs. 

const (
	// AuthenticationTypeAAD - Use AAD SSO to authenticate the user (this requires internet access).
	AuthenticationTypeAAD AuthenticationType = "AAD"
	// AuthenticationTypePassword - Use locally stored passwords to authenticate the user.
	AuthenticationTypePassword AuthenticationType = "Password"
)

func PossibleAuthenticationTypeValues 

func PossibleAuthenticationTypeValues() []AuthenticationType

PossibleAuthenticationTypeValues returns the possible values for the AuthenticationType const type.

type AzureStackEdgeDeviceResourceID 

type AzureStackEdgeDeviceResourceID struct {
	// REQUIRED; Azure Stack Edge device resource ID.
	ID *string
}

AzureStackEdgeDeviceResourceID - Reference to an Azure Stack Edge device resource.

func (AzureStackEdgeDeviceResourceID) MarshalJSON 

func (a AzureStackEdgeDeviceResourceID) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureStackEdgeDeviceResourceID.

func (*AzureStackEdgeDeviceResourceID) UnmarshalJSON 

func (a *AzureStackEdgeDeviceResourceID) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureStackEdgeDeviceResourceID.

type AzureStackHCIClusterResourceID 

type AzureStackHCIClusterResourceID struct {
	// REQUIRED; Azure Stack HCI cluster resource ID.
	ID *string
}

AzureStackHCIClusterResourceID - Reference to an Azure Stack HCI cluster resource.

func (AzureStackHCIClusterResourceID) MarshalJSON 

func (a AzureStackHCIClusterResourceID) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureStackHCIClusterResourceID.

func (*AzureStackHCIClusterResourceID) UnmarshalJSON 

func (a *AzureStackHCIClusterResourceID) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureStackHCIClusterResourceID.

type BillingSKU 

type BillingSKU string

BillingSKU - The SKU of the packet core control plane resource. The SKU list may change over time when a new SKU gets added or an exiting SKU gets removed. 

const (
	// BillingSKUG0 - 100 Mbps, 20 active SIMs plan
	BillingSKUG0 BillingSKU = "G0"
	// BillingSKUG1 - 1 Gbps, 100 active SIMs plan
	BillingSKUG1 BillingSKU = "G1"
	// BillingSKUG10 - 10 Gbps, 1000 active SIMs plan
	BillingSKUG10 BillingSKU = "G10"
	// BillingSKUG2 - 2 Gbps, 200 active SIMs plan
	BillingSKUG2 BillingSKU = "G2"
	// BillingSKUG3 - 3 Gbps, 300 active SIMs plan
	BillingSKUG3 BillingSKU = "G3"
	// BillingSKUG4 - 4 Gbps, 400 active SIMs plan
	BillingSKUG4 BillingSKU = "G4"
	// BillingSKUG5 - 5 Gbps, 500 active SIMs plan
	BillingSKUG5 BillingSKU = "G5"
)

func PossibleBillingSKUValues 

func PossibleBillingSKUValues() []BillingSKU

PossibleBillingSKUValues returns the possible values for the BillingSKU const type.

type CertificateProvisioning 

type CertificateProvisioning struct {
	// READ-ONLY; Reason for certificate provisioning failure.
	Reason *string

	// READ-ONLY; The certificate's provisioning state
	State *CertificateProvisioningState
}

CertificateProvisioning - Certificate provisioning state

func (CertificateProvisioning) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CertificateProvisioning.

func (*CertificateProvisioning) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CertificateProvisioning.

type CertificateProvisioningState 

type CertificateProvisioningState string

CertificateProvisioningState - The certificate's provisioning state 

const (
	// CertificateProvisioningStateFailed - The certificate failed to be provisioned. The "reason" property explains why.
	CertificateProvisioningStateFailed CertificateProvisioningState = "Failed"
	// CertificateProvisioningStateNotProvisioned - The certificate has not been provisioned.
	CertificateProvisioningStateNotProvisioned CertificateProvisioningState = "NotProvisioned"
	// CertificateProvisioningStateProvisioned - The certificate has been provisioned.
	CertificateProvisioningStateProvisioned CertificateProvisioningState = "Provisioned"
)

func PossibleCertificateProvisioningStateValues 

func PossibleCertificateProvisioningStateValues() []CertificateProvisioningState

PossibleCertificateProvisioningStateValues returns the possible values for the CertificateProvisioningState const type.

type ClientFactory added in v2.1.0 

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 added in v2.1.0 

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.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewAttachedDataNetworksClient added in v2.1.0 

func (c *ClientFactory) NewAttachedDataNetworksClient() *AttachedDataNetworksClient

func (*ClientFactory) NewDataNetworksClient added in v2.1.0 

func (c *ClientFactory) NewDataNetworksClient() *DataNetworksClient

func (*ClientFactory) NewMobileNetworksClient added in v2.1.0 

func (c *ClientFactory) NewMobileNetworksClient() *MobileNetworksClient

func (*ClientFactory) NewOperationsClient added in v2.1.0 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

func (*ClientFactory) NewPacketCoreControlPlaneVersionsClient added in v2.1.0 

func (c *ClientFactory) NewPacketCoreControlPlaneVersionsClient() *PacketCoreControlPlaneVersionsClient

func (*ClientFactory) NewPacketCoreControlPlanesClient added in v2.1.0 

func (c *ClientFactory) NewPacketCoreControlPlanesClient() *PacketCoreControlPlanesClient

func (*ClientFactory) NewPacketCoreDataPlanesClient added in v2.1.0 

func (c *ClientFactory) NewPacketCoreDataPlanesClient() *PacketCoreDataPlanesClient

func (*ClientFactory) NewServicesClient added in v2.1.0 

func (c *ClientFactory) NewServicesClient() *ServicesClient

func (*ClientFactory) NewSimGroupsClient added in v2.1.0 

func (c *ClientFactory) NewSimGroupsClient() *SimGroupsClient

func (*ClientFactory) NewSimPoliciesClient added in v2.1.0 

func (c *ClientFactory) NewSimPoliciesClient() *SimPoliciesClient

func (*ClientFactory) NewSimsClient added in v2.1.0 

func (c *ClientFactory) NewSimsClient() *SimsClient

func (*ClientFactory) NewSitesClient added in v2.1.0 

func (c *ClientFactory) NewSitesClient() *SitesClient

func (*ClientFactory) NewSlicesClient added in v2.1.0 

func (c *ClientFactory) NewSlicesClient() *SlicesClient

type CommonSimPropertiesFormat 

type CommonSimPropertiesFormat struct {
	// REQUIRED; The international mobile subscriber identity (IMSI) for the SIM.
	InternationalMobileSubscriberIdentity *string

	// An optional free-form text field that can be used to record the device type this SIM is associated with, for example 'Video
	// camera'. The Azure portal allows SIMs to be grouped and filtered based on
	// this value.
	DeviceType *string

	// The integrated circuit card ID (ICCID) for the SIM.
	IntegratedCircuitCardIdentifier *string

	// The SIM policy used by this SIM. The SIM policy must be in the same location as the SIM.
	SimPolicy *SimPolicyResourceID

	// A list of static IP addresses assigned to this SIM. Each address is assigned at a defined network scope, made up of {attached
	// data network, slice}.
	StaticIPConfiguration []*SimStaticIPProperties

	// READ-ONLY; The provisioning state of the SIM resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The state of the SIM resource.
	SimState *SimState

	// READ-ONLY; A dictionary of sites to the provisioning state of this SIM on that site.
	SiteProvisioningState map[string]*SiteProvisioningState

	// READ-ONLY; The public key fingerprint of the SIM vendor who provided this SIM, if any.
	VendorKeyFingerprint *string

	// READ-ONLY; The name of the SIM vendor who provided this SIM, if any.
	VendorName *string
}

CommonSimPropertiesFormat - Common SIM properties.

func (CommonSimPropertiesFormat) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CommonSimPropertiesFormat.

func (*CommonSimPropertiesFormat) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CommonSimPropertiesFormat.

type ConnectedClusterResourceID 

type ConnectedClusterResourceID struct {
	// REQUIRED; Azure Arc connected cluster resource ID.
	ID *string
}

ConnectedClusterResourceID - Reference to an Azure Arc custom location resource.

func (ConnectedClusterResourceID) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ConnectedClusterResourceID.

func (*ConnectedClusterResourceID) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ConnectedClusterResourceID.

type CoreNetworkType 

type CoreNetworkType string

CoreNetworkType - The core network technology generation (5G core or EPC / 4G core). 

const (
	// CoreNetworkTypeFiveGC - 5G core
	CoreNetworkTypeFiveGC CoreNetworkType = "5GC"
	// CoreNetworkTypeEPC - EPC / 4G core
	CoreNetworkTypeEPC CoreNetworkType = "EPC"
)

func PossibleCoreNetworkTypeValues 

func PossibleCoreNetworkTypeValues() []CoreNetworkType

PossibleCoreNetworkTypeValues returns the possible values for the CoreNetworkType const type.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

const (
	CreatedByTypeApplication     CreatedByType = "Application"
	CreatedByTypeKey             CreatedByType = "Key"
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	CreatedByTypeUser            CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type CustomLocationResourceID 

type CustomLocationResourceID struct {
	// REQUIRED; Azure Arc custom location resource ID.
	ID *string
}

CustomLocationResourceID - Reference to an Azure Arc custom location resource.

func (CustomLocationResourceID) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CustomLocationResourceID.

func (*CustomLocationResourceID) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CustomLocationResourceID.

type DataNetwork 

type DataNetwork struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// Data network properties.
	Properties *DataNetworkPropertiesFormat

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

DataNetwork - Data network resource. Must be created in the same location as its parent mobile network.

func (DataNetwork) MarshalJSON 

func (d DataNetwork) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DataNetwork.

func (*DataNetwork) UnmarshalJSON 

func (d *DataNetwork) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DataNetwork.

type DataNetworkConfiguration 

type DataNetworkConfiguration struct {
	// REQUIRED; List of services that can be used as part of this SIM policy. The list must not contain duplicate items and must
	// contain at least one item. The services must be in the same location as the SIM policy.
	AllowedServices []*ServiceResourceID

	// REQUIRED; A reference to the data network that these settings apply to. The data network must be in the same location as
	// the SIM policy.
	DataNetwork *DataNetworkResourceID

	// REQUIRED; Aggregate maximum bit rate across all non-GBR QoS flows of a given PDU session. See 3GPP TS23.501 section 5.7.2.6
	// for a full description of the Session-AMBR.
	SessionAmbr *Ambr

	// Allowed session types in addition to the default session type. Must not duplicate the default session type.
	AdditionalAllowedSessionTypes []*PduSessionType

	// Default QoS Flow allocation and retention priority (ARP) level. Flows with higher priority preempt flows with lower priority,
	// if the settings of preemptionCapability and preemptionVulnerability allow
	// it. 1 is the highest level of priority. If this field is not specified then 5qi is used to derive the ARP value. See 3GPP
	// TS23.501 section 5.7.2.2 for a full description of the ARP parameters.
	AllocationAndRetentionPriorityLevel *int32

	// The default PDU session type, which is used if the UE does not request a specific session type.
	DefaultSessionType *PduSessionType

	// Default QoS Flow 5G QoS Indicator value. The 5QI identifies a specific QoS forwarding treatment to be provided to a flow.
	// This must not be a standardized 5QI value corresponding to a GBR (guaranteed
	// bit rate) QoS Flow. The illegal GBR 5QI values are: 1, 2, 3, 4, 65, 66, 67, 71, 72, 73, 74, 75, 76, 82, 83, 84, and 85.
	// See 3GPP TS23.501 section 5.7.2.1 for a full description of the 5QI parameter,
	// and table 5.7.4-1 for the definition of which are the GBR 5QI values.
	FiveQi *int32

	// The maximum number of downlink packets to buffer at the user plane for High Latency Communication - Extended Buffering.
	// See 3GPP TS29.272 v15.10.0 section 7.3.188 for a full description. This maximum
	// is not guaranteed because there is a internal limit on buffered packets across all PDU sessions.
	MaximumNumberOfBufferedPackets *int32

	// Default QoS Flow preemption capability. The preemption capability of a QoS Flow controls whether it can preempt another
	// QoS Flow with a lower priority level. See 3GPP TS23.501 section 5.7.2.2 for a
	// full description of the ARP parameters.
	PreemptionCapability *PreemptionCapability

	// Default QoS Flow preemption vulnerability. The preemption vulnerability of a QoS Flow controls whether it can be preempted
	// by a QoS Flow with a higher priority level. See 3GPP TS23.501 section 5.7.2.2
	// for a full description of the ARP parameters.
	PreemptionVulnerability *PreemptionVulnerability
}

DataNetworkConfiguration - Settings controlling data network use

func (DataNetworkConfiguration) MarshalJSON 

func (d DataNetworkConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DataNetworkConfiguration.

func (*DataNetworkConfiguration) UnmarshalJSON 

func (d *DataNetworkConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DataNetworkConfiguration.

type DataNetworkListResult 

type DataNetworkListResult struct {
	// A list of data networks.
	Value []*DataNetwork

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

DataNetworkListResult - Response for data network API service call.

func (DataNetworkListResult) MarshalJSON 

func (d DataNetworkListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DataNetworkListResult.

func (*DataNetworkListResult) UnmarshalJSON 

func (d *DataNetworkListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DataNetworkListResult.

type DataNetworkPropertiesFormat 

type DataNetworkPropertiesFormat struct {
	// An optional description for this data network.
	Description *string

	// READ-ONLY; The provisioning state of the data network resource.
	ProvisioningState *ProvisioningState
}

DataNetworkPropertiesFormat - Data network properties.

func (DataNetworkPropertiesFormat) MarshalJSON 

func (d DataNetworkPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DataNetworkPropertiesFormat.

func (*DataNetworkPropertiesFormat) UnmarshalJSON 

func (d *DataNetworkPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DataNetworkPropertiesFormat.

type DataNetworkResourceID 

type DataNetworkResourceID struct {
	// REQUIRED; Data network resource ID.
	ID *string
}

DataNetworkResourceID - Reference to a data network resource.

func (DataNetworkResourceID) MarshalJSON 

func (d DataNetworkResourceID) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DataNetworkResourceID.

func (*DataNetworkResourceID) UnmarshalJSON 

func (d *DataNetworkResourceID) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DataNetworkResourceID.

type DataNetworksClient 

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

DataNetworksClient contains the methods for the DataNetworks group. Don't use this type directly, use NewDataNetworksClient() instead.

func NewDataNetworksClient 

func NewDataNetworksClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DataNetworksClient, error)

NewDataNetworksClient creates a new instance of DataNetworksClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*DataNetworksClient) BeginCreateOrUpdate 

func (client *DataNetworksClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, mobileNetworkName string, dataNetworkName string, parameters DataNetwork, options *DataNetworksClientBeginCreateOrUpdateOptions) (*runtime.Poller[DataNetworksClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a data network. Must be created in the same location as its parent mobile network. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • dataNetworkName - The name of the data network.
  • parameters - Parameters supplied to the create or update data network operation.
  • options - DataNetworksClientBeginCreateOrUpdateOptions contains the optional parameters for the DataNetworksClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/DataNetworkCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewDataNetworksClient().BeginCreateOrUpdate(ctx, "rg1", "testMobileNetwork", "testDataNetwork", armmobilenetwork.DataNetwork{
	Location: to.Ptr("eastus"),
	Properties: &armmobilenetwork.DataNetworkPropertiesFormat{
		Description: to.Ptr("myFavouriteDataNetwork"),
	},
}, 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.DataNetwork = armmobilenetwork.DataNetwork{
// 	Name: to.Ptr("testDataNetwork"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks/dataNetworks"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testDataNetwork"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.DataNetworkPropertiesFormat{
// 		Description: to.Ptr("myFavouriteDataNetwork"),
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 	},
// }

Output:

func (*DataNetworksClient) BeginDelete 

func (client *DataNetworksClient) BeginDelete(ctx context.Context, resourceGroupName string, mobileNetworkName string, dataNetworkName string, options *DataNetworksClientBeginDeleteOptions) (*runtime.Poller[DataNetworksClientDeleteResponse], error)

BeginDelete - Deletes the specified data network. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • dataNetworkName - The name of the data network.
  • options - DataNetworksClientBeginDeleteOptions contains the optional parameters for the DataNetworksClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/DataNetworkDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewDataNetworksClient().BeginDelete(ctx, "rg1", "testMobileNetwork", "testDataNetwork", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*DataNetworksClient) Get 

func (client *DataNetworksClient) Get(ctx context.Context, resourceGroupName string, mobileNetworkName string, dataNetworkName string, options *DataNetworksClientGetOptions) (DataNetworksClientGetResponse, error)

Get - Gets information about the specified data network. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • dataNetworkName - The name of the data network.
  • options - DataNetworksClientGetOptions contains the optional parameters for the DataNetworksClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/DataNetworkGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewDataNetworksClient().Get(ctx, "rg1", "testMobileNetwork", "testDataNetwork", 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.DataNetwork = armmobilenetwork.DataNetwork{
// 	Name: to.Ptr("testDataNetwork"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks/dataNetworks"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testDataNetwork"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.DataNetworkPropertiesFormat{
// 		Description: to.Ptr("myFavouriteDataNetwork"),
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 	},
// }

Output:

func (*DataNetworksClient) NewListByMobileNetworkPager 

func (client *DataNetworksClient) NewListByMobileNetworkPager(resourceGroupName string, mobileNetworkName string, options *DataNetworksClientListByMobileNetworkOptions) *runtime.Pager[DataNetworksClientListByMobileNetworkResponse]

NewListByMobileNetworkPager - Lists all data networks in the mobile network.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • options - DataNetworksClientListByMobileNetworkOptions contains the optional parameters for the DataNetworksClient.NewListByMobileNetworkPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/DataNetworkListByMobileNetwork.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewDataNetworksClient().NewListByMobileNetworkPager("rg1", "testMobileNetwork", 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.DataNetworkListResult = armmobilenetwork.DataNetworkListResult{
	// 	Value: []*armmobilenetwork.DataNetwork{
	// 		{
	// 			Name: to.Ptr("testDataNetwork"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks/dataNetworks"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testDataNetwork"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("eastus"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armmobilenetwork.DataNetworkPropertiesFormat{
	// 				Description: to.Ptr("myFavouriteDataNetwork"),
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

Output:

func (*DataNetworksClient) UpdateTags 

func (client *DataNetworksClient) UpdateTags(ctx context.Context, resourceGroupName string, mobileNetworkName string, dataNetworkName string, parameters TagsObject, options *DataNetworksClientUpdateTagsOptions) (DataNetworksClientUpdateTagsResponse, error)

UpdateTags - Updates data network tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • dataNetworkName - The name of the data network.
  • parameters - Parameters supplied to update data network tags.
  • options - DataNetworksClientUpdateTagsOptions contains the optional parameters for the DataNetworksClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/DataNetworkUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewDataNetworksClient().UpdateTags(ctx, "rg1", "testMobileNetwork", "testDataNetwork", armmobilenetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, 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.DataNetwork = armmobilenetwork.DataNetwork{
// 	Name: to.Ptr("testDataNetwork"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks/dataNetworks"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testDataNetwork"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Properties: &armmobilenetwork.DataNetworkPropertiesFormat{
// 		Description: to.Ptr("myFavouriteDataNetwork"),
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 	},
// }

Output:

type DataNetworksClientBeginCreateOrUpdateOptions 

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

DataNetworksClientBeginCreateOrUpdateOptions contains the optional parameters for the DataNetworksClient.BeginCreateOrUpdate method.

type DataNetworksClientBeginDeleteOptions 

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

DataNetworksClientBeginDeleteOptions contains the optional parameters for the DataNetworksClient.BeginDelete method.

type DataNetworksClientCreateOrUpdateResponse 

type DataNetworksClientCreateOrUpdateResponse struct {
	DataNetwork
}

DataNetworksClientCreateOrUpdateResponse contains the response from method DataNetworksClient.BeginCreateOrUpdate.

type DataNetworksClientDeleteResponse 

type DataNetworksClientDeleteResponse struct {
}

DataNetworksClientDeleteResponse contains the response from method DataNetworksClient.BeginDelete.

type DataNetworksClientGetOptions 

type DataNetworksClientGetOptions struct {
}

DataNetworksClientGetOptions contains the optional parameters for the DataNetworksClient.Get method.

type DataNetworksClientGetResponse 

type DataNetworksClientGetResponse struct {
	DataNetwork
}

DataNetworksClientGetResponse contains the response from method DataNetworksClient.Get.

type DataNetworksClientListByMobileNetworkOptions 

type DataNetworksClientListByMobileNetworkOptions struct {
}

DataNetworksClientListByMobileNetworkOptions contains the optional parameters for the DataNetworksClient.NewListByMobileNetworkPager method.

type DataNetworksClientListByMobileNetworkResponse 

type DataNetworksClientListByMobileNetworkResponse struct {
	DataNetworkListResult
}

DataNetworksClientListByMobileNetworkResponse contains the response from method DataNetworksClient.NewListByMobileNetworkPager.

type DataNetworksClientUpdateTagsOptions 

type DataNetworksClientUpdateTagsOptions struct {
}

DataNetworksClientUpdateTagsOptions contains the optional parameters for the DataNetworksClient.UpdateTags method.

type DataNetworksClientUpdateTagsResponse 

type DataNetworksClientUpdateTagsResponse struct {
	DataNetwork
}

DataNetworksClientUpdateTagsResponse contains the response from method DataNetworksClient.UpdateTags.

type EncryptedSimPropertiesFormat 

type EncryptedSimPropertiesFormat struct {
	// REQUIRED; The international mobile subscriber identity (IMSI) for the SIM.
	InternationalMobileSubscriberIdentity *string

	// An optional free-form text field that can be used to record the device type this SIM is associated with, for example 'Video
	// camera'. The Azure portal allows SIMs to be grouped and filtered based on
	// this value.
	DeviceType *string

	// The encrypted SIM credentials.
	EncryptedCredentials *string

	// The integrated circuit card ID (ICCID) for the SIM.
	IntegratedCircuitCardIdentifier *string

	// The SIM policy used by this SIM. The SIM policy must be in the same location as the SIM.
	SimPolicy *SimPolicyResourceID

	// A list of static IP addresses assigned to this SIM. Each address is assigned at a defined network scope, made up of {attached
	// data network, slice}.
	StaticIPConfiguration []*SimStaticIPProperties

	// READ-ONLY; The provisioning state of the SIM resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The state of the SIM resource.
	SimState *SimState

	// READ-ONLY; A dictionary of sites to the provisioning state of this SIM on that site.
	SiteProvisioningState map[string]*SiteProvisioningState

	// READ-ONLY; The public key fingerprint of the SIM vendor who provided this SIM, if any.
	VendorKeyFingerprint *string

	// READ-ONLY; The name of the SIM vendor who provided this SIM, if any.
	VendorName *string
}

EncryptedSimPropertiesFormat - Encrypted SIM properties.

func (EncryptedSimPropertiesFormat) MarshalJSON 

func (e EncryptedSimPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EncryptedSimPropertiesFormat.

func (*EncryptedSimPropertiesFormat) UnmarshalJSON 

func (e *EncryptedSimPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EncryptedSimPropertiesFormat.

type EncryptedSimUploadList 

type EncryptedSimUploadList struct {
	// REQUIRED; An identifier for the Azure SIM onboarding public key used for encrypted upload.
	AzureKeyIdentifier *int32

	// REQUIRED; The transport key used for encrypting SIM credentials, encrypted using the SIM onboarding public key.
	EncryptedTransportKey *string

	// REQUIRED; The encrypted transport key, signed using the SIM vendor private key.
	SignedTransportKey *string

	// REQUIRED; A list of SIMs to upload, with encrypted properties.
	Sims []*SimNameAndEncryptedProperties

	// REQUIRED; The fingerprint of the SIM vendor public key. The private counterpart is used for signing the encrypted transport
	// key.
	VendorKeyFingerprint *string

	// REQUIRED; The upload file format version.
	Version *int32
}

EncryptedSimUploadList - The SIMs to upload. The SIM credentials must be encrypted.

func (EncryptedSimUploadList) MarshalJSON 

func (e EncryptedSimUploadList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EncryptedSimUploadList.

func (*EncryptedSimUploadList) UnmarshalJSON 

func (e *EncryptedSimUploadList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EncryptedSimUploadList.

type ErrorAdditionalInfo 

type ErrorAdditionalInfo struct {
	// READ-ONLY; The additional info.
	Info any

	// READ-ONLY; The additional info type.
	Type *string
}

ErrorAdditionalInfo - The resource management error additional info.

func (ErrorAdditionalInfo) MarshalJSON 

func (e ErrorAdditionalInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ErrorAdditionalInfo.

func (*ErrorAdditionalInfo) UnmarshalJSON 

func (e *ErrorAdditionalInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorAdditionalInfo.

type ErrorDetail 

type ErrorDetail struct {
	// READ-ONLY; The error additional info.
	AdditionalInfo []*ErrorAdditionalInfo

	// READ-ONLY; The error code.
	Code *string

	// READ-ONLY; The error details.
	Details []*ErrorDetail

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

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

ErrorDetail - The error detail.

func (ErrorDetail) MarshalJSON 

func (e ErrorDetail) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ErrorDetail.

func (*ErrorDetail) UnmarshalJSON 

func (e *ErrorDetail) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorDetail.

type ErrorResponse 

type ErrorResponse struct {
	// The error object.
	Error *ErrorDetail
}

ErrorResponse - Common error response for all Azure Resource Manager APIs to return error details for failed operations. (This also follows the OData error response format.).

func (ErrorResponse) MarshalJSON 

func (e ErrorResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ErrorResponse.

func (*ErrorResponse) UnmarshalJSON 

func (e *ErrorResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponse.

type HTTPSServerCertificate 

type HTTPSServerCertificate struct {
	// REQUIRED; The certificate URL, unversioned. For example: https://contosovault.vault.azure.net/certificates/ingress.
	CertificateURL *string

	// READ-ONLY; The provisioning state of the certificate.
	Provisioning *CertificateProvisioning
}

HTTPSServerCertificate - HTTPS server certificate configuration.

func (HTTPSServerCertificate) MarshalJSON 

func (h HTTPSServerCertificate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HTTPSServerCertificate.

func (*HTTPSServerCertificate) UnmarshalJSON 

func (h *HTTPSServerCertificate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HTTPSServerCertificate.

type Installation 

type Installation struct {
	// A reference to an in-progress installation operation
	Operation *AsyncOperationID

	// Installation state
	State *InstallationState
}

Installation - The installation state of the packet core.

func (Installation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Installation.

func (*Installation) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Installation.

type InstallationState 

type InstallationState string

InstallationState - The installation state of the packet core. 

const (
	// InstallationStateFailed - The packet core is in failed state.
	InstallationStateFailed InstallationState = "Failed"
	// InstallationStateInstalled - The packet core is installed.
	InstallationStateInstalled InstallationState = "Installed"
	// InstallationStateInstalling - The packet core is installing.
	InstallationStateInstalling InstallationState = "Installing"
	// InstallationStateReinstalling - The packet core is reinstalling.
	InstallationStateReinstalling InstallationState = "Reinstalling"
	// InstallationStateRollingBack - The packet core is rolling back to its previous version.
	InstallationStateRollingBack InstallationState = "RollingBack"
	// InstallationStateUninstalled - The packet core is uninstalled.
	InstallationStateUninstalled InstallationState = "Uninstalled"
	// InstallationStateUninstalling - The packet core is uninstalling.
	InstallationStateUninstalling InstallationState = "Uninstalling"
	// InstallationStateUpdating - The packet core is updating its configuration.
	InstallationStateUpdating InstallationState = "Updating"
	// InstallationStateUpgrading - The packet core is upgrading to a different software version.
	InstallationStateUpgrading InstallationState = "Upgrading"
)

func PossibleInstallationStateValues 

func PossibleInstallationStateValues() []InstallationState

PossibleInstallationStateValues returns the possible values for the InstallationState const type.

type InterfaceProperties 

type InterfaceProperties struct {
	// The IPv4 address.
	IPv4Address *string

	// The default IPv4 gateway (router).
	IPv4Gateway *string

	// The IPv4 subnet.
	IPv4Subnet *string

	// The logical name for this interface. This should match one of the interfaces configured on your Azure Stack Edge device.
	Name *string
}

InterfaceProperties - Interface properties

func (InterfaceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type InterfaceProperties.

func (*InterfaceProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type InterfaceProperties.

type KeyVaultKey 

type KeyVaultKey struct {
	// The key URL, unversioned. For example: https://contosovault.vault.azure.net/keys/azureKey.
	KeyURL *string
}

KeyVaultKey - An Azure key vault key.

func (KeyVaultKey) MarshalJSON 

func (k KeyVaultKey) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KeyVaultKey.

func (*KeyVaultKey) UnmarshalJSON 

func (k *KeyVaultKey) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KeyVaultKey.

type ListResult 

type ListResult struct {
	// A list of mobile networks in a resource group.
	Value []*MobileNetwork

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

ListResult - Response for mobile networks API service call.

func (ListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ListResult.

func (*ListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ListResult.

type LocalDiagnosticsAccessConfiguration 

type LocalDiagnosticsAccessConfiguration struct {
	// REQUIRED; How to authenticate users who access local diagnostics APIs.
	AuthenticationType *AuthenticationType

	// The HTTPS server TLS certificate used to secure local access to diagnostics.
	HTTPSServerCertificate *HTTPSServerCertificate
}

LocalDiagnosticsAccessConfiguration - The kubernetes ingress configuration to control access to packet core diagnostics over local APIs.

func (LocalDiagnosticsAccessConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LocalDiagnosticsAccessConfiguration.

func (*LocalDiagnosticsAccessConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LocalDiagnosticsAccessConfiguration.

type ManagedServiceIdentity 

type ManagedServiceIdentity struct {
	// REQUIRED; Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
	Type *ManagedServiceIdentityType

	// The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM
	// resource ids in the form:
	// '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}.
	// The dictionary values can be empty objects ({}) in
	// requests.
	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
}

ManagedServiceIdentity - Managed service identity (system assigned and/or user assigned identities)

func (ManagedServiceIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentity.

func (*ManagedServiceIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedServiceIdentity.

type ManagedServiceIdentityType 

type ManagedServiceIdentityType string

ManagedServiceIdentityType - Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). 

const (
	ManagedServiceIdentityTypeNone                       ManagedServiceIdentityType = "None"
	ManagedServiceIdentityTypeSystemAssigned             ManagedServiceIdentityType = "SystemAssigned"
	ManagedServiceIdentityTypeSystemAssignedUserAssigned ManagedServiceIdentityType = "SystemAssigned,UserAssigned"
	ManagedServiceIdentityTypeUserAssigned               ManagedServiceIdentityType = "UserAssigned"
)

func PossibleManagedServiceIdentityTypeValues 

func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType

PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.

type MobileNetwork 

type MobileNetwork struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Mobile network properties.
	Properties *PropertiesFormat

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

MobileNetwork - Mobile network resource.

func (MobileNetwork) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MobileNetwork.

func (*MobileNetwork) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MobileNetwork.

type MobileNetworksClient 

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

MobileNetworksClient contains the methods for the MobileNetworks group. Don't use this type directly, use NewMobileNetworksClient() instead.

func NewMobileNetworksClient 

func NewMobileNetworksClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*MobileNetworksClient, error)

NewMobileNetworksClient creates a new instance of MobileNetworksClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*MobileNetworksClient) BeginCreateOrUpdate 

func (client *MobileNetworksClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, mobileNetworkName string, parameters MobileNetwork, options *MobileNetworksClientBeginCreateOrUpdateOptions) (*runtime.Poller[MobileNetworksClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a mobile network. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • parameters - Parameters supplied to the create or update mobile network operation.
  • options - MobileNetworksClientBeginCreateOrUpdateOptions contains the optional parameters for the MobileNetworksClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/MobileNetworkCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewMobileNetworksClient().BeginCreateOrUpdate(ctx, "rg1", "testMobileNetwork", armmobilenetwork.MobileNetwork{
	Location: to.Ptr("eastus"),
	Properties: &armmobilenetwork.PropertiesFormat{
		PublicLandMobileNetworkIdentifier: &armmobilenetwork.PlmnID{
			Mcc: to.Ptr("001"),
			Mnc: to.Ptr("01"),
		},
	},
}, 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.MobileNetwork = armmobilenetwork.MobileNetwork{
// 	Name: to.Ptr("testMobileNetwork"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.PropertiesFormat{
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		PublicLandMobileNetworkIdentifier: &armmobilenetwork.PlmnID{
// 			Mcc: to.Ptr("001"),
// 			Mnc: to.Ptr("01"),
// 		},
// 	},
// }

Output:

func (*MobileNetworksClient) BeginDelete 

func (client *MobileNetworksClient) BeginDelete(ctx context.Context, resourceGroupName string, mobileNetworkName string, options *MobileNetworksClientBeginDeleteOptions) (*runtime.Poller[MobileNetworksClientDeleteResponse], error)

BeginDelete - Deletes the specified mobile network. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • options - MobileNetworksClientBeginDeleteOptions contains the optional parameters for the MobileNetworksClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/MobileNetworkDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewMobileNetworksClient().BeginDelete(ctx, "rg1", "testMobileNetwork", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*MobileNetworksClient) Get 

func (client *MobileNetworksClient) Get(ctx context.Context, resourceGroupName string, mobileNetworkName string, options *MobileNetworksClientGetOptions) (MobileNetworksClientGetResponse, error)

Get - Gets information about the specified mobile network. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • options - MobileNetworksClientGetOptions contains the optional parameters for the MobileNetworksClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/MobileNetworkGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMobileNetworksClient().Get(ctx, "rg1", "testMobileNetwork", 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.MobileNetwork = armmobilenetwork.MobileNetwork{
// 	Name: to.Ptr("testMobileNetwork"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.PropertiesFormat{
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		PublicLandMobileNetworkIdentifier: &armmobilenetwork.PlmnID{
// 			Mcc: to.Ptr("001"),
// 			Mnc: to.Ptr("01"),
// 		},
// 	},
// }

Output:

func (*MobileNetworksClient) NewListByResourceGroupPager 

func (client *MobileNetworksClient) NewListByResourceGroupPager(resourceGroupName string, options *MobileNetworksClientListByResourceGroupOptions) *runtime.Pager[MobileNetworksClientListByResourceGroupResponse]

NewListByResourceGroupPager - Lists all the mobile networks in a resource group.

Generated from API version 2022-11-01

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/MobileNetworkListByResourceGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMobileNetworksClient().NewListByResourceGroupPager("rg1", 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.ListResult = armmobilenetwork.ListResult{
	// 	Value: []*armmobilenetwork.MobileNetwork{
	// 		{
	// 			Name: to.Ptr("testMobileNetwork"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("eastus"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armmobilenetwork.PropertiesFormat{
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 				PublicLandMobileNetworkIdentifier: &armmobilenetwork.PlmnID{
	// 					Mcc: to.Ptr("001"),
	// 					Mnc: to.Ptr("01"),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

func (*MobileNetworksClient) NewListBySubscriptionPager 

func (client *MobileNetworksClient) NewListBySubscriptionPager(options *MobileNetworksClientListBySubscriptionOptions) *runtime.Pager[MobileNetworksClientListBySubscriptionResponse]

NewListBySubscriptionPager - Lists all the mobile networks in a subscription.

Generated from API version 2022-11-01

  • options - MobileNetworksClientListBySubscriptionOptions contains the optional parameters for the MobileNetworksClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/MobileNetworkListBySubscription.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMobileNetworksClient().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.ListResult = armmobilenetwork.ListResult{
	// 	Value: []*armmobilenetwork.MobileNetwork{
	// 		{
	// 			Name: to.Ptr("testMobileNetwork"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("eastus"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armmobilenetwork.PropertiesFormat{
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 				PublicLandMobileNetworkIdentifier: &armmobilenetwork.PlmnID{
	// 					Mcc: to.Ptr("001"),
	// 					Mnc: to.Ptr("01"),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

func (*MobileNetworksClient) UpdateTags 

func (client *MobileNetworksClient) UpdateTags(ctx context.Context, resourceGroupName string, mobileNetworkName string, parameters TagsObject, options *MobileNetworksClientUpdateTagsOptions) (MobileNetworksClientUpdateTagsResponse, error)

UpdateTags - Updates mobile network tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • parameters - Parameters supplied to update mobile network tags.
  • options - MobileNetworksClientUpdateTagsOptions contains the optional parameters for the MobileNetworksClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/MobileNetworkUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMobileNetworksClient().UpdateTags(ctx, "rg1", "testMobileNetwork", armmobilenetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, 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.MobileNetwork = armmobilenetwork.MobileNetwork{
// 	Name: to.Ptr("testMobileNetwork"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Properties: &armmobilenetwork.PropertiesFormat{
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		PublicLandMobileNetworkIdentifier: &armmobilenetwork.PlmnID{
// 			Mcc: to.Ptr("001"),
// 			Mnc: to.Ptr("01"),
// 		},
// 	},
// }

Output:

type MobileNetworksClientBeginCreateOrUpdateOptions 

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

MobileNetworksClientBeginCreateOrUpdateOptions contains the optional parameters for the MobileNetworksClient.BeginCreateOrUpdate method.

type MobileNetworksClientBeginDeleteOptions 

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

MobileNetworksClientBeginDeleteOptions contains the optional parameters for the MobileNetworksClient.BeginDelete method.

type MobileNetworksClientCreateOrUpdateResponse 

type MobileNetworksClientCreateOrUpdateResponse struct {
	MobileNetwork
}

MobileNetworksClientCreateOrUpdateResponse contains the response from method MobileNetworksClient.BeginCreateOrUpdate.

type MobileNetworksClientDeleteResponse 

type MobileNetworksClientDeleteResponse struct {
}

MobileNetworksClientDeleteResponse contains the response from method MobileNetworksClient.BeginDelete.

type MobileNetworksClientGetOptions 

type MobileNetworksClientGetOptions struct {
}

MobileNetworksClientGetOptions contains the optional parameters for the MobileNetworksClient.Get method.

type MobileNetworksClientGetResponse 

type MobileNetworksClientGetResponse struct {
	MobileNetwork
}

MobileNetworksClientGetResponse contains the response from method MobileNetworksClient.Get.

type MobileNetworksClientListByResourceGroupOptions 

type MobileNetworksClientListByResourceGroupOptions struct {
}

MobileNetworksClientListByResourceGroupOptions contains the optional parameters for the MobileNetworksClient.NewListByResourceGroupPager method.

type MobileNetworksClientListByResourceGroupResponse 

type MobileNetworksClientListByResourceGroupResponse struct {
	ListResult
}

MobileNetworksClientListByResourceGroupResponse contains the response from method MobileNetworksClient.NewListByResourceGroupPager.

type MobileNetworksClientListBySubscriptionOptions 

type MobileNetworksClientListBySubscriptionOptions struct {
}

MobileNetworksClientListBySubscriptionOptions contains the optional parameters for the MobileNetworksClient.NewListBySubscriptionPager method.

type MobileNetworksClientListBySubscriptionResponse 

type MobileNetworksClientListBySubscriptionResponse struct {
	ListResult
}

MobileNetworksClientListBySubscriptionResponse contains the response from method MobileNetworksClient.NewListBySubscriptionPager.

type MobileNetworksClientUpdateTagsOptions 

type MobileNetworksClientUpdateTagsOptions struct {
}

MobileNetworksClientUpdateTagsOptions contains the optional parameters for the MobileNetworksClient.UpdateTags method.

type MobileNetworksClientUpdateTagsResponse 

type MobileNetworksClientUpdateTagsResponse struct {
	MobileNetwork
}

MobileNetworksClientUpdateTagsResponse contains the response from method MobileNetworksClient.UpdateTags.

type NaptConfiguration 

type NaptConfiguration struct {
	// Whether NAPT is enabled for connections to this attached data network.
	Enabled *NaptEnabled

	// Maximum number of UDP and TCP pinholes that can be open simultaneously on the core interface. For 5G networks, this is
	// the N6 interface. For 4G networks, this is the SGi interface.
	PinholeLimits *int32

	// Expiry times of inactive NAPT pinholes, in seconds. All timers must be at least 1 second.
	PinholeTimeouts *PinholeTimeouts

	// Range of port numbers to use as translated ports on each translated address. If not specified and NAPT is enabled, this
	// range defaults to 1,024 - 49,999. (Ports under 1,024 should not be used because
	// these are special purpose ports reserved by IANA. Ports 50,000 and above are reserved for non-NAPT use.)
	PortRange *PortRange

	// The minimum time (in seconds) that will pass before a port that was used by a closed pinhole can be recycled for use by
	// another pinhole. All hold times must be at least 1 second.
	PortReuseHoldTime *PortReuseHoldTimes
}

NaptConfiguration - The network address and port translation settings to use for the attached data network.

func (NaptConfiguration) MarshalJSON 

func (n NaptConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NaptConfiguration.

func (*NaptConfiguration) UnmarshalJSON 

func (n *NaptConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NaptConfiguration.

type NaptEnabled 

type NaptEnabled string

NaptEnabled - Whether network address and port translation is enabled. 

const (
	// NaptEnabledDisabled - NAPT is disabled
	NaptEnabledDisabled NaptEnabled = "Disabled"
	// NaptEnabledEnabled - NAPT is enabled
	NaptEnabledEnabled NaptEnabled = "Enabled"
)

func PossibleNaptEnabledValues 

func PossibleNaptEnabledValues() []NaptEnabled

PossibleNaptEnabledValues returns the possible values for the NaptEnabled const type.

type ObsoleteVersion 

type ObsoleteVersion string

ObsoleteVersion - Indicates whether this version is obsolete. 

const (
	// ObsoleteVersionNotObsolete - This version is not obsolete for use in new packet core control plane deployments.
	ObsoleteVersionNotObsolete ObsoleteVersion = "NotObsolete"
	// ObsoleteVersionObsolete - This version is obsolete for use in new packet core control plane deployments.
	ObsoleteVersionObsolete ObsoleteVersion = "Obsolete"
)

func PossibleObsoleteVersionValues 

func PossibleObsoleteVersionValues() []ObsoleteVersion

PossibleObsoleteVersionValues returns the possible values for the ObsoleteVersion const type.

type Operation 

type Operation struct {
	// Indicates whether the operation applies to data-plane.
	IsDataAction *bool

	// READ-ONLY; The object that represents the operation.
	Display *OperationDisplay

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

Operation - Object that describes a single Microsoft.MobileNetwork operation.

func (Operation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// Description of the operation.
	Description *string

	// Operation type: Read, write, delete, etc.
	Operation *string

	// Service provider: Microsoft.MobileNetwork
	Provider *string

	// Resource on which the operation is performed: Registration definition, registration assignment etc.
	Resource *string
}

OperationDisplay - The object that represents the operation.

func (OperationDisplay) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationList 

type OperationList struct {
	// READ-ONLY; The URL to get the next set of results.
	NextLink *string

	// READ-ONLY; List of Microsoft.MobileNetwork operations.
	Value []*Operation
}

OperationList - List of the operations.

func (OperationList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationList.

func (*OperationList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationList.

type OperationsClient 

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

OperationsClient contains the methods for the Operations group. Don't use this type directly, use NewOperationsClient() instead.

func NewOperationsClient 

func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error)

NewOperationsClient creates a new instance of OperationsClient with the specified values.

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

func (*OperationsClient) NewListPager 

func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse]

NewListPager - Gets a list of the operations.

Generated from API version 2022-11-01

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/OperationList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", 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.OperationList = armmobilenetwork.OperationList{
	// 	Value: []*armmobilenetwork.Operation{
	// 		{
	// 			Name: to.Ptr("Microsoft.MobileNetwork/mobileNetworks/read"),
	// 			Display: &armmobilenetwork.OperationDisplay{
	// 				Description: to.Ptr("Gets mobileNetwork"),
	// 				Operation: to.Ptr("Get mobileNetwork"),
	// 				Provider: to.Ptr("Microsoft.MobileNetwok"),
	// 				Resource: to.Ptr("MobileNetwork"),
	// 			},
	// 			IsDataAction: to.Ptr(false),
	// 	}},
	// }
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	OperationList
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type PacketCoreControlPlane 

type PacketCoreControlPlane struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Packet core control plane Properties.
	Properties *PacketCoreControlPlanePropertiesFormat

	// The identity used to retrieve the ingress certificate from Azure key vault.
	Identity *ManagedServiceIdentity

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

PacketCoreControlPlane - Packet core control plane resource.

func (PacketCoreControlPlane) MarshalJSON 

func (p PacketCoreControlPlane) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PacketCoreControlPlane.

func (*PacketCoreControlPlane) UnmarshalJSON 

func (p *PacketCoreControlPlane) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCoreControlPlane.

type PacketCoreControlPlaneCollectDiagnosticsPackage 

type PacketCoreControlPlaneCollectDiagnosticsPackage struct {
	// REQUIRED; The Storage Account Blob URL to upload the diagnostics package to.
	StorageAccountBlobURL *string
}

PacketCoreControlPlaneCollectDiagnosticsPackage - Packet core control plane collect diagnostics package options

func (PacketCoreControlPlaneCollectDiagnosticsPackage) MarshalJSON 

func (p PacketCoreControlPlaneCollectDiagnosticsPackage) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PacketCoreControlPlaneCollectDiagnosticsPackage.

func (*PacketCoreControlPlaneCollectDiagnosticsPackage) UnmarshalJSON 

func (p *PacketCoreControlPlaneCollectDiagnosticsPackage) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCoreControlPlaneCollectDiagnosticsPackage.

type PacketCoreControlPlaneListResult 

type PacketCoreControlPlaneListResult struct {
	// A list of packet core control planes in a resource group.
	Value []*PacketCoreControlPlane

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

PacketCoreControlPlaneListResult - Response for packet core control planes API service call.

func (PacketCoreControlPlaneListResult) MarshalJSON 

func (p PacketCoreControlPlaneListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PacketCoreControlPlaneListResult.

func (*PacketCoreControlPlaneListResult) UnmarshalJSON 

func (p *PacketCoreControlPlaneListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCoreControlPlaneListResult.

type PacketCoreControlPlanePropertiesFormat 

type PacketCoreControlPlanePropertiesFormat struct {
	// REQUIRED; The control plane interface on the access network. For 5G networks, this is the N2 interface. For 4G networks,
	// this is the S1-MME interface.
	ControlPlaneAccessInterface *InterfaceProperties

	// REQUIRED; The kubernetes ingress configuration to control access to packet core diagnostics over local APIs.
	LocalDiagnosticsAccess *LocalDiagnosticsAccessConfiguration

	// REQUIRED; The platform where the packet core is deployed.
	Platform *PlatformConfiguration

	// REQUIRED; The SKU defining the throughput and SIM allowances for this packet core control plane deployment.
	SKU *BillingSKU

	// REQUIRED; Site(s) under which this packet core control plane should be deployed. The sites must be in the same location
	// as the packet core control plane.
	Sites []*SiteResourceID

	// The core network technology generation (5G core or EPC / 4G core).
	CoreNetworkTechnology *CoreNetworkType

	// Settings to allow interoperability with third party components e.g. RANs and UEs.
	InteropSettings any

	// The MTU (in bytes) signaled to the UE. The same MTU is set on the user plane data links for all data networks. The MTU
	// set on the user plane access link is calculated to be 60 bytes greater than this
	// value to allow for GTP encapsulation.
	UeMtu *int32

	// The version of the packet core software that is deployed.
	Version *string

	// READ-ONLY; The installation state of the packet core control plane resource.
	Installation *Installation

	// READ-ONLY; The provisioning state of the packet core control plane resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The previous version of the packet core software that was deployed. Used when performing the rollback action.
	RollbackVersion *string
}

PacketCoreControlPlanePropertiesFormat - Packet core control plane properties.

func (PacketCoreControlPlanePropertiesFormat) MarshalJSON 

func (p PacketCoreControlPlanePropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PacketCoreControlPlanePropertiesFormat.

func (*PacketCoreControlPlanePropertiesFormat) UnmarshalJSON 

func (p *PacketCoreControlPlanePropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCoreControlPlanePropertiesFormat.

type PacketCoreControlPlaneVersion 

type PacketCoreControlPlaneVersion struct {
	// REQUIRED; Packet core control plane version properties.
	Properties *PacketCoreControlPlaneVersionPropertiesFormat

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

PacketCoreControlPlaneVersion - Packet core control plane version resource.

func (PacketCoreControlPlaneVersion) MarshalJSON 

func (p PacketCoreControlPlaneVersion) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PacketCoreControlPlaneVersion.

func (*PacketCoreControlPlaneVersion) UnmarshalJSON 

func (p *PacketCoreControlPlaneVersion) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCoreControlPlaneVersion.

type PacketCoreControlPlaneVersionListResult 

type PacketCoreControlPlaneVersionListResult struct {
	// A list of supported packet core control plane versions.
	Value []*PacketCoreControlPlaneVersion

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

PacketCoreControlPlaneVersionListResult - Response for packet core control plane version API service call.

func (PacketCoreControlPlaneVersionListResult) MarshalJSON 

func (p PacketCoreControlPlaneVersionListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PacketCoreControlPlaneVersionListResult.

func (*PacketCoreControlPlaneVersionListResult) UnmarshalJSON 

func (p *PacketCoreControlPlaneVersionListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCoreControlPlaneVersionListResult.

type PacketCoreControlPlaneVersionPropertiesFormat 

type PacketCoreControlPlaneVersionPropertiesFormat struct {
	// Platform specific packet core control plane version properties.
	Platforms []*Platform

	// READ-ONLY; The provisioning state of the packet core control plane version resource.
	ProvisioningState *ProvisioningState
}

PacketCoreControlPlaneVersionPropertiesFormat - Packet core control plane version properties.

func (PacketCoreControlPlaneVersionPropertiesFormat) MarshalJSON 

func (p PacketCoreControlPlaneVersionPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PacketCoreControlPlaneVersionPropertiesFormat.

func (*PacketCoreControlPlaneVersionPropertiesFormat) UnmarshalJSON 

func (p *PacketCoreControlPlaneVersionPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCoreControlPlaneVersionPropertiesFormat.

type PacketCoreControlPlaneVersionsClient 

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

PacketCoreControlPlaneVersionsClient contains the methods for the PacketCoreControlPlaneVersions group. Don't use this type directly, use NewPacketCoreControlPlaneVersionsClient() instead.

func NewPacketCoreControlPlaneVersionsClient 

func NewPacketCoreControlPlaneVersionsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*PacketCoreControlPlaneVersionsClient, error)

NewPacketCoreControlPlaneVersionsClient creates a new instance of PacketCoreControlPlaneVersionsClient with the specified values.

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

func (*PacketCoreControlPlaneVersionsClient) Get 

func (client *PacketCoreControlPlaneVersionsClient) Get(ctx context.Context, versionName string, options *PacketCoreControlPlaneVersionsClientGetOptions) (PacketCoreControlPlaneVersionsClientGetResponse, error)

Get - Gets information about the specified packet core control plane version. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • versionName - The name of the packet core control plane version.
  • options - PacketCoreControlPlaneVersionsClientGetOptions contains the optional parameters for the PacketCoreControlPlaneVersionsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreControlPlaneVersionGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPacketCoreControlPlaneVersionsClient().Get(ctx, "PMN-4-11-1", 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.PacketCoreControlPlaneVersion = armmobilenetwork.PacketCoreControlPlaneVersion{
// 	Name: to.Ptr("PMN-4-11-1"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlaneVersions"),
// 	ID: to.Ptr("/providers/Microsoft.MobileNetwork/packetCoreControlPlaneVersions/PMN-4-11-1"),
// 	Properties: &armmobilenetwork.PacketCoreControlPlaneVersionPropertiesFormat{
// 		Platforms: []*armmobilenetwork.Platform{
// 			{
// 				MaximumPlatformSoftwareVersion: to.Ptr("2211"),
// 				MinimumPlatformSoftwareVersion: to.Ptr("2209"),
// 				PlatformType: to.Ptr(armmobilenetwork.PlatformTypeAKSHCI),
// 				RecommendedVersion: to.Ptr(armmobilenetwork.RecommendedVersionRecommended),
// 				VersionState: to.Ptr(armmobilenetwork.VersionStateActive),
// 		}},
// 	},
// }

Output:

func (*PacketCoreControlPlaneVersionsClient) NewListPager 

func (client *PacketCoreControlPlaneVersionsClient) NewListPager(options *PacketCoreControlPlaneVersionsClientListOptions) *runtime.Pager[PacketCoreControlPlaneVersionsClientListResponse]

NewListPager - Lists all supported packet core control planes versions.

Generated from API version 2022-11-01

  • options - PacketCoreControlPlaneVersionsClientListOptions contains the optional parameters for the PacketCoreControlPlaneVersionsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreControlPlaneVersionList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewPacketCoreControlPlaneVersionsClient().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.PacketCoreControlPlaneVersionListResult = armmobilenetwork.PacketCoreControlPlaneVersionListResult{
	// 	Value: []*armmobilenetwork.PacketCoreControlPlaneVersion{
	// 		{
	// 			Name: to.Ptr("PMN-4-9-4"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlaneVersions"),
	// 			ID: to.Ptr("/providers/Microsoft.MobileNetwork/packetCoreControlPlaneVersions/PMN-4-9-4"),
	// 			Properties: &armmobilenetwork.PacketCoreControlPlaneVersionPropertiesFormat{
	// 				Platforms: []*armmobilenetwork.Platform{
	// 					{
	// 						MaximumPlatformSoftwareVersion: to.Ptr("2211"),
	// 						MinimumPlatformSoftwareVersion: to.Ptr("2209"),
	// 						PlatformType: to.Ptr(armmobilenetwork.PlatformTypeAKSHCI),
	// 						RecommendedVersion: to.Ptr(armmobilenetwork.RecommendedVersionNotRecommended),
	// 						VersionState: to.Ptr(armmobilenetwork.VersionStateActive),
	// 				}},
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("PMN-4-10-2"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlaneVersions"),
	// 			ID: to.Ptr("/providers/Microsoft.MobileNetwork/packetCoreControlPlaneVersions/PMN-4-10-2"),
	// 			Properties: &armmobilenetwork.PacketCoreControlPlaneVersionPropertiesFormat{
	// 				Platforms: []*armmobilenetwork.Platform{
	// 					{
	// 						MaximumPlatformSoftwareVersion: to.Ptr("2212"),
	// 						MinimumPlatformSoftwareVersion: to.Ptr("2210"),
	// 						PlatformType: to.Ptr(armmobilenetwork.PlatformTypeAKSHCI),
	// 						RecommendedVersion: to.Ptr(armmobilenetwork.RecommendedVersionNotRecommended),
	// 						VersionState: to.Ptr(armmobilenetwork.VersionStateActive),
	// 				}},
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("PMN-4-11-1"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlaneVersions"),
	// 			ID: to.Ptr("/providers/Microsoft.MobileNetwork/packetCoreControlPlaneVersions/PMN-4-11-1"),
	// 			Properties: &armmobilenetwork.PacketCoreControlPlaneVersionPropertiesFormat{
	// 				Platforms: []*armmobilenetwork.Platform{
	// 					{
	// 						MaximumPlatformSoftwareVersion: to.Ptr("2301"),
	// 						MinimumPlatformSoftwareVersion: to.Ptr("2211"),
	// 						PlatformType: to.Ptr(armmobilenetwork.PlatformTypeAKSHCI),
	// 						RecommendedVersion: to.Ptr(armmobilenetwork.RecommendedVersionRecommended),
	// 						VersionState: to.Ptr(armmobilenetwork.VersionStateActive),
	// 				}},
	// 			},
	// 	}},
	// }
}

Output:

type PacketCoreControlPlaneVersionsClientGetOptions 

type PacketCoreControlPlaneVersionsClientGetOptions struct {
}

PacketCoreControlPlaneVersionsClientGetOptions contains the optional parameters for the PacketCoreControlPlaneVersionsClient.Get method.

type PacketCoreControlPlaneVersionsClientGetResponse 

type PacketCoreControlPlaneVersionsClientGetResponse struct {
	PacketCoreControlPlaneVersion
}

PacketCoreControlPlaneVersionsClientGetResponse contains the response from method PacketCoreControlPlaneVersionsClient.Get.

type PacketCoreControlPlaneVersionsClientListOptions 

type PacketCoreControlPlaneVersionsClientListOptions struct {
}

PacketCoreControlPlaneVersionsClientListOptions contains the optional parameters for the PacketCoreControlPlaneVersionsClient.NewListPager method.

type PacketCoreControlPlaneVersionsClientListResponse 

type PacketCoreControlPlaneVersionsClientListResponse struct {
	PacketCoreControlPlaneVersionListResult
}

PacketCoreControlPlaneVersionsClientListResponse contains the response from method PacketCoreControlPlaneVersionsClient.NewListPager.

type PacketCoreControlPlanesClient 

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

PacketCoreControlPlanesClient contains the methods for the PacketCoreControlPlanes group. Don't use this type directly, use NewPacketCoreControlPlanesClient() instead.

func NewPacketCoreControlPlanesClient 

func NewPacketCoreControlPlanesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PacketCoreControlPlanesClient, error)

NewPacketCoreControlPlanesClient creates a new instance of PacketCoreControlPlanesClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*PacketCoreControlPlanesClient) BeginCollectDiagnosticsPackage 

func (client *PacketCoreControlPlanesClient) BeginCollectDiagnosticsPackage(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, parameters PacketCoreControlPlaneCollectDiagnosticsPackage, options *PacketCoreControlPlanesClientBeginCollectDiagnosticsPackageOptions) (*runtime.Poller[PacketCoreControlPlanesClientCollectDiagnosticsPackageResponse], error)

BeginCollectDiagnosticsPackage - Collect a diagnostics package for the specified packet core control plane. This action will upload the diagnostics to a storage account. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • parameters - Parameters supplied to the packet core control plane collect diagnostics package operation.
  • options - PacketCoreControlPlanesClientBeginCollectDiagnosticsPackageOptions contains the optional parameters for the PacketCoreControlPlanesClient.BeginCollectDiagnosticsPackage method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreControlPlaneCollectDiagnosticsPackage.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPacketCoreControlPlanesClient().BeginCollectDiagnosticsPackage(ctx, "rg1", "TestPacketCoreCP", armmobilenetwork.PacketCoreControlPlaneCollectDiagnosticsPackage{
	StorageAccountBlobURL: to.Ptr("https://contosoaccount.blob.core.windows.net/container/diagnosticsPackage.zip"),
}, 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.AsyncOperationStatus = armmobilenetwork.AsyncOperationStatus{
// 	Name: to.Ptr("testOperation"),
// 	EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-19T03:38:07.000Z"); return t}()),
// 	ID: to.Ptr("/providers/Microsoft.MobileNetwork/locations/testLocation/operationStatuses/testOperation"),
// 	StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-19T03:36:07.000Z"); return t}()),
// 	Status: to.Ptr("Succeeded"),
// }

Output:

func (*PacketCoreControlPlanesClient) BeginCreateOrUpdate 

func (client *PacketCoreControlPlanesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, parameters PacketCoreControlPlane, options *PacketCoreControlPlanesClientBeginCreateOrUpdateOptions) (*runtime.Poller[PacketCoreControlPlanesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a packet core control plane. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • parameters - Parameters supplied to the create or update packet core control plane operation.
  • options - PacketCoreControlPlanesClientBeginCreateOrUpdateOptions contains the optional parameters for the PacketCoreControlPlanesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreControlPlaneCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPacketCoreControlPlanesClient().BeginCreateOrUpdate(ctx, "rg1", "TestPacketCoreCP", armmobilenetwork.PacketCoreControlPlane{
	Location: to.Ptr("eastus"),
	Properties: &armmobilenetwork.PacketCoreControlPlanePropertiesFormat{
		ControlPlaneAccessInterface: &armmobilenetwork.InterfaceProperties{
			Name: to.Ptr("N2"),
		},
		CoreNetworkTechnology: to.Ptr(armmobilenetwork.CoreNetworkTypeFiveGC),
		LocalDiagnosticsAccess: &armmobilenetwork.LocalDiagnosticsAccessConfiguration{
			AuthenticationType: to.Ptr(armmobilenetwork.AuthenticationTypeAAD),
			HTTPSServerCertificate: &armmobilenetwork.HTTPSServerCertificate{
				CertificateURL: to.Ptr("https://contosovault.vault.azure.net/certificates/ingress"),
			},
		},
		Platform: &armmobilenetwork.PlatformConfiguration{
			Type: to.Ptr(armmobilenetwork.PlatformTypeAKSHCI),
			AzureStackEdgeDevice: &armmobilenetwork.AzureStackEdgeDeviceResourceID{
				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
			},
			ConnectedCluster: &armmobilenetwork.ConnectedClusterResourceID{
				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/TestConnectedCluster"),
			},
			CustomLocation: &armmobilenetwork.CustomLocationResourceID{
				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.ExtendedLocation/customLocations/TestCustomLocation"),
			},
		},
		Sites: []*armmobilenetwork.SiteResourceID{
			{
				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite"),
			}},
		SKU:     to.Ptr(armmobilenetwork.BillingSKUG0),
		UeMtu:   to.Ptr[int32](1600),
		Version: to.Ptr("0.2.0"),
	},
}, 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.PacketCoreControlPlane = armmobilenetwork.PacketCoreControlPlane{
// 	Name: to.Ptr("TestPacketCoreCP"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlane"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.PacketCoreControlPlanePropertiesFormat{
// 		ControlPlaneAccessInterface: &armmobilenetwork.InterfaceProperties{
// 			Name: to.Ptr("N2"),
// 		},
// 		CoreNetworkTechnology: to.Ptr(armmobilenetwork.CoreNetworkTypeFiveGC),
// 		Installation: &armmobilenetwork.Installation{
// 			State: to.Ptr(armmobilenetwork.InstallationStateInstalled),
// 		},
// 		LocalDiagnosticsAccess: &armmobilenetwork.LocalDiagnosticsAccessConfiguration{
// 			AuthenticationType: to.Ptr(armmobilenetwork.AuthenticationTypeAAD),
// 			HTTPSServerCertificate: &armmobilenetwork.HTTPSServerCertificate{
// 				CertificateURL: to.Ptr("https://contosovault.vault.azure.net/certificates/ingress"),
// 				Provisioning: &armmobilenetwork.CertificateProvisioning{
// 					State: to.Ptr(armmobilenetwork.CertificateProvisioningStateNotProvisioned),
// 				},
// 			},
// 		},
// 		Platform: &armmobilenetwork.PlatformConfiguration{
// 			Type: to.Ptr(armmobilenetwork.PlatformTypeAKSHCI),
// 			AzureStackEdgeDevice: &armmobilenetwork.AzureStackEdgeDeviceResourceID{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
// 			},
// 			AzureStackEdgeDevices: []*armmobilenetwork.AzureStackEdgeDeviceResourceID{
// 				{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
// 				},
// 				{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice2"),
// 			}},
// 			ConnectedCluster: &armmobilenetwork.ConnectedClusterResourceID{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/TestConnectedCluster"),
// 			},
// 			CustomLocation: &armmobilenetwork.CustomLocationResourceID{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.ExtendedLocation/customLocations/TestCustomLocation"),
// 			},
// 		},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		Sites: []*armmobilenetwork.SiteResourceID{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite"),
// 		}},
// 		SKU: to.Ptr(armmobilenetwork.BillingSKUG0),
// 		UeMtu: to.Ptr[int32](1600),
// 		Version: to.Ptr("0.2.0"),
// 	},
// }

Output:

func (*PacketCoreControlPlanesClient) BeginDelete 

func (client *PacketCoreControlPlanesClient) BeginDelete(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, options *PacketCoreControlPlanesClientBeginDeleteOptions) (*runtime.Poller[PacketCoreControlPlanesClientDeleteResponse], error)

BeginDelete - Deletes the specified packet core control plane. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • options - PacketCoreControlPlanesClientBeginDeleteOptions contains the optional parameters for the PacketCoreControlPlanesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreControlPlaneDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPacketCoreControlPlanesClient().BeginDelete(ctx, "rg1", "TestPacketCoreCP", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*PacketCoreControlPlanesClient) BeginReinstall 

func (client *PacketCoreControlPlanesClient) BeginReinstall(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, options *PacketCoreControlPlanesClientBeginReinstallOptions) (*runtime.Poller[PacketCoreControlPlanesClientReinstallResponse], error)

BeginReinstall - Reinstall the specified packet core control plane. This action will remove any transaction state from the packet core to return it to a known state. This action will cause a service outage. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • options - PacketCoreControlPlanesClientBeginReinstallOptions contains the optional parameters for the PacketCoreControlPlanesClient.BeginReinstall method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreControlPlaneReinstall.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPacketCoreControlPlanesClient().BeginReinstall(ctx, "rg1", "TestPacketCoreCP", 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.AsyncOperationStatus = armmobilenetwork.AsyncOperationStatus{
// 	Name: to.Ptr("testOperation"),
// 	EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-19T03:38:07.000Z"); return t}()),
// 	ID: to.Ptr("/providers/Microsoft.MobileNetwork/locations/testLocation/operationStatuses/testOperation"),
// 	StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-19T03:36:07.000Z"); return t}()),
// 	Status: to.Ptr("Succeeded"),
// }

Output:

func (*PacketCoreControlPlanesClient) BeginRollback 

func (client *PacketCoreControlPlanesClient) BeginRollback(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, options *PacketCoreControlPlanesClientBeginRollbackOptions) (*runtime.Poller[PacketCoreControlPlanesClientRollbackResponse], error)

BeginRollback - Roll back the specified packet core control plane to the previous version, "rollbackVersion". Multiple consecutive rollbacks are not possible. This action may cause a service outage. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • options - PacketCoreControlPlanesClientBeginRollbackOptions contains the optional parameters for the PacketCoreControlPlanesClient.BeginRollback method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreControlPlaneRollback.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPacketCoreControlPlanesClient().BeginRollback(ctx, "rg1", "TestPacketCoreCP", 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.AsyncOperationStatus = armmobilenetwork.AsyncOperationStatus{
// 	Name: to.Ptr("testOperation"),
// 	EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-19T03:38:07.000Z"); return t}()),
// 	ID: to.Ptr("/providers/Microsoft.MobileNetwork/locations/testLocation/operationStatuses/testOperation"),
// 	StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-19T03:36:07.000Z"); return t}()),
// 	Status: to.Ptr("Succeeded"),
// }

Output:

func (*PacketCoreControlPlanesClient) Get 

func (client *PacketCoreControlPlanesClient) Get(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, options *PacketCoreControlPlanesClientGetOptions) (PacketCoreControlPlanesClientGetResponse, error)

Get - Gets information about the specified packet core control plane. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • options - PacketCoreControlPlanesClientGetOptions contains the optional parameters for the PacketCoreControlPlanesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreControlPlaneGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPacketCoreControlPlanesClient().Get(ctx, "rg1", "TestPacketCoreCP", 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.PacketCoreControlPlane = armmobilenetwork.PacketCoreControlPlane{
// 	Name: to.Ptr("TestPacketCoreCP"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlane"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.PacketCoreControlPlanePropertiesFormat{
// 		ControlPlaneAccessInterface: &armmobilenetwork.InterfaceProperties{
// 			Name: to.Ptr("N2"),
// 		},
// 		CoreNetworkTechnology: to.Ptr(armmobilenetwork.CoreNetworkTypeFiveGC),
// 		Installation: &armmobilenetwork.Installation{
// 			Operation: &armmobilenetwork.AsyncOperationID{
// 				ID: to.Ptr("/providers/Microsoft.MobileNetwork/locations/EASTUS/operationStatuses/abc"),
// 			},
// 			State: to.Ptr(armmobilenetwork.InstallationStateInstalling),
// 		},
// 		LocalDiagnosticsAccess: &armmobilenetwork.LocalDiagnosticsAccessConfiguration{
// 			AuthenticationType: to.Ptr(armmobilenetwork.AuthenticationTypePassword),
// 			HTTPSServerCertificate: &armmobilenetwork.HTTPSServerCertificate{
// 				CertificateURL: to.Ptr("https://contosovault.vault.azure.net/certificates/ingress"),
// 				Provisioning: &armmobilenetwork.CertificateProvisioning{
// 					State: to.Ptr(armmobilenetwork.CertificateProvisioningStateNotProvisioned),
// 				},
// 			},
// 		},
// 		Platform: &armmobilenetwork.PlatformConfiguration{
// 			Type: to.Ptr(armmobilenetwork.PlatformTypeAKSHCI),
// 			AzureStackEdgeDevice: &armmobilenetwork.AzureStackEdgeDeviceResourceID{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
// 			},
// 			AzureStackEdgeDevices: []*armmobilenetwork.AzureStackEdgeDeviceResourceID{
// 				{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
// 				},
// 				{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice2"),
// 			}},
// 			ConnectedCluster: &armmobilenetwork.ConnectedClusterResourceID{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/TestConnectedCluster"),
// 			},
// 			CustomLocation: &armmobilenetwork.CustomLocationResourceID{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.ExtendedLocation/customLocations/TestCustomLocation"),
// 			},
// 		},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		RollbackVersion: to.Ptr("0.1.0"),
// 		Sites: []*armmobilenetwork.SiteResourceID{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite"),
// 		}},
// 		SKU: to.Ptr(armmobilenetwork.BillingSKUG0),
// 		UeMtu: to.Ptr[int32](1600),
// 		Version: to.Ptr("0.2.0"),
// 	},
// }

Output:

func (*PacketCoreControlPlanesClient) NewListByResourceGroupPager 

func (client *PacketCoreControlPlanesClient) NewListByResourceGroupPager(resourceGroupName string, options *PacketCoreControlPlanesClientListByResourceGroupOptions) *runtime.Pager[PacketCoreControlPlanesClientListByResourceGroupResponse]

NewListByResourceGroupPager - Lists all the packet core control planes in a resource group.

Generated from API version 2022-11-01

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreControlPlaneListByResourceGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewPacketCoreControlPlanesClient().NewListByResourceGroupPager("rg1", 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.PacketCoreControlPlaneListResult = armmobilenetwork.PacketCoreControlPlaneListResult{
	// 	Value: []*armmobilenetwork.PacketCoreControlPlane{
	// 		{
	// 			Name: to.Ptr("TestPacketCoreCP"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlane"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("eastus"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armmobilenetwork.PacketCoreControlPlanePropertiesFormat{
	// 				ControlPlaneAccessInterface: &armmobilenetwork.InterfaceProperties{
	// 					Name: to.Ptr("N2"),
	// 				},
	// 				CoreNetworkTechnology: to.Ptr(armmobilenetwork.CoreNetworkTypeFiveGC),
	// 				Installation: &armmobilenetwork.Installation{
	// 					State: to.Ptr(armmobilenetwork.InstallationStateInstalled),
	// 				},
	// 				LocalDiagnosticsAccess: &armmobilenetwork.LocalDiagnosticsAccessConfiguration{
	// 					AuthenticationType: to.Ptr(armmobilenetwork.AuthenticationTypePassword),
	// 					HTTPSServerCertificate: &armmobilenetwork.HTTPSServerCertificate{
	// 						CertificateURL: to.Ptr("https://contosovault.vault.azure.net/certificates/ingress"),
	// 						Provisioning: &armmobilenetwork.CertificateProvisioning{
	// 							State: to.Ptr(armmobilenetwork.CertificateProvisioningStateNotProvisioned),
	// 						},
	// 					},
	// 				},
	// 				Platform: &armmobilenetwork.PlatformConfiguration{
	// 					Type: to.Ptr(armmobilenetwork.PlatformTypeAKSHCI),
	// 					AzureStackEdgeDevice: &armmobilenetwork.AzureStackEdgeDeviceResourceID{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
	// 					},
	// 					AzureStackEdgeDevices: []*armmobilenetwork.AzureStackEdgeDeviceResourceID{
	// 						{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
	// 						},
	// 						{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice2"),
	// 					}},
	// 					ConnectedCluster: &armmobilenetwork.ConnectedClusterResourceID{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/TestConnectedCluster"),
	// 					},
	// 					CustomLocation: &armmobilenetwork.CustomLocationResourceID{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.ExtendedLocation/customLocations/TestCustomLocation"),
	// 					},
	// 				},
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 				RollbackVersion: to.Ptr("0.1.0"),
	// 				Sites: []*armmobilenetwork.SiteResourceID{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite"),
	// 				}},
	// 				SKU: to.Ptr(armmobilenetwork.BillingSKUG0),
	// 				UeMtu: to.Ptr[int32](1600),
	// 				Version: to.Ptr("0.2.0"),
	// 			},
	// 	}},
	// }
}

Output:

func (*PacketCoreControlPlanesClient) NewListBySubscriptionPager 

func (client *PacketCoreControlPlanesClient) NewListBySubscriptionPager(options *PacketCoreControlPlanesClientListBySubscriptionOptions) *runtime.Pager[PacketCoreControlPlanesClientListBySubscriptionResponse]

NewListBySubscriptionPager - Lists all the packet core control planes in a subscription.

Generated from API version 2022-11-01

  • options - PacketCoreControlPlanesClientListBySubscriptionOptions contains the optional parameters for the PacketCoreControlPlanesClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreControlPlaneListBySubscription.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewPacketCoreControlPlanesClient().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.PacketCoreControlPlaneListResult = armmobilenetwork.PacketCoreControlPlaneListResult{
	// 	Value: []*armmobilenetwork.PacketCoreControlPlane{
	// 		{
	// 			Name: to.Ptr("TestPacketCoreCP"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlane"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("eastus"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armmobilenetwork.PacketCoreControlPlanePropertiesFormat{
	// 				ControlPlaneAccessInterface: &armmobilenetwork.InterfaceProperties{
	// 					Name: to.Ptr("N2"),
	// 				},
	// 				CoreNetworkTechnology: to.Ptr(armmobilenetwork.CoreNetworkTypeFiveGC),
	// 				Installation: &armmobilenetwork.Installation{
	// 					State: to.Ptr(armmobilenetwork.InstallationStateInstalled),
	// 				},
	// 				LocalDiagnosticsAccess: &armmobilenetwork.LocalDiagnosticsAccessConfiguration{
	// 					AuthenticationType: to.Ptr(armmobilenetwork.AuthenticationTypePassword),
	// 					HTTPSServerCertificate: &armmobilenetwork.HTTPSServerCertificate{
	// 						CertificateURL: to.Ptr("https://contosovault.vault.azure.net/certificates/ingress"),
	// 						Provisioning: &armmobilenetwork.CertificateProvisioning{
	// 							State: to.Ptr(armmobilenetwork.CertificateProvisioningStateNotProvisioned),
	// 						},
	// 					},
	// 				},
	// 				Platform: &armmobilenetwork.PlatformConfiguration{
	// 					Type: to.Ptr(armmobilenetwork.PlatformTypeAKSHCI),
	// 					AzureStackEdgeDevice: &armmobilenetwork.AzureStackEdgeDeviceResourceID{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
	// 					},
	// 					AzureStackEdgeDevices: []*armmobilenetwork.AzureStackEdgeDeviceResourceID{
	// 						{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
	// 						},
	// 						{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice2"),
	// 					}},
	// 					ConnectedCluster: &armmobilenetwork.ConnectedClusterResourceID{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/TestConnectedCluster"),
	// 					},
	// 					CustomLocation: &armmobilenetwork.CustomLocationResourceID{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.ExtendedLocation/customLocations/TestCustomLocation"),
	// 					},
	// 				},
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 				RollbackVersion: to.Ptr("0.1.0"),
	// 				Sites: []*armmobilenetwork.SiteResourceID{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite"),
	// 				}},
	// 				SKU: to.Ptr(armmobilenetwork.BillingSKUG0),
	// 				UeMtu: to.Ptr[int32](1600),
	// 				Version: to.Ptr("0.2.0"),
	// 			},
	// 	}},
	// }
}

Output:

func (*PacketCoreControlPlanesClient) UpdateTags 

func (client *PacketCoreControlPlanesClient) UpdateTags(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, parameters TagsObject, options *PacketCoreControlPlanesClientUpdateTagsOptions) (PacketCoreControlPlanesClientUpdateTagsResponse, error)

UpdateTags - Updates packet core control planes tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • parameters - Parameters supplied to update packet core control plane tags.
  • options - PacketCoreControlPlanesClientUpdateTagsOptions contains the optional parameters for the PacketCoreControlPlanesClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreControlPlaneUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPacketCoreControlPlanesClient().UpdateTags(ctx, "rg1", "TestPacketCoreCP", armmobilenetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, 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.PacketCoreControlPlane = armmobilenetwork.PacketCoreControlPlane{
// 	Name: to.Ptr("TestPacketCoreCP"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlane"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Properties: &armmobilenetwork.PacketCoreControlPlanePropertiesFormat{
// 		ControlPlaneAccessInterface: &armmobilenetwork.InterfaceProperties{
// 			Name: to.Ptr("N2"),
// 		},
// 		CoreNetworkTechnology: to.Ptr(armmobilenetwork.CoreNetworkTypeFiveGC),
// 		Installation: &armmobilenetwork.Installation{
// 			State: to.Ptr(armmobilenetwork.InstallationStateInstalled),
// 		},
// 		LocalDiagnosticsAccess: &armmobilenetwork.LocalDiagnosticsAccessConfiguration{
// 			AuthenticationType: to.Ptr(armmobilenetwork.AuthenticationTypePassword),
// 			HTTPSServerCertificate: &armmobilenetwork.HTTPSServerCertificate{
// 				CertificateURL: to.Ptr("https://contosovault.vault.azure.net/certificates/ingress"),
// 				Provisioning: &armmobilenetwork.CertificateProvisioning{
// 					State: to.Ptr(armmobilenetwork.CertificateProvisioningStateNotProvisioned),
// 				},
// 			},
// 		},
// 		Platform: &armmobilenetwork.PlatformConfiguration{
// 			Type: to.Ptr(armmobilenetwork.PlatformTypeAKSHCI),
// 			AzureStackEdgeDevice: &armmobilenetwork.AzureStackEdgeDeviceResourceID{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
// 			},
// 			AzureStackEdgeDevices: []*armmobilenetwork.AzureStackEdgeDeviceResourceID{
// 				{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
// 				},
// 				{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice2"),
// 			}},
// 			ConnectedCluster: &armmobilenetwork.ConnectedClusterResourceID{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/TestConnectedCluster"),
// 			},
// 			CustomLocation: &armmobilenetwork.CustomLocationResourceID{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.ExtendedLocation/customLocations/TestCustomLocation"),
// 			},
// 		},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		RollbackVersion: to.Ptr("0.1.0"),
// 		Sites: []*armmobilenetwork.SiteResourceID{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite"),
// 		}},
// 		SKU: to.Ptr(armmobilenetwork.BillingSKUG0),
// 		UeMtu: to.Ptr[int32](1600),
// 		Version: to.Ptr("0.2.0"),
// 	},
// }

Output:

type PacketCoreControlPlanesClientBeginCollectDiagnosticsPackageOptions 

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

PacketCoreControlPlanesClientBeginCollectDiagnosticsPackageOptions contains the optional parameters for the PacketCoreControlPlanesClient.BeginCollectDiagnosticsPackage method.

type PacketCoreControlPlanesClientBeginCreateOrUpdateOptions 

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

PacketCoreControlPlanesClientBeginCreateOrUpdateOptions contains the optional parameters for the PacketCoreControlPlanesClient.BeginCreateOrUpdate method.

type PacketCoreControlPlanesClientBeginDeleteOptions 

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

PacketCoreControlPlanesClientBeginDeleteOptions contains the optional parameters for the PacketCoreControlPlanesClient.BeginDelete method.

type PacketCoreControlPlanesClientBeginReinstallOptions 

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

PacketCoreControlPlanesClientBeginReinstallOptions contains the optional parameters for the PacketCoreControlPlanesClient.BeginReinstall method.

type PacketCoreControlPlanesClientBeginRollbackOptions 

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

PacketCoreControlPlanesClientBeginRollbackOptions contains the optional parameters for the PacketCoreControlPlanesClient.BeginRollback method.

type PacketCoreControlPlanesClientCollectDiagnosticsPackageResponse 

type PacketCoreControlPlanesClientCollectDiagnosticsPackageResponse struct {
	AsyncOperationStatus
}

PacketCoreControlPlanesClientCollectDiagnosticsPackageResponse contains the response from method PacketCoreControlPlanesClient.BeginCollectDiagnosticsPackage.

type PacketCoreControlPlanesClientCreateOrUpdateResponse 

type PacketCoreControlPlanesClientCreateOrUpdateResponse struct {
	PacketCoreControlPlane
}

PacketCoreControlPlanesClientCreateOrUpdateResponse contains the response from method PacketCoreControlPlanesClient.BeginCreateOrUpdate.

type PacketCoreControlPlanesClientDeleteResponse 

type PacketCoreControlPlanesClientDeleteResponse struct {
}

PacketCoreControlPlanesClientDeleteResponse contains the response from method PacketCoreControlPlanesClient.BeginDelete.

type PacketCoreControlPlanesClientGetOptions 

type PacketCoreControlPlanesClientGetOptions struct {
}

PacketCoreControlPlanesClientGetOptions contains the optional parameters for the PacketCoreControlPlanesClient.Get method.

type PacketCoreControlPlanesClientGetResponse 

type PacketCoreControlPlanesClientGetResponse struct {
	PacketCoreControlPlane
}

PacketCoreControlPlanesClientGetResponse contains the response from method PacketCoreControlPlanesClient.Get.

type PacketCoreControlPlanesClientListByResourceGroupOptions 

type PacketCoreControlPlanesClientListByResourceGroupOptions struct {
}

PacketCoreControlPlanesClientListByResourceGroupOptions contains the optional parameters for the PacketCoreControlPlanesClient.NewListByResourceGroupPager method.

type PacketCoreControlPlanesClientListByResourceGroupResponse 

type PacketCoreControlPlanesClientListByResourceGroupResponse struct {
	PacketCoreControlPlaneListResult
}

PacketCoreControlPlanesClientListByResourceGroupResponse contains the response from method PacketCoreControlPlanesClient.NewListByResourceGroupPager.

type PacketCoreControlPlanesClientListBySubscriptionOptions 

type PacketCoreControlPlanesClientListBySubscriptionOptions struct {
}

PacketCoreControlPlanesClientListBySubscriptionOptions contains the optional parameters for the PacketCoreControlPlanesClient.NewListBySubscriptionPager method.

type PacketCoreControlPlanesClientListBySubscriptionResponse 

type PacketCoreControlPlanesClientListBySubscriptionResponse struct {
	PacketCoreControlPlaneListResult
}

PacketCoreControlPlanesClientListBySubscriptionResponse contains the response from method PacketCoreControlPlanesClient.NewListBySubscriptionPager.

type PacketCoreControlPlanesClientReinstallResponse 

type PacketCoreControlPlanesClientReinstallResponse struct {
	AsyncOperationStatus
}

PacketCoreControlPlanesClientReinstallResponse contains the response from method PacketCoreControlPlanesClient.BeginReinstall.

type PacketCoreControlPlanesClientRollbackResponse 

type PacketCoreControlPlanesClientRollbackResponse struct {
	AsyncOperationStatus
}

PacketCoreControlPlanesClientRollbackResponse contains the response from method PacketCoreControlPlanesClient.BeginRollback.

type PacketCoreControlPlanesClientUpdateTagsOptions 

type PacketCoreControlPlanesClientUpdateTagsOptions struct {
}

PacketCoreControlPlanesClientUpdateTagsOptions contains the optional parameters for the PacketCoreControlPlanesClient.UpdateTags method.

type PacketCoreControlPlanesClientUpdateTagsResponse 

type PacketCoreControlPlanesClientUpdateTagsResponse struct {
	PacketCoreControlPlane
}

PacketCoreControlPlanesClientUpdateTagsResponse contains the response from method PacketCoreControlPlanesClient.UpdateTags.

type PacketCoreDataPlane 

type PacketCoreDataPlane struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Packet core data plane Properties.
	Properties *PacketCoreDataPlanePropertiesFormat

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

PacketCoreDataPlane - Packet core data plane resource. Must be created in the same location as its parent packet core control plane.

func (PacketCoreDataPlane) MarshalJSON 

func (p PacketCoreDataPlane) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PacketCoreDataPlane.

func (*PacketCoreDataPlane) UnmarshalJSON 

func (p *PacketCoreDataPlane) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCoreDataPlane.

type PacketCoreDataPlaneListResult 

type PacketCoreDataPlaneListResult struct {
	// A list of packet core data planes in a resource group.
	Value []*PacketCoreDataPlane

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

PacketCoreDataPlaneListResult - Response for packet core data planes API service call.

func (PacketCoreDataPlaneListResult) MarshalJSON 

func (p PacketCoreDataPlaneListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PacketCoreDataPlaneListResult.

func (*PacketCoreDataPlaneListResult) UnmarshalJSON 

func (p *PacketCoreDataPlaneListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCoreDataPlaneListResult.

type PacketCoreDataPlanePropertiesFormat 

type PacketCoreDataPlanePropertiesFormat struct {
	// REQUIRED; The user plane interface on the access network. For 5G networks, this is the N3 interface. For 4G networks, this
	// is the S1-U interface.
	UserPlaneAccessInterface *InterfaceProperties

	// READ-ONLY; The provisioning state of the packet core data plane resource.
	ProvisioningState *ProvisioningState
}

PacketCoreDataPlanePropertiesFormat - Packet core data plane properties.

func (PacketCoreDataPlanePropertiesFormat) MarshalJSON 

func (p PacketCoreDataPlanePropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PacketCoreDataPlanePropertiesFormat.

func (*PacketCoreDataPlanePropertiesFormat) UnmarshalJSON 

func (p *PacketCoreDataPlanePropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCoreDataPlanePropertiesFormat.

type PacketCoreDataPlanesClient 

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

PacketCoreDataPlanesClient contains the methods for the PacketCoreDataPlanes group. Don't use this type directly, use NewPacketCoreDataPlanesClient() instead.

func NewPacketCoreDataPlanesClient 

func NewPacketCoreDataPlanesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PacketCoreDataPlanesClient, error)

NewPacketCoreDataPlanesClient creates a new instance of PacketCoreDataPlanesClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*PacketCoreDataPlanesClient) BeginCreateOrUpdate 

func (client *PacketCoreDataPlanesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, packetCoreDataPlaneName string, parameters PacketCoreDataPlane, options *PacketCoreDataPlanesClientBeginCreateOrUpdateOptions) (*runtime.Poller[PacketCoreDataPlanesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a packet core data plane. Must be created in the same location as its parent packet core control plane. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • packetCoreDataPlaneName - The name of the packet core data plane.
  • parameters - Parameters supplied to the create or update packet core data plane operation.
  • options - PacketCoreDataPlanesClientBeginCreateOrUpdateOptions contains the optional parameters for the PacketCoreDataPlanesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreDataPlaneCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPacketCoreDataPlanesClient().BeginCreateOrUpdate(ctx, "rg1", "testPacketCoreCP", "testPacketCoreDP", armmobilenetwork.PacketCoreDataPlane{
	Location: to.Ptr("eastus"),
	Properties: &armmobilenetwork.PacketCoreDataPlanePropertiesFormat{
		UserPlaneAccessInterface: &armmobilenetwork.InterfaceProperties{
			Name: to.Ptr("N3"),
		},
	},
}, 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.PacketCoreDataPlane = armmobilenetwork.PacketCoreDataPlane{
// 	Name: to.Ptr("TestPacketCoreDP"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/packetCoreDataPlane"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.PacketCoreDataPlanePropertiesFormat{
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		UserPlaneAccessInterface: &armmobilenetwork.InterfaceProperties{
// 			Name: to.Ptr("N3"),
// 		},
// 	},
// }

Output:

func (*PacketCoreDataPlanesClient) BeginDelete 

func (client *PacketCoreDataPlanesClient) BeginDelete(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, packetCoreDataPlaneName string, options *PacketCoreDataPlanesClientBeginDeleteOptions) (*runtime.Poller[PacketCoreDataPlanesClientDeleteResponse], error)

BeginDelete - Deletes the specified packet core data plane. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • packetCoreDataPlaneName - The name of the packet core data plane.
  • options - PacketCoreDataPlanesClientBeginDeleteOptions contains the optional parameters for the PacketCoreDataPlanesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreDataPlaneDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPacketCoreDataPlanesClient().BeginDelete(ctx, "rg1", "testPacketCoreCP", "testPacketCoreDP", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*PacketCoreDataPlanesClient) Get 

func (client *PacketCoreDataPlanesClient) Get(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, packetCoreDataPlaneName string, options *PacketCoreDataPlanesClientGetOptions) (PacketCoreDataPlanesClientGetResponse, error)

Get - Gets information about the specified packet core data plane. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • packetCoreDataPlaneName - The name of the packet core data plane.
  • options - PacketCoreDataPlanesClientGetOptions contains the optional parameters for the PacketCoreDataPlanesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreDataPlaneGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPacketCoreDataPlanesClient().Get(ctx, "rg1", "testPacketCoreCP", "testPacketCoreDP", 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.PacketCoreDataPlane = armmobilenetwork.PacketCoreDataPlane{
// 	Name: to.Ptr("TestPacketCoreDP"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/packetCoreDataPlane"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.PacketCoreDataPlanePropertiesFormat{
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		UserPlaneAccessInterface: &armmobilenetwork.InterfaceProperties{
// 			Name: to.Ptr("N3"),
// 		},
// 	},
// }

Output:

func (*PacketCoreDataPlanesClient) NewListByPacketCoreControlPlanePager 

func (client *PacketCoreDataPlanesClient) NewListByPacketCoreControlPlanePager(resourceGroupName string, packetCoreControlPlaneName string, options *PacketCoreDataPlanesClientListByPacketCoreControlPlaneOptions) *runtime.Pager[PacketCoreDataPlanesClientListByPacketCoreControlPlaneResponse]

NewListByPacketCoreControlPlanePager - Lists all the packet core data planes associated with a packet core control plane.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • options - PacketCoreDataPlanesClientListByPacketCoreControlPlaneOptions contains the optional parameters for the PacketCoreDataPlanesClient.NewListByPacketCoreControlPlanePager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreDataPlaneListByPacketCoreControlPlane.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewPacketCoreDataPlanesClient().NewListByPacketCoreControlPlanePager("rg1", "testPacketCoreCP", 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.PacketCoreDataPlaneListResult = armmobilenetwork.PacketCoreDataPlaneListResult{
	// 	Value: []*armmobilenetwork.PacketCoreDataPlane{
	// 		{
	// 			Name: to.Ptr("TestPacketCoreDP"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/packetCoreDataPlane"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("eastus"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armmobilenetwork.PacketCoreDataPlanePropertiesFormat{
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 				UserPlaneAccessInterface: &armmobilenetwork.InterfaceProperties{
	// 					Name: to.Ptr("N3"),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

func (*PacketCoreDataPlanesClient) UpdateTags 

func (client *PacketCoreDataPlanesClient) UpdateTags(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, packetCoreDataPlaneName string, parameters TagsObject, options *PacketCoreDataPlanesClientUpdateTagsOptions) (PacketCoreDataPlanesClientUpdateTagsResponse, error)

UpdateTags - Updates packet core data planes tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • packetCoreDataPlaneName - The name of the packet core data plane.
  • parameters - Parameters supplied to update packet core data plane tags.
  • options - PacketCoreDataPlanesClientUpdateTagsOptions contains the optional parameters for the PacketCoreDataPlanesClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/PacketCoreDataPlaneUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPacketCoreDataPlanesClient().UpdateTags(ctx, "rg1", "testPacketCoreCP", "testPacketCoreDP", armmobilenetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, 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.PacketCoreDataPlane = armmobilenetwork.PacketCoreDataPlane{
// 	Name: to.Ptr("TestPacketCoreDP"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/packetCoreDataPlane"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Properties: &armmobilenetwork.PacketCoreDataPlanePropertiesFormat{
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		UserPlaneAccessInterface: &armmobilenetwork.InterfaceProperties{
// 			Name: to.Ptr("N3"),
// 		},
// 	},
// }

Output:

type PacketCoreDataPlanesClientBeginCreateOrUpdateOptions 

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

PacketCoreDataPlanesClientBeginCreateOrUpdateOptions contains the optional parameters for the PacketCoreDataPlanesClient.BeginCreateOrUpdate method.

type PacketCoreDataPlanesClientBeginDeleteOptions 

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

PacketCoreDataPlanesClientBeginDeleteOptions contains the optional parameters for the PacketCoreDataPlanesClient.BeginDelete method.

type PacketCoreDataPlanesClientCreateOrUpdateResponse 

type PacketCoreDataPlanesClientCreateOrUpdateResponse struct {
	PacketCoreDataPlane
}

PacketCoreDataPlanesClientCreateOrUpdateResponse contains the response from method PacketCoreDataPlanesClient.BeginCreateOrUpdate.

type PacketCoreDataPlanesClientDeleteResponse 

type PacketCoreDataPlanesClientDeleteResponse struct {
}

PacketCoreDataPlanesClientDeleteResponse contains the response from method PacketCoreDataPlanesClient.BeginDelete.

type PacketCoreDataPlanesClientGetOptions 

type PacketCoreDataPlanesClientGetOptions struct {
}

PacketCoreDataPlanesClientGetOptions contains the optional parameters for the PacketCoreDataPlanesClient.Get method.

type PacketCoreDataPlanesClientGetResponse 

type PacketCoreDataPlanesClientGetResponse struct {
	PacketCoreDataPlane
}

PacketCoreDataPlanesClientGetResponse contains the response from method PacketCoreDataPlanesClient.Get.

type PacketCoreDataPlanesClientListByPacketCoreControlPlaneOptions 

type PacketCoreDataPlanesClientListByPacketCoreControlPlaneOptions struct {
}

PacketCoreDataPlanesClientListByPacketCoreControlPlaneOptions contains the optional parameters for the PacketCoreDataPlanesClient.NewListByPacketCoreControlPlanePager method.

type PacketCoreDataPlanesClientListByPacketCoreControlPlaneResponse 

type PacketCoreDataPlanesClientListByPacketCoreControlPlaneResponse struct {
	PacketCoreDataPlaneListResult
}

PacketCoreDataPlanesClientListByPacketCoreControlPlaneResponse contains the response from method PacketCoreDataPlanesClient.NewListByPacketCoreControlPlanePager.

type PacketCoreDataPlanesClientUpdateTagsOptions 

type PacketCoreDataPlanesClientUpdateTagsOptions struct {
}

PacketCoreDataPlanesClientUpdateTagsOptions contains the optional parameters for the PacketCoreDataPlanesClient.UpdateTags method.

type PacketCoreDataPlanesClientUpdateTagsResponse 

type PacketCoreDataPlanesClientUpdateTagsResponse struct {
	PacketCoreDataPlane
}

PacketCoreDataPlanesClientUpdateTagsResponse contains the response from method PacketCoreDataPlanesClient.UpdateTags.

type PccRuleConfiguration 

type PccRuleConfiguration struct {
	// REQUIRED; The name of the rule. This must be unique within the parent service. You must not use any of the following reserved
	// strings - default, requested or service.
	RuleName *string

	// REQUIRED; A precedence value that is used to decide between data flow policy rules when identifying the QoS values to use
	// for a particular SIM. A lower value means a higher priority. This value should be unique
	// among all data flow policy rules configured in the mobile network.
	RulePrecedence *int32

	// REQUIRED; The set of data flow templates to use for this data flow policy rule.
	ServiceDataFlowTemplates []*ServiceDataFlowTemplate

	// The QoS policy to use for packets matching this rule. If this field is null then the parent service will define the QoS
	// settings.
	RuleQosPolicy *PccRuleQosPolicy

	// Determines whether flows that match this data flow policy rule are permitted.
	TrafficControl *TrafficControlPermission
}

PccRuleConfiguration - Data flow policy rule configuration

func (PccRuleConfiguration) MarshalJSON 

func (p PccRuleConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PccRuleConfiguration.

func (*PccRuleConfiguration) UnmarshalJSON 

func (p *PccRuleConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PccRuleConfiguration.

type PccRuleQosPolicy 

type PccRuleQosPolicy struct {
	// REQUIRED; The maximum bit rate (MBR) for all service data flows that use this data flow policy rule or service.
	MaximumBitRate *Ambr

	// QoS Flow allocation and retention priority (ARP) level. Flows with higher priority preempt flows with lower priority, if
	// the settings of preemptionCapability and preemptionVulnerability allow it. 1 is
	// the highest level of priority. If this field is not specified then 5qi is used to derive the ARP value. See 3GPP TS23.501
	// section 5.7.2.2 for a full description of the ARP parameters.
	AllocationAndRetentionPriorityLevel *int32

	// QoS Flow 5G QoS Indicator value. The 5QI identifies a specific QoS forwarding treatment to be provided to a flow. This
	// must not be a standardized 5QI value corresponding to a GBR (guaranteed bit rate)
	// QoS Flow. The illegal GBR 5QI values are: 1, 2, 3, 4, 65, 66, 67, 71, 72, 73, 74, 75, 76, 82, 83, 84, and 85. See 3GPP
	// TS23.501 section 5.7.2.1 for a full description of the 5QI parameter, and table
	// 5.7.4-1 for the definition of which are the GBR 5QI values.
	FiveQi *int32

	// The guaranteed bit rate (GBR) for all service data flows that use this data flow policy rule. This is an optional setting.
	// If you do not provide a value, there will be no GBR set for the data flow
	// policy rule that uses this QoS definition.
	GuaranteedBitRate *Ambr

	// QoS Flow preemption capability. The preemption capability of a QoS Flow controls whether it can preempt another QoS Flow
	// with a lower priority level. See 3GPP TS23.501 section 5.7.2.2 for a full
	// description of the ARP parameters.
	PreemptionCapability *PreemptionCapability

	// QoS Flow preemption vulnerability. The preemption vulnerability of a QoS Flow controls whether it can be preempted by a
	// QoS Flow with a higher priority level. See 3GPP TS23.501 section 5.7.2.2 for a
	// full description of the ARP parameters.
	PreemptionVulnerability *PreemptionVulnerability
}

PccRuleQosPolicy - Data flow policy rule QoS policy

func (PccRuleQosPolicy) MarshalJSON 

func (p PccRuleQosPolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PccRuleQosPolicy.

func (*PccRuleQosPolicy) UnmarshalJSON 

func (p *PccRuleQosPolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PccRuleQosPolicy.

type PduSessionType 

type PduSessionType string

PduSessionType - PDU session type (IPv4/IPv6). 

const (
	PduSessionTypeIPv4 PduSessionType = "IPv4"
	PduSessionTypeIPv6 PduSessionType = "IPv6"
)

func PossiblePduSessionTypeValues 

func PossiblePduSessionTypeValues() []PduSessionType

PossiblePduSessionTypeValues returns the possible values for the PduSessionType const type.

type PinholeTimeouts 

type PinholeTimeouts struct {
	// Pinhole timeout for ICMP pinholes in seconds. Default for ICMP Echo is 30 seconds.
	Icmp *int32

	// Pinhole timeout for TCP pinholes in seconds. Default for TCP is 3 minutes.
	TCP *int32

	// Pinhole timeout for UDP pinholes in seconds. Default for UDP is 30 seconds.
	UDP *int32
}

PinholeTimeouts - Expiry times of inactive NAPT pinholes, in seconds. All timers must be at least 1 second.

func (PinholeTimeouts) MarshalJSON 

func (p PinholeTimeouts) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PinholeTimeouts.

func (*PinholeTimeouts) UnmarshalJSON 

func (p *PinholeTimeouts) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PinholeTimeouts.

type Platform 

type Platform struct {
	// The maximum software version of the platform where this packet core version can be deployed.
	MaximumPlatformSoftwareVersion *string

	// The minimum software version of the platform where this packet core version can be deployed.
	MinimumPlatformSoftwareVersion *string

	// Indicates whether this version is obsoleted for this platform.
	ObsoleteVersion *ObsoleteVersion

	// The platform type where this version can be deployed.
	PlatformType *PlatformType

	// Indicates whether this is the recommended version for this platform.
	RecommendedVersion *RecommendedVersion

	// The state of this packet core control plane version on this platform.
	VersionState *VersionState
}

Platform specific packet core control plane version properties.

func (Platform) MarshalJSON 

func (p Platform) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Platform.

func (*Platform) UnmarshalJSON 

func (p *Platform) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Platform.

type PlatformConfiguration 

type PlatformConfiguration struct {
	// REQUIRED; The platform type where packet core is deployed.
	Type *PlatformType

	// The Azure Stack Edge device where the packet core is deployed. If the device is part of a fault tolerant pair, either device
	// in the pair can be specified.
	AzureStackEdgeDevice *AzureStackEdgeDeviceResourceID

	// The Azure Stack HCI cluster where the packet core is deployed.
	AzureStackHciCluster *AzureStackHCIClusterResourceID

	// Azure Arc connected cluster where the packet core is deployed.
	ConnectedCluster *ConnectedClusterResourceID

	// Azure Arc custom location where the packet core is deployed.
	CustomLocation *CustomLocationResourceID

	// READ-ONLY; The Azure Stack Edge devices where the packet core is deployed. If the packet core is deployed across multiple
	// devices, all devices will appear in this list.
	AzureStackEdgeDevices []*AzureStackEdgeDeviceResourceID
}

PlatformConfiguration - The platform where the packet core is deployed.

func (PlatformConfiguration) MarshalJSON 

func (p PlatformConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlatformConfiguration.

func (*PlatformConfiguration) UnmarshalJSON 

func (p *PlatformConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlatformConfiguration.

type PlatformType 

type PlatformType string

PlatformType - The platform type where packet core is deployed. The contents of this enum can change. 

const (
	// PlatformTypeAKSHCI - If this option is chosen, you must set one of "azureStackEdgeDevice", "connectedCluster" or "customLocation".
	// If multiple are set, they must be consistent with each other.
	PlatformTypeAKSHCI PlatformType = "AKS-HCI"
	// PlatformTypeThreePAZURESTACKHCI - If this option is chosen, you must set one of "azureStackHciCluster", "connectedCluster"
	// or "customLocation". If multiple are set, they must be consistent with each other.
	PlatformTypeThreePAZURESTACKHCI PlatformType = "3P-AZURE-STACK-HCI"
)

func PossiblePlatformTypeValues 

func PossiblePlatformTypeValues() []PlatformType

PossiblePlatformTypeValues returns the possible values for the PlatformType const type.

type PlmnID 

type PlmnID struct {
	// REQUIRED; Mobile country code (MCC).
	Mcc *string

	// REQUIRED; Mobile network code (MNC).
	Mnc *string
}

PlmnID - Public land mobile network (PLMN) ID.

func (PlmnID) MarshalJSON 

func (p PlmnID) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlmnID.

func (*PlmnID) UnmarshalJSON 

func (p *PlmnID) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlmnID.

type PortRange 

type PortRange struct {
	// The maximum port number
	MaxPort *int32

	// The minimum port number
	MinPort *int32
}

PortRange - Range of port numbers to use as translated ports on each translated address. If not specified and NAPT is enabled, this range defaults to 1,024 - 49,999. (Ports under 1,024 should not be used because these are special purpose ports reserved by IANA. Ports 50,000 and above are reserved for non-NAPT use.)

func (PortRange) MarshalJSON 

func (p PortRange) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PortRange.

func (*PortRange) UnmarshalJSON 

func (p *PortRange) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PortRange.

type PortReuseHoldTimes 

type PortReuseHoldTimes struct {
	// Minimum time in seconds that will pass before a TCP port that was used by a closed pinhole can be reused. Default for TCP
	// is 2 minutes.
	TCP *int32

	// Minimum time in seconds that will pass before a UDP port that was used by a closed pinhole can be reused. Default for UDP
	// is 1 minute.
	UDP *int32
}

PortReuseHoldTimes - The minimum time (in seconds) that will pass before a port that was used by a closed pinhole can be recycled for use by another pinhole. All hold times must be minimum 1 second.

func (PortReuseHoldTimes) MarshalJSON 

func (p PortReuseHoldTimes) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PortReuseHoldTimes.

func (*PortReuseHoldTimes) UnmarshalJSON 

func (p *PortReuseHoldTimes) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PortReuseHoldTimes.

type PreemptionCapability 

type PreemptionCapability string

PreemptionCapability - Preemption capability. 

const (
	// PreemptionCapabilityMayPreempt - May preempt
	PreemptionCapabilityMayPreempt PreemptionCapability = "MayPreempt"
	// PreemptionCapabilityNotPreempt - Cannot preempt
	PreemptionCapabilityNotPreempt PreemptionCapability = "NotPreempt"
)

func PossiblePreemptionCapabilityValues 

func PossiblePreemptionCapabilityValues() []PreemptionCapability

PossiblePreemptionCapabilityValues returns the possible values for the PreemptionCapability const type.

type PreemptionVulnerability 

type PreemptionVulnerability string

PreemptionVulnerability - Preemption vulnerability. 

const (
	// PreemptionVulnerabilityNotPreemptable - Cannot be preempted
	PreemptionVulnerabilityNotPreemptable PreemptionVulnerability = "NotPreemptable"
	// PreemptionVulnerabilityPreemptable - May be preempted
	PreemptionVulnerabilityPreemptable PreemptionVulnerability = "Preemptable"
)

func PossiblePreemptionVulnerabilityValues 

func PossiblePreemptionVulnerabilityValues() []PreemptionVulnerability

PossiblePreemptionVulnerabilityValues returns the possible values for the PreemptionVulnerability const type.

type PropertiesFormat 

type PropertiesFormat struct {
	// REQUIRED; The unique public land mobile network identifier for the network. This is made up of the mobile country code
	// and mobile network code, as defined in https://www.itu.int/rec/T-REC-E.212. The values
	// 001-01 and 001-001 can be used for testing and the values 999-99 and 999-999 can be used on internal private networks.
	PublicLandMobileNetworkIdentifier *PlmnID

	// READ-ONLY; The provisioning state of the mobile network resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The mobile network resource identifier
	ServiceKey *string
}

PropertiesFormat - Mobile network properties.

func (PropertiesFormat) MarshalJSON 

func (p PropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PropertiesFormat.

func (*PropertiesFormat) UnmarshalJSON 

func (p *PropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PropertiesFormat.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - The current provisioning state. 

const (
	ProvisioningStateAccepted  ProvisioningState = "Accepted"
	ProvisioningStateCanceled  ProvisioningState = "Canceled"
	ProvisioningStateDeleted   ProvisioningState = "Deleted"
	ProvisioningStateDeleting  ProvisioningState = "Deleting"
	ProvisioningStateFailed    ProvisioningState = "Failed"
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
	ProvisioningStateUnknown   ProvisioningState = "Unknown"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type ProxyResource 

type ProxyResource struct {
	// 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
}

ProxyResource - The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location

func (ProxyResource) MarshalJSON 

func (p ProxyResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ProxyResource.

func (*ProxyResource) UnmarshalJSON 

func (p *ProxyResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ProxyResource.

type QosPolicy 

type QosPolicy struct {
	// REQUIRED; The maximum bit rate (MBR) for all service data flows that use this data flow policy rule or service.
	MaximumBitRate *Ambr

	// QoS Flow allocation and retention priority (ARP) level. Flows with higher priority preempt flows with lower priority, if
	// the settings of preemptionCapability and preemptionVulnerability allow it. 1 is
	// the highest level of priority. If this field is not specified then 5qi is used to derive the ARP value. See 3GPP TS23.501
	// section 5.7.2.2 for a full description of the ARP parameters.
	AllocationAndRetentionPriorityLevel *int32

	// QoS Flow 5G QoS Indicator value. The 5QI identifies a specific QoS forwarding treatment to be provided to a flow. This
	// must not be a standardized 5QI value corresponding to a GBR (guaranteed bit rate)
	// QoS Flow. The illegal GBR 5QI values are: 1, 2, 3, 4, 65, 66, 67, 71, 72, 73, 74, 75, 76, 82, 83, 84, and 85. See 3GPP
	// TS23.501 section 5.7.2.1 for a full description of the 5QI parameter, and table
	// 5.7.4-1 for the definition of which are the GBR 5QI values.
	FiveQi *int32

	// QoS Flow preemption capability. The preemption capability of a QoS Flow controls whether it can preempt another QoS Flow
	// with a lower priority level. See 3GPP TS23.501 section 5.7.2.2 for a full
	// description of the ARP parameters.
	PreemptionCapability *PreemptionCapability

	// QoS Flow preemption vulnerability. The preemption vulnerability of a QoS Flow controls whether it can be preempted by a
	// QoS Flow with a higher priority level. See 3GPP TS23.501 section 5.7.2.2 for a
	// full description of the ARP parameters.
	PreemptionVulnerability *PreemptionVulnerability
}

QosPolicy - QoS policy

func (QosPolicy) MarshalJSON 

func (q QosPolicy) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type QosPolicy.

func (*QosPolicy) UnmarshalJSON 

func (q *QosPolicy) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type QosPolicy.

type RecommendedVersion 

type RecommendedVersion string

RecommendedVersion - Indicates whether this is the recommended version to use for new packet core control plane deployments. 

const (
	// RecommendedVersionNotRecommended - This is not the recommended version to use for new packet core control plane deployments.
	RecommendedVersionNotRecommended RecommendedVersion = "NotRecommended"
	// RecommendedVersionRecommended - This is the recommended version to use for new packet core control plane deployments.
	RecommendedVersionRecommended RecommendedVersion = "Recommended"
)

func PossibleRecommendedVersionValues 

func PossibleRecommendedVersionValues() []RecommendedVersion

PossibleRecommendedVersionValues returns the possible values for the RecommendedVersion const type.

type Resource 

type Resource struct {
	// 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
}

Resource - Common fields that are returned in the response for all Azure Resource Manager resources

func (Resource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Resource.

func (*Resource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

type ResourceID 

type ResourceID struct {
	// REQUIRED; Mobile network resource ID.
	ID *string
}

ResourceID - Reference to a mobile network resource.

func (ResourceID) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ResourceID.

func (*ResourceID) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceID.

type SdfDirection 

type SdfDirection string

SdfDirection - Service data flow direction. 

const (
	// SdfDirectionBidirectional - Traffic flowing both to and from the UE.
	SdfDirectionBidirectional SdfDirection = "Bidirectional"
	// SdfDirectionDownlink - Traffic flowing from the data network to the UE.
	SdfDirectionDownlink SdfDirection = "Downlink"
	// SdfDirectionUplink - Traffic flowing from the UE to the data network.
	SdfDirectionUplink SdfDirection = "Uplink"
)

func PossibleSdfDirectionValues 

func PossibleSdfDirectionValues() []SdfDirection

PossibleSdfDirectionValues returns the possible values for the SdfDirection const type.

type Service 

type Service struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Service Properties.
	Properties *ServicePropertiesFormat

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

Service resource. Must be created in the same location as its parent mobile network.

func (Service) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Service.

func (*Service) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Service.

type ServiceDataFlowTemplate 

type ServiceDataFlowTemplate struct {
	// REQUIRED; The direction of this flow.
	Direction *SdfDirection

	// REQUIRED; A list of the allowed protocol(s) for this flow. If you want this flow to be able to use any protocol within
	// the internet protocol suite, use the value ip. If you only want to allow a selection of
	// protocols, you must use the corresponding IANA Assigned Internet Protocol Number for each protocol, as described in https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml.
	// For
	// example, for UDP, you must use 17. If you use the value ip then you must leave the field port unspecified.
	Protocol []*string

	// REQUIRED; The remote IP address(es) to which UEs will connect for this flow. If you want to allow connections on any IP
	// address, use the value any. Otherwise, you must provide each of the remote IP addresses to
	// which the packet core instance will connect for this flow. You must provide each IP address in CIDR notation, including
	// the netmask (for example, 192.0.2.54/24).
	RemoteIPList []*string

	// REQUIRED; The name of the data flow template. This must be unique within the parent data flow policy rule. You must not
	// use any of the following reserved strings - default, requested or service.
	TemplateName *string

	// The port(s) to which UEs will connect for this flow. You can specify zero or more ports or port ranges. If you specify
	// one or more ports or port ranges then you must specify a value other than ip in
	// the protocol field. This is an optional setting. If you do not specify it then connections will be allowed on all ports.
	// Port ranges must be specified as -. For example: [8080, 8082-8085].
	Ports []*string
}

ServiceDataFlowTemplate - Data flow template

func (ServiceDataFlowTemplate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceDataFlowTemplate.

func (*ServiceDataFlowTemplate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceDataFlowTemplate.

type ServiceListResult 

type ServiceListResult struct {
	// A list of services.
	Value []*Service

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

ServiceListResult - Response for services API service call.

func (ServiceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceListResult.

func (*ServiceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceListResult.

type ServicePropertiesFormat 

type ServicePropertiesFormat struct {
	// REQUIRED; The set of data flow policy rules that make up this service.
	PccRules []*PccRuleConfiguration

	// REQUIRED; A precedence value that is used to decide between services when identifying the QoS values to use for a particular
	// SIM. A lower value means a higher priority. This value should be unique among all
	// services configured in the mobile network.
	ServicePrecedence *int32

	// The QoS policy to use for packets matching this service. This can be overridden for particular flows using the ruleQosPolicy
	// field in a PccRuleConfiguration. If this field is null then the UE's SIM
	// policy will define the QoS settings.
	ServiceQosPolicy *QosPolicy

	// READ-ONLY; The provisioning state of the service resource.
	ProvisioningState *ProvisioningState
}

ServicePropertiesFormat - Service properties.

func (ServicePropertiesFormat) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServicePropertiesFormat.

func (*ServicePropertiesFormat) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServicePropertiesFormat.

type ServiceResourceID 

type ServiceResourceID struct {
	// REQUIRED; Service resource ID.
	ID *string
}

ServiceResourceID - Reference to a service resource.

func (ServiceResourceID) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceResourceID.

func (*ServiceResourceID) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceResourceID.

type ServicesClient 

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

ServicesClient contains the methods for the Services group. Don't use this type directly, use NewServicesClient() instead.

func NewServicesClient 

func NewServicesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ServicesClient, error)

NewServicesClient creates a new instance of ServicesClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ServicesClient) BeginCreateOrUpdate 

func (client *ServicesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, mobileNetworkName string, serviceName string, parameters Service, options *ServicesClientBeginCreateOrUpdateOptions) (*runtime.Poller[ServicesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a service. Must be created in the same location as its parent mobile network. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • serviceName - The name of the service. You must not use any of the following reserved strings - default, requested or service
  • parameters - Parameters supplied to the create or update service operation.
  • options - ServicesClientBeginCreateOrUpdateOptions contains the optional parameters for the ServicesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/ServiceCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServicesClient().BeginCreateOrUpdate(ctx, "rg1", "testMobileNetwork", "TestService", armmobilenetwork.Service{
	Location: to.Ptr("eastus"),
	Properties: &armmobilenetwork.ServicePropertiesFormat{
		PccRules: []*armmobilenetwork.PccRuleConfiguration{
			{
				RuleName:       to.Ptr("default-rule"),
				RulePrecedence: to.Ptr[int32](255),
				RuleQosPolicy: &armmobilenetwork.PccRuleQosPolicy{
					FiveQi:                              to.Ptr[int32](9),
					AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
					MaximumBitRate: &armmobilenetwork.Ambr{
						Downlink: to.Ptr("1 Gbps"),
						Uplink:   to.Ptr("500 Mbps"),
					},
					PreemptionCapability:    to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
					PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
				},
				ServiceDataFlowTemplates: []*armmobilenetwork.ServiceDataFlowTemplate{
					{
						Direction: to.Ptr(armmobilenetwork.SdfDirectionUplink),
						Ports:     []*string{},
						RemoteIPList: []*string{
							to.Ptr("10.3.4.0/24")},
						TemplateName: to.Ptr("IP-to-server"),
						Protocol: []*string{
							to.Ptr("ip")},
					}},
				TrafficControl: to.Ptr(armmobilenetwork.TrafficControlPermissionEnabled),
			}},
		ServicePrecedence: to.Ptr[int32](255),
		ServiceQosPolicy: &armmobilenetwork.QosPolicy{
			FiveQi:                              to.Ptr[int32](9),
			AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
			MaximumBitRate: &armmobilenetwork.Ambr{
				Downlink: to.Ptr("1 Gbps"),
				Uplink:   to.Ptr("500 Mbps"),
			},
			PreemptionCapability:    to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
			PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
		},
	},
}, 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.Service = armmobilenetwork.Service{
// 	Name: to.Ptr("testPolicy"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/service"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/TestService"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.ServicePropertiesFormat{
// 		PccRules: []*armmobilenetwork.PccRuleConfiguration{
// 			{
// 				RuleName: to.Ptr("default-rule"),
// 				RulePrecedence: to.Ptr[int32](255),
// 				RuleQosPolicy: &armmobilenetwork.PccRuleQosPolicy{
// 					FiveQi: to.Ptr[int32](9),
// 					AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
// 					MaximumBitRate: &armmobilenetwork.Ambr{
// 						Downlink: to.Ptr("1 Gbps"),
// 						Uplink: to.Ptr("500 Mbps"),
// 					},
// 					PreemptionCapability: to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
// 					PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
// 				},
// 				ServiceDataFlowTemplates: []*armmobilenetwork.ServiceDataFlowTemplate{
// 					{
// 						Direction: to.Ptr(armmobilenetwork.SdfDirectionUplink),
// 						Ports: []*string{
// 						},
// 						RemoteIPList: []*string{
// 							to.Ptr("10.3.4.0/24")},
// 							TemplateName: to.Ptr("IP-to-server"),
// 							Protocol: []*string{
// 								to.Ptr("ip")},
// 						}},
// 						TrafficControl: to.Ptr(armmobilenetwork.TrafficControlPermissionEnabled),
// 				}},
// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 				ServicePrecedence: to.Ptr[int32](255),
// 				ServiceQosPolicy: &armmobilenetwork.QosPolicy{
// 					FiveQi: to.Ptr[int32](9),
// 					AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
// 					MaximumBitRate: &armmobilenetwork.Ambr{
// 						Downlink: to.Ptr("1 Gbps"),
// 						Uplink: to.Ptr("500 Mbps"),
// 					},
// 					PreemptionCapability: to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
// 					PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
// 				},
// 			},
// 		}

Output:

func (*ServicesClient) BeginDelete 

func (client *ServicesClient) BeginDelete(ctx context.Context, resourceGroupName string, mobileNetworkName string, serviceName string, options *ServicesClientBeginDeleteOptions) (*runtime.Poller[ServicesClientDeleteResponse], error)

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

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • serviceName - The name of the service. You must not use any of the following reserved strings - default, requested or service
  • options - ServicesClientBeginDeleteOptions contains the optional parameters for the ServicesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/ServiceDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServicesClient().BeginDelete(ctx, "rg1", "testMobileNetwork", "TestService", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*ServicesClient) Get 

func (client *ServicesClient) Get(ctx context.Context, resourceGroupName string, mobileNetworkName string, serviceName string, options *ServicesClientGetOptions) (ServicesClientGetResponse, error)

Get - Gets information about the specified service. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • serviceName - The name of the service. You must not use any of the following reserved strings - default, requested or service
  • options - ServicesClientGetOptions contains the optional parameters for the ServicesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/ServiceGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewServicesClient().Get(ctx, "rg1", "testMobileNetwork", "TestService", 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.Service = armmobilenetwork.Service{
// 	Name: to.Ptr("testPolicy"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/service"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/TestService"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.ServicePropertiesFormat{
// 		PccRules: []*armmobilenetwork.PccRuleConfiguration{
// 			{
// 				RuleName: to.Ptr("default-rule"),
// 				RulePrecedence: to.Ptr[int32](255),
// 				RuleQosPolicy: &armmobilenetwork.PccRuleQosPolicy{
// 					FiveQi: to.Ptr[int32](9),
// 					AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
// 					MaximumBitRate: &armmobilenetwork.Ambr{
// 						Downlink: to.Ptr("1 Gbps"),
// 						Uplink: to.Ptr("500 Mbps"),
// 					},
// 					PreemptionCapability: to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
// 					PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
// 				},
// 				ServiceDataFlowTemplates: []*armmobilenetwork.ServiceDataFlowTemplate{
// 					{
// 						Direction: to.Ptr(armmobilenetwork.SdfDirectionUplink),
// 						Ports: []*string{
// 						},
// 						RemoteIPList: []*string{
// 							to.Ptr("10.3.4.0/24")},
// 							TemplateName: to.Ptr("IP-to-server"),
// 							Protocol: []*string{
// 								to.Ptr("ip")},
// 						}},
// 						TrafficControl: to.Ptr(armmobilenetwork.TrafficControlPermissionEnabled),
// 				}},
// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 				ServicePrecedence: to.Ptr[int32](255),
// 				ServiceQosPolicy: &armmobilenetwork.QosPolicy{
// 					FiveQi: to.Ptr[int32](9),
// 					AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
// 					MaximumBitRate: &armmobilenetwork.Ambr{
// 						Downlink: to.Ptr("1 Gbps"),
// 						Uplink: to.Ptr("500 Mbps"),
// 					},
// 					PreemptionCapability: to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
// 					PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
// 				},
// 			},
// 		}

Output:

func (*ServicesClient) NewListByMobileNetworkPager 

func (client *ServicesClient) NewListByMobileNetworkPager(resourceGroupName string, mobileNetworkName string, options *ServicesClientListByMobileNetworkOptions) *runtime.Pager[ServicesClientListByMobileNetworkResponse]

NewListByMobileNetworkPager - Gets all the services in a mobile network.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • options - ServicesClientListByMobileNetworkOptions contains the optional parameters for the ServicesClient.NewListByMobileNetworkPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/ServiceListByMobileNetwork.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewServicesClient().NewListByMobileNetworkPager("testResourceGroupName", "testMobileNetwork", 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.ServiceListResult = armmobilenetwork.ServiceListResult{
	// 	Value: []*armmobilenetwork.Service{
	// 		{
	// 			Type: to.Ptr("Microsoft.MobileNetwork/service"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/TestService"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("eastus"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armmobilenetwork.ServicePropertiesFormat{
	// 				PccRules: []*armmobilenetwork.PccRuleConfiguration{
	// 					{
	// 						RuleName: to.Ptr("default-rule"),
	// 						RulePrecedence: to.Ptr[int32](255),
	// 						RuleQosPolicy: &armmobilenetwork.PccRuleQosPolicy{
	// 							FiveQi: to.Ptr[int32](9),
	// 							AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
	// 							MaximumBitRate: &armmobilenetwork.Ambr{
	// 								Downlink: to.Ptr("1 Gbps"),
	// 								Uplink: to.Ptr("500 Mbps"),
	// 							},
	// 							PreemptionCapability: to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
	// 							PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
	// 						},
	// 						ServiceDataFlowTemplates: []*armmobilenetwork.ServiceDataFlowTemplate{
	// 							{
	// 								Direction: to.Ptr(armmobilenetwork.SdfDirectionUplink),
	// 								Ports: []*string{
	// 								},
	// 								RemoteIPList: []*string{
	// 									to.Ptr("10.3.4.0/24")},
	// 									TemplateName: to.Ptr("IP-to-server"),
	// 									Protocol: []*string{
	// 										to.Ptr("ip")},
	// 								}},
	// 								TrafficControl: to.Ptr(armmobilenetwork.TrafficControlPermissionEnabled),
	// 						}},
	// 						ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 						ServicePrecedence: to.Ptr[int32](255),
	// 						ServiceQosPolicy: &armmobilenetwork.QosPolicy{
	// 							FiveQi: to.Ptr[int32](9),
	// 							AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
	// 							MaximumBitRate: &armmobilenetwork.Ambr{
	// 								Downlink: to.Ptr("1 Gbps"),
	// 								Uplink: to.Ptr("500 Mbps"),
	// 							},
	// 							PreemptionCapability: to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
	// 							PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
	// 						},
	// 					},
	// 			}},
	// 		}
}

Output:

func (*ServicesClient) UpdateTags 

func (client *ServicesClient) UpdateTags(ctx context.Context, resourceGroupName string, mobileNetworkName string, serviceName string, parameters TagsObject, options *ServicesClientUpdateTagsOptions) (ServicesClientUpdateTagsResponse, error)

UpdateTags - Updates service tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • serviceName - The name of the service. You must not use any of the following reserved strings - default, requested or service
  • parameters - Parameters supplied to update service tags.
  • options - ServicesClientUpdateTagsOptions contains the optional parameters for the ServicesClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/ServiceUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewServicesClient().UpdateTags(ctx, "rg1", "testMobileNetwork", "TestService", armmobilenetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, 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.Service = armmobilenetwork.Service{
// 	Name: to.Ptr("TestService"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/service"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/TestService"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Properties: &armmobilenetwork.ServicePropertiesFormat{
// 		PccRules: []*armmobilenetwork.PccRuleConfiguration{
// 			{
// 				RuleName: to.Ptr("default-rule"),
// 				RulePrecedence: to.Ptr[int32](255),
// 				RuleQosPolicy: &armmobilenetwork.PccRuleQosPolicy{
// 					FiveQi: to.Ptr[int32](9),
// 					AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
// 					MaximumBitRate: &armmobilenetwork.Ambr{
// 						Downlink: to.Ptr("1 Gbps"),
// 						Uplink: to.Ptr("500 Mbps"),
// 					},
// 					PreemptionCapability: to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
// 					PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
// 				},
// 				ServiceDataFlowTemplates: []*armmobilenetwork.ServiceDataFlowTemplate{
// 					{
// 						Direction: to.Ptr(armmobilenetwork.SdfDirectionUplink),
// 						Ports: []*string{
// 						},
// 						RemoteIPList: []*string{
// 							to.Ptr("10.3.4.0/24")},
// 							TemplateName: to.Ptr("IP-to-server"),
// 							Protocol: []*string{
// 								to.Ptr("ip")},
// 						}},
// 						TrafficControl: to.Ptr(armmobilenetwork.TrafficControlPermissionEnabled),
// 				}},
// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 				ServicePrecedence: to.Ptr[int32](255),
// 				ServiceQosPolicy: &armmobilenetwork.QosPolicy{
// 					FiveQi: to.Ptr[int32](9),
// 					AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
// 					MaximumBitRate: &armmobilenetwork.Ambr{
// 						Downlink: to.Ptr("1 Gbps"),
// 						Uplink: to.Ptr("500 Mbps"),
// 					},
// 					PreemptionCapability: to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
// 					PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
// 				},
// 			},
// 		}

Output:

type ServicesClientBeginCreateOrUpdateOptions 

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

ServicesClientBeginCreateOrUpdateOptions contains the optional parameters for the ServicesClient.BeginCreateOrUpdate method.

type ServicesClientBeginDeleteOptions 

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

ServicesClientBeginDeleteOptions contains the optional parameters for the ServicesClient.BeginDelete method.

type ServicesClientCreateOrUpdateResponse 

type ServicesClientCreateOrUpdateResponse struct {
	Service
}

ServicesClientCreateOrUpdateResponse contains the response from method ServicesClient.BeginCreateOrUpdate.

type ServicesClientDeleteResponse 

type ServicesClientDeleteResponse struct {
}

ServicesClientDeleteResponse contains the response from method ServicesClient.BeginDelete.

type ServicesClientGetOptions 

type ServicesClientGetOptions struct {
}

ServicesClientGetOptions contains the optional parameters for the ServicesClient.Get method.

type ServicesClientGetResponse 

type ServicesClientGetResponse struct {
	Service
}

ServicesClientGetResponse contains the response from method ServicesClient.Get.

type ServicesClientListByMobileNetworkOptions 

type ServicesClientListByMobileNetworkOptions struct {
}

ServicesClientListByMobileNetworkOptions contains the optional parameters for the ServicesClient.NewListByMobileNetworkPager method.

type ServicesClientListByMobileNetworkResponse 

type ServicesClientListByMobileNetworkResponse struct {
	ServiceListResult
}

ServicesClientListByMobileNetworkResponse contains the response from method ServicesClient.NewListByMobileNetworkPager.

type ServicesClientUpdateTagsOptions 

type ServicesClientUpdateTagsOptions struct {
}

ServicesClientUpdateTagsOptions contains the optional parameters for the ServicesClient.UpdateTags method.

type ServicesClientUpdateTagsResponse 

type ServicesClientUpdateTagsResponse struct {
	Service
}

ServicesClientUpdateTagsResponse contains the response from method ServicesClient.UpdateTags.

type Sim 

type Sim struct {
	// REQUIRED; SIM Properties.
	Properties *SimPropertiesFormat

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

Sim - SIM resource.

func (Sim) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Sim.

func (*Sim) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Sim.

type SimDeleteList 

type SimDeleteList struct {
	// REQUIRED; A list of SIM resource names to delete.
	Sims []*string
}

SimDeleteList - The SIMs to delete.

func (SimDeleteList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimDeleteList.

func (*SimDeleteList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimDeleteList.

type SimGroup 

type SimGroup struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; SIM group Properties.
	Properties *SimGroupPropertiesFormat

	// The identity used to retrieve the encryption key from Azure key vault.
	Identity *ManagedServiceIdentity

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

SimGroup - SIM group resource.

func (SimGroup) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimGroup.

func (*SimGroup) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimGroup.

type SimGroupListResult 

type SimGroupListResult struct {
	// A list of SIM groups in a resource group.
	Value []*SimGroup

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

SimGroupListResult - Response for list SIM groups API service call.

func (SimGroupListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimGroupListResult.

func (*SimGroupListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimGroupListResult.

type SimGroupPropertiesFormat 

type SimGroupPropertiesFormat struct {
	// A key to encrypt the SIM data that belongs to this SIM group.
	EncryptionKey *KeyVaultKey

	// Mobile network that this SIM group belongs to. The mobile network must be in the same location as the SIM group.
	MobileNetwork *ResourceID

	// READ-ONLY; The provisioning state of the SIM group resource.
	ProvisioningState *ProvisioningState
}

SimGroupPropertiesFormat - SIM group properties.

func (SimGroupPropertiesFormat) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimGroupPropertiesFormat.

func (*SimGroupPropertiesFormat) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimGroupPropertiesFormat.

type SimGroupResourceID 

type SimGroupResourceID struct {
	// REQUIRED; SIM group resource ID.
	ID *string
}

SimGroupResourceID - Reference to a SIM group resource.

func (SimGroupResourceID) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimGroupResourceID.

func (*SimGroupResourceID) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimGroupResourceID.

type SimGroupsClient 

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

SimGroupsClient contains the methods for the SimGroups group. Don't use this type directly, use NewSimGroupsClient() instead.

func NewSimGroupsClient 

func NewSimGroupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SimGroupsClient, error)

NewSimGroupsClient creates a new instance of SimGroupsClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*SimGroupsClient) BeginCreateOrUpdate 

func (client *SimGroupsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, simGroupName string, parameters SimGroup, options *SimGroupsClientBeginCreateOrUpdateOptions) (*runtime.Poller[SimGroupsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a SIM group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • simGroupName - The name of the SIM Group.
  • parameters - Parameters supplied to the create or update SIM group operation.
  • options - SimGroupsClientBeginCreateOrUpdateOptions contains the optional parameters for the SimGroupsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimGroupCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSimGroupsClient().BeginCreateOrUpdate(ctx, "rg1", "testSimGroup", armmobilenetwork.SimGroup{
	Location: to.Ptr("eastus"),
	Identity: &armmobilenetwork.ManagedServiceIdentity{
		Type: to.Ptr(armmobilenetwork.ManagedServiceIdentityTypeUserAssigned),
		UserAssignedIdentities: map[string]*armmobilenetwork.UserAssignedIdentity{
			"/subscriptions/subid/resourcegroups/rg1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testUserAssignedManagedIdentity": {},
		},
	},
	Properties: &armmobilenetwork.SimGroupPropertiesFormat{
		EncryptionKey: &armmobilenetwork.KeyVaultKey{
			KeyURL: to.Ptr("https://contosovault.vault.azure.net/keys/azureKey"),
		},
		MobileNetwork: &armmobilenetwork.ResourceID{
			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork"),
		},
	},
}, 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.SimGroup = armmobilenetwork.SimGroup{
// 	Name: to.Ptr("testSimGroup"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/simGroups"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/simGroups/testSimGroup"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Identity: &armmobilenetwork.ManagedServiceIdentity{
// 		Type: to.Ptr(armmobilenetwork.ManagedServiceIdentityTypeUserAssigned),
// 		UserAssignedIdentities: map[string]*armmobilenetwork.UserAssignedIdentity{
// 			"/subscriptions/subid/resourcegroups/rg1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testUserAssignedManagedIdentity": &armmobilenetwork.UserAssignedIdentity{
// 				ClientID: to.Ptr("12345678-abcd-dcba-abcd-0123456789ef"),
// 				PrincipalID: to.Ptr("12345678-abcd-dcba-abcd-0123456789ef"),
// 			},
// 		},
// 	},
// 	Properties: &armmobilenetwork.SimGroupPropertiesFormat{
// 		EncryptionKey: &armmobilenetwork.KeyVaultKey{
// 			KeyURL: to.Ptr("https://contosovault.vault.azure.net/keys/azureKey"),
// 		},
// 		MobileNetwork: &armmobilenetwork.ResourceID{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork"),
// 		},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 	},
// }

Output:

func (*SimGroupsClient) BeginDelete 

func (client *SimGroupsClient) BeginDelete(ctx context.Context, resourceGroupName string, simGroupName string, options *SimGroupsClientBeginDeleteOptions) (*runtime.Poller[SimGroupsClientDeleteResponse], error)

BeginDelete - Deletes the specified SIM group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • simGroupName - The name of the SIM Group.
  • options - SimGroupsClientBeginDeleteOptions contains the optional parameters for the SimGroupsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimGroupDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSimGroupsClient().BeginDelete(ctx, "testResourceGroupName", "testSimGroup", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*SimGroupsClient) Get 

func (client *SimGroupsClient) Get(ctx context.Context, resourceGroupName string, simGroupName string, options *SimGroupsClientGetOptions) (SimGroupsClientGetResponse, error)

Get - Gets information about the specified SIM group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • simGroupName - The name of the SIM Group.
  • options - SimGroupsClientGetOptions contains the optional parameters for the SimGroupsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimGroupGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSimGroupsClient().Get(ctx, "testResourceGroupName", "testSimGroupName", 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.SimGroup = armmobilenetwork.SimGroup{
// 	Name: to.Ptr("testSimGroup"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/simGroups"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/simGroups/testSimGroup"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Identity: &armmobilenetwork.ManagedServiceIdentity{
// 		Type: to.Ptr(armmobilenetwork.ManagedServiceIdentityTypeUserAssigned),
// 		UserAssignedIdentities: map[string]*armmobilenetwork.UserAssignedIdentity{
// 			"/subscriptions/subid/resourcegroups/rg1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testUserAssignedManagedIdentity": &armmobilenetwork.UserAssignedIdentity{
// 				ClientID: to.Ptr("12345678-abcd-dcba-abcd-0123456789ef"),
// 				PrincipalID: to.Ptr("12345678-abcd-dcba-abcd-0123456789ef"),
// 			},
// 		},
// 	},
// 	Properties: &armmobilenetwork.SimGroupPropertiesFormat{
// 		EncryptionKey: &armmobilenetwork.KeyVaultKey{
// 			KeyURL: to.Ptr("https://contosovault.vault.azure.net/keys/azureKey"),
// 		},
// 		MobileNetwork: &armmobilenetwork.ResourceID{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork"),
// 		},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 	},
// }

Output:

func (*SimGroupsClient) NewListByResourceGroupPager 

func (client *SimGroupsClient) NewListByResourceGroupPager(resourceGroupName string, options *SimGroupsClientListByResourceGroupOptions) *runtime.Pager[SimGroupsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Gets all the SIM groups in a resource group.

Generated from API version 2022-11-01

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimGroupListByResourceGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSimGroupsClient().NewListByResourceGroupPager("rg1", 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.SimGroupListResult = armmobilenetwork.SimGroupListResult{
	// 	Value: []*armmobilenetwork.SimGroup{
	// 		{
	// 			Name: to.Ptr("testSimGroup"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/simGroups"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/simGroups/testSimGroup"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("eastus"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Identity: &armmobilenetwork.ManagedServiceIdentity{
	// 				Type: to.Ptr(armmobilenetwork.ManagedServiceIdentityTypeUserAssigned),
	// 				UserAssignedIdentities: map[string]*armmobilenetwork.UserAssignedIdentity{
	// 					"/subscriptions/subid/resourcegroups/rg1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testUserAssignedManagedIdentity": &armmobilenetwork.UserAssignedIdentity{
	// 						ClientID: to.Ptr("12345678-abcd-dcba-abcd-0123456789ef"),
	// 						PrincipalID: to.Ptr("12345678-abcd-dcba-abcd-0123456789ef"),
	// 					},
	// 				},
	// 			},
	// 			Properties: &armmobilenetwork.SimGroupPropertiesFormat{
	// 				EncryptionKey: &armmobilenetwork.KeyVaultKey{
	// 					KeyURL: to.Ptr("https://contosovault.vault.azure.net/keys/azureKey"),
	// 				},
	// 				MobileNetwork: &armmobilenetwork.ResourceID{
	// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork"),
	// 				},
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

Output:

func (*SimGroupsClient) NewListBySubscriptionPager 

func (client *SimGroupsClient) NewListBySubscriptionPager(options *SimGroupsClientListBySubscriptionOptions) *runtime.Pager[SimGroupsClientListBySubscriptionResponse]

NewListBySubscriptionPager - Gets all the SIM groups in a subscription.

Generated from API version 2022-11-01

  • options - SimGroupsClientListBySubscriptionOptions contains the optional parameters for the SimGroupsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimGroupListBySubscription.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSimGroupsClient().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.SimGroupListResult = armmobilenetwork.SimGroupListResult{
	// 	Value: []*armmobilenetwork.SimGroup{
	// 		{
	// 			Name: to.Ptr("testSimGroup"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/simGroups"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/simGroups/testSimGroup"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("eastus"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Identity: &armmobilenetwork.ManagedServiceIdentity{
	// 				Type: to.Ptr(armmobilenetwork.ManagedServiceIdentityTypeUserAssigned),
	// 				UserAssignedIdentities: map[string]*armmobilenetwork.UserAssignedIdentity{
	// 					"/subscriptions/subid/resourcegroups/rg1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testUserAssignedManagedIdentity": &armmobilenetwork.UserAssignedIdentity{
	// 						ClientID: to.Ptr("12345678-abcd-dcba-abcd-0123456789ef"),
	// 						PrincipalID: to.Ptr("12345678-abcd-dcba-abcd-0123456789ef"),
	// 					},
	// 				},
	// 			},
	// 			Properties: &armmobilenetwork.SimGroupPropertiesFormat{
	// 				EncryptionKey: &armmobilenetwork.KeyVaultKey{
	// 					KeyURL: to.Ptr("https://contosovault.vault.azure.net/keys/azureKey"),
	// 				},
	// 				MobileNetwork: &armmobilenetwork.ResourceID{
	// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork"),
	// 				},
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

Output:

func (*SimGroupsClient) UpdateTags 

func (client *SimGroupsClient) UpdateTags(ctx context.Context, resourceGroupName string, simGroupName string, parameters TagsObject, options *SimGroupsClientUpdateTagsOptions) (SimGroupsClientUpdateTagsResponse, error)

UpdateTags - Updates SIM group tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • simGroupName - The name of the SIM Group.
  • parameters - Parameters supplied to update SIM group tags.
  • options - SimGroupsClientUpdateTagsOptions contains the optional parameters for the SimGroupsClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimGroupUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSimGroupsClient().UpdateTags(ctx, "rg1", "testSimGroup", armmobilenetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, 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.SimGroup = armmobilenetwork.SimGroup{
// 	Name: to.Ptr("testSimGroup"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/simGroups"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/simGroups/testSimGroup"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Identity: &armmobilenetwork.ManagedServiceIdentity{
// 		Type: to.Ptr(armmobilenetwork.ManagedServiceIdentityTypeUserAssigned),
// 		UserAssignedIdentities: map[string]*armmobilenetwork.UserAssignedIdentity{
// 			"/subscriptions/subid/resourcegroups/rg1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testUserAssignedManagedIdentity": &armmobilenetwork.UserAssignedIdentity{
// 				ClientID: to.Ptr("12345678-abcd-dcba-abcd-0123456789ef"),
// 				PrincipalID: to.Ptr("12345678-abcd-dcba-abcd-0123456789ef"),
// 			},
// 		},
// 	},
// 	Properties: &armmobilenetwork.SimGroupPropertiesFormat{
// 		EncryptionKey: &armmobilenetwork.KeyVaultKey{
// 			KeyURL: to.Ptr("https://contosovault.vault.azure.net/keys/azureKey"),
// 		},
// 		MobileNetwork: &armmobilenetwork.ResourceID{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork"),
// 		},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 	},
// }

Output:

type SimGroupsClientBeginCreateOrUpdateOptions 

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

SimGroupsClientBeginCreateOrUpdateOptions contains the optional parameters for the SimGroupsClient.BeginCreateOrUpdate method.

type SimGroupsClientBeginDeleteOptions 

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

SimGroupsClientBeginDeleteOptions contains the optional parameters for the SimGroupsClient.BeginDelete method.

type SimGroupsClientCreateOrUpdateResponse 

type SimGroupsClientCreateOrUpdateResponse struct {
	SimGroup
}

SimGroupsClientCreateOrUpdateResponse contains the response from method SimGroupsClient.BeginCreateOrUpdate.

type SimGroupsClientDeleteResponse 

type SimGroupsClientDeleteResponse struct {
}

SimGroupsClientDeleteResponse contains the response from method SimGroupsClient.BeginDelete.

type SimGroupsClientGetOptions 

type SimGroupsClientGetOptions struct {
}

SimGroupsClientGetOptions contains the optional parameters for the SimGroupsClient.Get method.

type SimGroupsClientGetResponse 

type SimGroupsClientGetResponse struct {
	SimGroup
}

SimGroupsClientGetResponse contains the response from method SimGroupsClient.Get.

type SimGroupsClientListByResourceGroupOptions 

type SimGroupsClientListByResourceGroupOptions struct {
}

SimGroupsClientListByResourceGroupOptions contains the optional parameters for the SimGroupsClient.NewListByResourceGroupPager method.

type SimGroupsClientListByResourceGroupResponse 

type SimGroupsClientListByResourceGroupResponse struct {
	SimGroupListResult
}

SimGroupsClientListByResourceGroupResponse contains the response from method SimGroupsClient.NewListByResourceGroupPager.

type SimGroupsClientListBySubscriptionOptions 

type SimGroupsClientListBySubscriptionOptions struct {
}

SimGroupsClientListBySubscriptionOptions contains the optional parameters for the SimGroupsClient.NewListBySubscriptionPager method.

type SimGroupsClientListBySubscriptionResponse 

type SimGroupsClientListBySubscriptionResponse struct {
	SimGroupListResult
}

SimGroupsClientListBySubscriptionResponse contains the response from method SimGroupsClient.NewListBySubscriptionPager.

type SimGroupsClientUpdateTagsOptions 

type SimGroupsClientUpdateTagsOptions struct {
}

SimGroupsClientUpdateTagsOptions contains the optional parameters for the SimGroupsClient.UpdateTags method.

type SimGroupsClientUpdateTagsResponse 

type SimGroupsClientUpdateTagsResponse struct {
	SimGroup
}

SimGroupsClientUpdateTagsResponse contains the response from method SimGroupsClient.UpdateTags.

type SimListResult 

type SimListResult struct {
	// A list of SIMs in a resource group.
	Value []*Sim

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

SimListResult - Response for list SIMs API service call.

func (SimListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimListResult.

func (*SimListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimListResult.

type SimNameAndEncryptedProperties 

type SimNameAndEncryptedProperties struct {
	// REQUIRED; The name of the SIM.
	Name *string

	// REQUIRED; Encrypted SIM Properties.
	Properties *EncryptedSimPropertiesFormat
}

SimNameAndEncryptedProperties - SIM name and encrypted properties.

func (SimNameAndEncryptedProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimNameAndEncryptedProperties.

func (*SimNameAndEncryptedProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimNameAndEncryptedProperties.

type SimNameAndProperties 

type SimNameAndProperties struct {
	// REQUIRED; The name of the SIM.
	Name *string

	// REQUIRED; SIM Properties.
	Properties *SimPropertiesFormat
}

SimNameAndProperties - SIM name and properties.

func (SimNameAndProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimNameAndProperties.

func (*SimNameAndProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimNameAndProperties.

type SimPoliciesClient 

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

SimPoliciesClient contains the methods for the SimPolicies group. Don't use this type directly, use NewSimPoliciesClient() instead.

func NewSimPoliciesClient 

func NewSimPoliciesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SimPoliciesClient, error)

NewSimPoliciesClient creates a new instance of SimPoliciesClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*SimPoliciesClient) BeginCreateOrUpdate 

func (client *SimPoliciesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, mobileNetworkName string, simPolicyName string, parameters SimPolicy, options *SimPoliciesClientBeginCreateOrUpdateOptions) (*runtime.Poller[SimPoliciesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a SIM policy. Must be created in the same location as its parent mobile network. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • simPolicyName - The name of the SIM policy.
  • parameters - Parameters supplied to the create or update SIM policy operation.
  • options - SimPoliciesClientBeginCreateOrUpdateOptions contains the optional parameters for the SimPoliciesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimPolicyCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSimPoliciesClient().BeginCreateOrUpdate(ctx, "rg1", "testMobileNetwork", "testPolicy", armmobilenetwork.SimPolicy{
	Location: to.Ptr("eastus"),
	Properties: &armmobilenetwork.SimPolicyPropertiesFormat{
		DefaultSlice: &armmobilenetwork.SliceResourceID{
			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
		},
		RegistrationTimer: to.Ptr[int32](3240),
		SliceConfigurations: []*armmobilenetwork.SliceConfiguration{
			{
				DataNetworkConfigurations: []*armmobilenetwork.DataNetworkConfiguration{
					{
						FiveQi:                              to.Ptr[int32](9),
						AdditionalAllowedSessionTypes:       []*armmobilenetwork.PduSessionType{},
						AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
						AllowedServices: []*armmobilenetwork.ServiceResourceID{
							{
								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/testService"),
							}},
						DataNetwork: &armmobilenetwork.DataNetworkResourceID{
							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
						},
						DefaultSessionType:             to.Ptr(armmobilenetwork.PduSessionTypeIPv4),
						MaximumNumberOfBufferedPackets: to.Ptr[int32](200),
						PreemptionCapability:           to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
						PreemptionVulnerability:        to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
						SessionAmbr: &armmobilenetwork.Ambr{
							Downlink: to.Ptr("1 Gbps"),
							Uplink:   to.Ptr("500 Mbps"),
						},
					}},
				DefaultDataNetwork: &armmobilenetwork.DataNetworkResourceID{
					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
				},
				Slice: &armmobilenetwork.SliceResourceID{
					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
				},
			}},
		UeAmbr: &armmobilenetwork.Ambr{
			Downlink: to.Ptr("1 Gbps"),
			Uplink:   to.Ptr("500 Mbps"),
		},
	},
}, 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.SimPolicy = armmobilenetwork.SimPolicy{
// 	Name: to.Ptr("testPolicy"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/simPolicy"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/testPolicy"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.SimPolicyPropertiesFormat{
// 		DefaultSlice: &armmobilenetwork.SliceResourceID{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
// 		},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		RegistrationTimer: to.Ptr[int32](3240),
// 		SiteProvisioningState: map[string]*armmobilenetwork.SiteProvisioningState{
// 			"/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
// 			"/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite2": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
// 		},
// 		SliceConfigurations: []*armmobilenetwork.SliceConfiguration{
// 			{
// 				DataNetworkConfigurations: []*armmobilenetwork.DataNetworkConfiguration{
// 					{
// 						FiveQi: to.Ptr[int32](9),
// 						AdditionalAllowedSessionTypes: []*armmobilenetwork.PduSessionType{
// 						},
// 						AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
// 						AllowedServices: []*armmobilenetwork.ServiceResourceID{
// 							{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/testService"),
// 						}},
// 						DataNetwork: &armmobilenetwork.DataNetworkResourceID{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
// 						},
// 						DefaultSessionType: to.Ptr(armmobilenetwork.PduSessionTypeIPv4),
// 						MaximumNumberOfBufferedPackets: to.Ptr[int32](200),
// 						PreemptionCapability: to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
// 						PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
// 						SessionAmbr: &armmobilenetwork.Ambr{
// 							Downlink: to.Ptr("1 Gbps"),
// 							Uplink: to.Ptr("500 Mbps"),
// 						},
// 				}},
// 				DefaultDataNetwork: &armmobilenetwork.DataNetworkResourceID{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
// 				},
// 				Slice: &armmobilenetwork.SliceResourceID{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
// 				},
// 		}},
// 		UeAmbr: &armmobilenetwork.Ambr{
// 			Downlink: to.Ptr("1 Gbps"),
// 			Uplink: to.Ptr("500 Mbps"),
// 		},
// 	},
// }

Output:

func (*SimPoliciesClient) BeginDelete 

func (client *SimPoliciesClient) BeginDelete(ctx context.Context, resourceGroupName string, mobileNetworkName string, simPolicyName string, options *SimPoliciesClientBeginDeleteOptions) (*runtime.Poller[SimPoliciesClientDeleteResponse], error)

BeginDelete - Deletes the specified SIM policy. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • simPolicyName - The name of the SIM policy.
  • options - SimPoliciesClientBeginDeleteOptions contains the optional parameters for the SimPoliciesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimPolicyDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSimPoliciesClient().BeginDelete(ctx, "rg1", "testMobileNetwork", "testPolicy", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*SimPoliciesClient) Get 

func (client *SimPoliciesClient) Get(ctx context.Context, resourceGroupName string, mobileNetworkName string, simPolicyName string, options *SimPoliciesClientGetOptions) (SimPoliciesClientGetResponse, error)

Get - Gets information about the specified SIM policy. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • simPolicyName - The name of the SIM policy.
  • options - SimPoliciesClientGetOptions contains the optional parameters for the SimPoliciesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimPolicyGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSimPoliciesClient().Get(ctx, "rg1", "testMobileNetwork", "testPolicy", 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.SimPolicy = armmobilenetwork.SimPolicy{
// 	Name: to.Ptr("testPolicy"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/simPolicy"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/testPolicy"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.SimPolicyPropertiesFormat{
// 		DefaultSlice: &armmobilenetwork.SliceResourceID{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
// 		},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		RegistrationTimer: to.Ptr[int32](3240),
// 		SiteProvisioningState: map[string]*armmobilenetwork.SiteProvisioningState{
// 			"/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite": to.Ptr(armmobilenetwork.SiteProvisioningStateAdding),
// 			"/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite2": to.Ptr(armmobilenetwork.SiteProvisioningStateAdding),
// 		},
// 		SliceConfigurations: []*armmobilenetwork.SliceConfiguration{
// 			{
// 				DataNetworkConfigurations: []*armmobilenetwork.DataNetworkConfiguration{
// 					{
// 						FiveQi: to.Ptr[int32](9),
// 						AdditionalAllowedSessionTypes: []*armmobilenetwork.PduSessionType{
// 						},
// 						AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
// 						AllowedServices: []*armmobilenetwork.ServiceResourceID{
// 							{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/testService"),
// 						}},
// 						DataNetwork: &armmobilenetwork.DataNetworkResourceID{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
// 						},
// 						DefaultSessionType: to.Ptr(armmobilenetwork.PduSessionTypeIPv4),
// 						MaximumNumberOfBufferedPackets: to.Ptr[int32](200),
// 						PreemptionCapability: to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
// 						PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
// 						SessionAmbr: &armmobilenetwork.Ambr{
// 							Downlink: to.Ptr("1 Gbps"),
// 							Uplink: to.Ptr("500 Mbps"),
// 						},
// 				}},
// 				DefaultDataNetwork: &armmobilenetwork.DataNetworkResourceID{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
// 				},
// 				Slice: &armmobilenetwork.SliceResourceID{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
// 				},
// 		}},
// 		UeAmbr: &armmobilenetwork.Ambr{
// 			Downlink: to.Ptr("1 Gbps"),
// 			Uplink: to.Ptr("500 Mbps"),
// 		},
// 	},
// }

Output:

func (*SimPoliciesClient) NewListByMobileNetworkPager 

func (client *SimPoliciesClient) NewListByMobileNetworkPager(resourceGroupName string, mobileNetworkName string, options *SimPoliciesClientListByMobileNetworkOptions) *runtime.Pager[SimPoliciesClientListByMobileNetworkResponse]

NewListByMobileNetworkPager - Gets all the SIM policies in a mobile network.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • options - SimPoliciesClientListByMobileNetworkOptions contains the optional parameters for the SimPoliciesClient.NewListByMobileNetworkPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimPolicyListByMobileNetwork.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSimPoliciesClient().NewListByMobileNetworkPager("testResourceGroupName", "testMobileNetwork", 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.SimPolicyListResult = armmobilenetwork.SimPolicyListResult{
	// 	Value: []*armmobilenetwork.SimPolicy{
	// 		{
	// 			Type: to.Ptr("Microsoft.MobileNetwork/simPolicy"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/testPolicy"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("eastus"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armmobilenetwork.SimPolicyPropertiesFormat{
	// 				DefaultSlice: &armmobilenetwork.SliceResourceID{
	// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
	// 				},
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 				RegistrationTimer: to.Ptr[int32](3240),
	// 				SliceConfigurations: []*armmobilenetwork.SliceConfiguration{
	// 					{
	// 						DataNetworkConfigurations: []*armmobilenetwork.DataNetworkConfiguration{
	// 							{
	// 								FiveQi: to.Ptr[int32](9),
	// 								AdditionalAllowedSessionTypes: []*armmobilenetwork.PduSessionType{
	// 								},
	// 								AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
	// 								AllowedServices: []*armmobilenetwork.ServiceResourceID{
	// 									{
	// 										ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/testService"),
	// 								}},
	// 								DataNetwork: &armmobilenetwork.DataNetworkResourceID{
	// 									ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
	// 								},
	// 								DefaultSessionType: to.Ptr(armmobilenetwork.PduSessionTypeIPv4),
	// 								MaximumNumberOfBufferedPackets: to.Ptr[int32](200),
	// 								PreemptionCapability: to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
	// 								PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
	// 								SessionAmbr: &armmobilenetwork.Ambr{
	// 									Downlink: to.Ptr("1 Gbps"),
	// 									Uplink: to.Ptr("500 Mbps"),
	// 								},
	// 						}},
	// 						DefaultDataNetwork: &armmobilenetwork.DataNetworkResourceID{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
	// 						},
	// 						Slice: &armmobilenetwork.SliceResourceID{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
	// 						},
	// 				}},
	// 				UeAmbr: &armmobilenetwork.Ambr{
	// 					Downlink: to.Ptr("1 Gbps"),
	// 					Uplink: to.Ptr("500 Mbps"),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

func (*SimPoliciesClient) UpdateTags 

func (client *SimPoliciesClient) UpdateTags(ctx context.Context, resourceGroupName string, mobileNetworkName string, simPolicyName string, parameters TagsObject, options *SimPoliciesClientUpdateTagsOptions) (SimPoliciesClientUpdateTagsResponse, error)

UpdateTags - Updates SIM policy tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • simPolicyName - The name of the SIM policy.
  • parameters - Parameters supplied to update SIM policy tags.
  • options - SimPoliciesClientUpdateTagsOptions contains the optional parameters for the SimPoliciesClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimPolicyUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSimPoliciesClient().UpdateTags(ctx, "rg1", "testMobileNetwork", "testPolicy", armmobilenetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, 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.SimPolicy = armmobilenetwork.SimPolicy{
// 	Name: to.Ptr("testPolicy"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/simPolicy"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/testPolicy"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Properties: &armmobilenetwork.SimPolicyPropertiesFormat{
// 		DefaultSlice: &armmobilenetwork.SliceResourceID{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
// 		},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		RegistrationTimer: to.Ptr[int32](3240),
// 		SliceConfigurations: []*armmobilenetwork.SliceConfiguration{
// 			{
// 				DataNetworkConfigurations: []*armmobilenetwork.DataNetworkConfiguration{
// 					{
// 						FiveQi: to.Ptr[int32](9),
// 						AdditionalAllowedSessionTypes: []*armmobilenetwork.PduSessionType{
// 						},
// 						AllocationAndRetentionPriorityLevel: to.Ptr[int32](9),
// 						AllowedServices: []*armmobilenetwork.ServiceResourceID{
// 							{
// 								ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/testService"),
// 						}},
// 						DataNetwork: &armmobilenetwork.DataNetworkResourceID{
// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
// 						},
// 						DefaultSessionType: to.Ptr(armmobilenetwork.PduSessionTypeIPv4),
// 						MaximumNumberOfBufferedPackets: to.Ptr[int32](200),
// 						PreemptionCapability: to.Ptr(armmobilenetwork.PreemptionCapabilityNotPreempt),
// 						PreemptionVulnerability: to.Ptr(armmobilenetwork.PreemptionVulnerabilityPreemptable),
// 						SessionAmbr: &armmobilenetwork.Ambr{
// 							Downlink: to.Ptr("1 Gbps"),
// 							Uplink: to.Ptr("500 Mbps"),
// 						},
// 				}},
// 				DefaultDataNetwork: &armmobilenetwork.DataNetworkResourceID{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
// 				},
// 				Slice: &armmobilenetwork.SliceResourceID{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
// 				},
// 		}},
// 		UeAmbr: &armmobilenetwork.Ambr{
// 			Downlink: to.Ptr("1 Gbps"),
// 			Uplink: to.Ptr("500 Mbps"),
// 		},
// 	},
// }

Output:

type SimPoliciesClientBeginCreateOrUpdateOptions 

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

SimPoliciesClientBeginCreateOrUpdateOptions contains the optional parameters for the SimPoliciesClient.BeginCreateOrUpdate method.

type SimPoliciesClientBeginDeleteOptions 

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

SimPoliciesClientBeginDeleteOptions contains the optional parameters for the SimPoliciesClient.BeginDelete method.

type SimPoliciesClientCreateOrUpdateResponse 

type SimPoliciesClientCreateOrUpdateResponse struct {
	SimPolicy
}

SimPoliciesClientCreateOrUpdateResponse contains the response from method SimPoliciesClient.BeginCreateOrUpdate.

type SimPoliciesClientDeleteResponse 

type SimPoliciesClientDeleteResponse struct {
}

SimPoliciesClientDeleteResponse contains the response from method SimPoliciesClient.BeginDelete.

type SimPoliciesClientGetOptions 

type SimPoliciesClientGetOptions struct {
}

SimPoliciesClientGetOptions contains the optional parameters for the SimPoliciesClient.Get method.

type SimPoliciesClientGetResponse 

type SimPoliciesClientGetResponse struct {
	SimPolicy
}

SimPoliciesClientGetResponse contains the response from method SimPoliciesClient.Get.

type SimPoliciesClientListByMobileNetworkOptions 

type SimPoliciesClientListByMobileNetworkOptions struct {
}

SimPoliciesClientListByMobileNetworkOptions contains the optional parameters for the SimPoliciesClient.NewListByMobileNetworkPager method.

type SimPoliciesClientListByMobileNetworkResponse 

type SimPoliciesClientListByMobileNetworkResponse struct {
	SimPolicyListResult
}

SimPoliciesClientListByMobileNetworkResponse contains the response from method SimPoliciesClient.NewListByMobileNetworkPager.

type SimPoliciesClientUpdateTagsOptions 

type SimPoliciesClientUpdateTagsOptions struct {
}

SimPoliciesClientUpdateTagsOptions contains the optional parameters for the SimPoliciesClient.UpdateTags method.

type SimPoliciesClientUpdateTagsResponse 

type SimPoliciesClientUpdateTagsResponse struct {
	SimPolicy
}

SimPoliciesClientUpdateTagsResponse contains the response from method SimPoliciesClient.UpdateTags.

type SimPolicy 

type SimPolicy struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; SIM policy Properties.
	Properties *SimPolicyPropertiesFormat

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

SimPolicy - SIM policy resource.

func (SimPolicy) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimPolicy.

func (*SimPolicy) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimPolicy.

type SimPolicyListResult 

type SimPolicyListResult struct {
	// A list of SIM policies.
	Value []*SimPolicy

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

SimPolicyListResult - Response for SIM policies API service call.

func (SimPolicyListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimPolicyListResult.

func (*SimPolicyListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimPolicyListResult.

type SimPolicyPropertiesFormat 

type SimPolicyPropertiesFormat struct {
	// REQUIRED; The default slice to use if the UE does not explicitly specify it. This slice must exist in the sliceConfigurations
	// map. The slice must be in the same location as the SIM policy.
	DefaultSlice *SliceResourceID

	// REQUIRED; The allowed slices and the settings to use for them. The list must not contain duplicate items and must contain
	// at least one item.
	SliceConfigurations []*SliceConfiguration

	// REQUIRED; Aggregate maximum bit rate across all non-GBR QoS flows of all PDU sessions of a given UE. See 3GPP TS23.501
	// section 5.7.2.6 for a full description of the UE-AMBR.
	UeAmbr *Ambr

	// Interval for the UE periodic registration update procedure, in seconds.
	RegistrationTimer *int32

	// RAT/Frequency Selection Priority Index, defined in 3GPP TS 36.413. This is an optional setting and by default is unspecified.
	RfspIndex *int32

	// READ-ONLY; The provisioning state of the SIM policy resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; A dictionary of sites to the provisioning state of this SIM policy on that site.
	SiteProvisioningState map[string]*SiteProvisioningState
}

SimPolicyPropertiesFormat - SIM policy properties. Must be created in the same location as its parent mobile network.

func (SimPolicyPropertiesFormat) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimPolicyPropertiesFormat.

func (*SimPolicyPropertiesFormat) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimPolicyPropertiesFormat.

type SimPolicyResourceID 

type SimPolicyResourceID struct {
	// REQUIRED; SIM policy resource ID.
	ID *string
}

SimPolicyResourceID - Reference to a SIM policy resource.

func (SimPolicyResourceID) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimPolicyResourceID.

func (*SimPolicyResourceID) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimPolicyResourceID.

type SimPropertiesFormat 

type SimPropertiesFormat struct {
	// REQUIRED; The international mobile subscriber identity (IMSI) for the SIM.
	InternationalMobileSubscriberIdentity *string

	// The Ki value for the SIM.
	AuthenticationKey *string

	// An optional free-form text field that can be used to record the device type this SIM is associated with, for example 'Video
	// camera'. The Azure portal allows SIMs to be grouped and filtered based on
	// this value.
	DeviceType *string

	// The integrated circuit card ID (ICCID) for the SIM.
	IntegratedCircuitCardIdentifier *string

	// The Opc value for the SIM.
	OperatorKeyCode *string

	// The SIM policy used by this SIM. The SIM policy must be in the same location as the SIM.
	SimPolicy *SimPolicyResourceID

	// A list of static IP addresses assigned to this SIM. Each address is assigned at a defined network scope, made up of {attached
	// data network, slice}.
	StaticIPConfiguration []*SimStaticIPProperties

	// READ-ONLY; The provisioning state of the SIM resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The state of the SIM resource.
	SimState *SimState

	// READ-ONLY; A dictionary of sites to the provisioning state of this SIM on that site.
	SiteProvisioningState map[string]*SiteProvisioningState

	// READ-ONLY; The public key fingerprint of the SIM vendor who provided this SIM, if any.
	VendorKeyFingerprint *string

	// READ-ONLY; The name of the SIM vendor who provided this SIM, if any.
	VendorName *string
}

SimPropertiesFormat - SIM properties.

func (SimPropertiesFormat) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimPropertiesFormat.

func (*SimPropertiesFormat) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimPropertiesFormat.

type SimState 

type SimState string

SimState - The state of the SIM resource. 

const (
	// SimStateDisabled - The SIM is disabled because not all configuration required for enabling is present.
	SimStateDisabled SimState = "Disabled"
	// SimStateEnabled - The SIM is enabled.
	SimStateEnabled SimState = "Enabled"
	// SimStateInvalid - The SIM cannot be enabled because some of the associated configuration is invalid.
	SimStateInvalid SimState = "Invalid"
)

func PossibleSimStateValues 

func PossibleSimStateValues() []SimState

PossibleSimStateValues returns the possible values for the SimState const type.

type SimStaticIPProperties 

type SimStaticIPProperties struct {
	// The attached data network on which the static IP address will be used. The combination of attached data network and slice
	// defines the network scope of the IP address. The attached data network must be
	// in the same location as the SIM.
	AttachedDataNetwork *AttachedDataNetworkResourceID

	// The network slice on which the static IP address will be used. The combination of attached data network and slice defines
	// the network scope of the IP address. The slice must be in the same location as
	// the SIM.
	Slice *SliceResourceID

	// The static IP configuration for the SIM to use at the defined network scope.
	StaticIP *SimStaticIPPropertiesStaticIP
}

SimStaticIPProperties - Static IP configuration for a SIM, scoped to a particular attached data network and slice.

func (SimStaticIPProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimStaticIPProperties.

func (*SimStaticIPProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimStaticIPProperties.

type SimStaticIPPropertiesStaticIP 

type SimStaticIPPropertiesStaticIP struct {
	// The IPv4 address assigned to the SIM at this network scope. This address must be in the userEquipmentStaticAddressPoolPrefix
	// defined in the attached data network.
	IPv4Address *string
}

SimStaticIPPropertiesStaticIP - The static IP configuration for the SIM to use at the defined network scope.

func (SimStaticIPPropertiesStaticIP) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimStaticIPPropertiesStaticIP.

func (*SimStaticIPPropertiesStaticIP) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimStaticIPPropertiesStaticIP.

type SimUploadList 

type SimUploadList struct {
	// REQUIRED; A list of SIMs to upload.
	Sims []*SimNameAndProperties
}

SimUploadList - The SIMs to upload.

func (SimUploadList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SimUploadList.

func (*SimUploadList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SimUploadList.

type SimsClient 

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

SimsClient contains the methods for the Sims group. Don't use this type directly, use NewSimsClient() instead.

func NewSimsClient 

func NewSimsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SimsClient, error)

NewSimsClient creates a new instance of SimsClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*SimsClient) BeginBulkDelete 

func (client *SimsClient) BeginBulkDelete(ctx context.Context, resourceGroupName string, simGroupName string, parameters SimDeleteList, options *SimsClientBeginBulkDeleteOptions) (*runtime.Poller[SimsClientBulkDeleteResponse], error)

BeginBulkDelete - Bulk delete SIMs from a SIM group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • simGroupName - The name of the SIM Group.
  • parameters - Parameters supplied to the bulk SIM delete operation.
  • options - SimsClientBeginBulkDeleteOptions contains the optional parameters for the SimsClient.BeginBulkDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimBulkDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSimsClient().BeginBulkDelete(ctx, "testResourceGroupName", "testSimGroup", armmobilenetwork.SimDeleteList{
	Sims: []*string{
		to.Ptr("testSim"),
		to.Ptr("testSim2")},
}, 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.AsyncOperationStatus = armmobilenetwork.AsyncOperationStatus{
// 	Name: to.Ptr("testOperation"),
// 	EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-19T03:38:07.000Z"); return t}()),
// 	ID: to.Ptr("/providers/Microsoft.MobileNetwork/locations/testLocation/operationStatuses/testOperation"),
// 	StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-19T03:36:07.000Z"); return t}()),
// 	Status: to.Ptr("Succeeded"),
// }

Output:

func (*SimsClient) BeginBulkUpload 

func (client *SimsClient) BeginBulkUpload(ctx context.Context, resourceGroupName string, simGroupName string, parameters SimUploadList, options *SimsClientBeginBulkUploadOptions) (*runtime.Poller[SimsClientBulkUploadResponse], error)

BeginBulkUpload - Bulk upload SIMs to a SIM group. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • simGroupName - The name of the SIM Group.
  • parameters - Parameters supplied to the bulk SIM upload operation.
  • options - SimsClientBeginBulkUploadOptions contains the optional parameters for the SimsClient.BeginBulkUpload method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimBulkUpload.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSimsClient().BeginBulkUpload(ctx, "rg1", "testSimGroup", armmobilenetwork.SimUploadList{
	Sims: []*armmobilenetwork.SimNameAndProperties{
		{
			Name: to.Ptr("testSim"),
			Properties: &armmobilenetwork.SimPropertiesFormat{
				DeviceType:                            to.Ptr("Video camera"),
				IntegratedCircuitCardIdentifier:       to.Ptr("8900000000000000000"),
				InternationalMobileSubscriberIdentity: to.Ptr("00000"),
				SimPolicy: &armmobilenetwork.SimPolicyResourceID{
					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
				},
				StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
					{
						AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
						},
						Slice: &armmobilenetwork.SliceResourceID{
							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
						},
						StaticIP: &armmobilenetwork.SimStaticIPPropertiesStaticIP{
							IPv4Address: to.Ptr("2.4.0.1"),
						},
					}},
				AuthenticationKey: to.Ptr("00000000000000000000000000000000"),
				OperatorKeyCode:   to.Ptr("00000000000000000000000000000000"),
			},
		},
		{
			Name: to.Ptr("testSim2"),
			Properties: &armmobilenetwork.SimPropertiesFormat{
				DeviceType:                            to.Ptr("Video camera"),
				IntegratedCircuitCardIdentifier:       to.Ptr("8900000000000000001"),
				InternationalMobileSubscriberIdentity: to.Ptr("00000"),
				SimPolicy: &armmobilenetwork.SimPolicyResourceID{
					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
				},
				StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
					{
						AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
						},
						Slice: &armmobilenetwork.SliceResourceID{
							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
						},
						StaticIP: &armmobilenetwork.SimStaticIPPropertiesStaticIP{
							IPv4Address: to.Ptr("2.4.0.2"),
						},
					}},
				AuthenticationKey: to.Ptr("00000000000000000000000000000000"),
				OperatorKeyCode:   to.Ptr("00000000000000000000000000000000"),
			},
		}},
}, 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.AsyncOperationStatus = armmobilenetwork.AsyncOperationStatus{
// 	Name: to.Ptr("testOperation"),
// 	EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-19T03:38:07.000Z"); return t}()),
// 	ID: to.Ptr("/providers/Microsoft.MobileNetwork/locations/testLocation/operationStatuses/testOperation"),
// 	StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-19T03:36:07.000Z"); return t}()),
// 	Status: to.Ptr("Succeeded"),
// }

Output:

func (*SimsClient) BeginBulkUploadEncrypted 

func (client *SimsClient) BeginBulkUploadEncrypted(ctx context.Context, resourceGroupName string, simGroupName string, parameters EncryptedSimUploadList, options *SimsClientBeginBulkUploadEncryptedOptions) (*runtime.Poller[SimsClientBulkUploadEncryptedResponse], error)

BeginBulkUploadEncrypted - Bulk upload SIMs in encrypted form to a SIM group. The SIM credentials must be encrypted. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • simGroupName - The name of the SIM Group.
  • parameters - Parameters supplied to the encrypted SIMs upload operation.
  • options - SimsClientBeginBulkUploadEncryptedOptions contains the optional parameters for the SimsClient.BeginBulkUploadEncrypted method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimBulkUploadEncrypted.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSimsClient().BeginBulkUploadEncrypted(ctx, "rg1", "testSimGroup", armmobilenetwork.EncryptedSimUploadList{
	AzureKeyIdentifier:    to.Ptr[int32](1),
	EncryptedTransportKey: to.Ptr("ABC123"),
	SignedTransportKey:    to.Ptr("ABC123"),
	Sims: []*armmobilenetwork.SimNameAndEncryptedProperties{
		{
			Name: to.Ptr("testSim"),
			Properties: &armmobilenetwork.EncryptedSimPropertiesFormat{
				DeviceType:                            to.Ptr("Video camera"),
				IntegratedCircuitCardIdentifier:       to.Ptr("8900000000000000000"),
				InternationalMobileSubscriberIdentity: to.Ptr("00000"),
				SimPolicy: &armmobilenetwork.SimPolicyResourceID{
					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
				},
				StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
					{
						AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
						},
						Slice: &armmobilenetwork.SliceResourceID{
							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
						},
						StaticIP: &armmobilenetwork.SimStaticIPPropertiesStaticIP{
							IPv4Address: to.Ptr("2.4.0.1"),
						},
					}},
				EncryptedCredentials: to.Ptr("ABC123"),
			},
		},
		{
			Name: to.Ptr("testSim2"),
			Properties: &armmobilenetwork.EncryptedSimPropertiesFormat{
				DeviceType:                            to.Ptr("Video camera"),
				IntegratedCircuitCardIdentifier:       to.Ptr("8900000000000000001"),
				InternationalMobileSubscriberIdentity: to.Ptr("00000"),
				SimPolicy: &armmobilenetwork.SimPolicyResourceID{
					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
				},
				StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
					{
						AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
						},
						Slice: &armmobilenetwork.SliceResourceID{
							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
						},
						StaticIP: &armmobilenetwork.SimStaticIPPropertiesStaticIP{
							IPv4Address: to.Ptr("2.4.0.2"),
						},
					}},
				EncryptedCredentials: to.Ptr("ABC123"),
			},
		}},
	VendorKeyFingerprint: to.Ptr("ABC123"),
	Version:              to.Ptr[int32](1),
}, 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.AsyncOperationStatus = armmobilenetwork.AsyncOperationStatus{
// 	Name: to.Ptr("testOperation"),
// 	EndTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-19T03:38:07.000Z"); return t}()),
// 	ID: to.Ptr("/providers/Microsoft.MobileNetwork/locations/testLocation/operationStatuses/testOperation"),
// 	StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-19T03:36:07.000Z"); return t}()),
// 	Status: to.Ptr("Succeeded"),
// }

Output:

func (*SimsClient) BeginCreateOrUpdate 

func (client *SimsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, simGroupName string, simName string, parameters Sim, options *SimsClientBeginCreateOrUpdateOptions) (*runtime.Poller[SimsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a SIM. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • simGroupName - The name of the SIM Group.
  • simName - The name of the SIM.
  • parameters - Parameters supplied to the create or update SIM operation.
  • options - SimsClientBeginCreateOrUpdateOptions contains the optional parameters for the SimsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSimsClient().BeginCreateOrUpdate(ctx, "rg1", "testSimGroup", "testSim", armmobilenetwork.Sim{
	Properties: &armmobilenetwork.SimPropertiesFormat{
		DeviceType:                            to.Ptr("Video camera"),
		IntegratedCircuitCardIdentifier:       to.Ptr("8900000000000000000"),
		InternationalMobileSubscriberIdentity: to.Ptr("00000"),
		SimPolicy: &armmobilenetwork.SimPolicyResourceID{
			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
		},
		StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
			{
				AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
				},
				Slice: &armmobilenetwork.SliceResourceID{
					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
				},
				StaticIP: &armmobilenetwork.SimStaticIPPropertiesStaticIP{
					IPv4Address: to.Ptr("2.4.0.1"),
				},
			}},
		AuthenticationKey: to.Ptr("00000000000000000000000000000000"),
		OperatorKeyCode:   to.Ptr("00000000000000000000000000000000"),
	},
}, 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.Sim = armmobilenetwork.Sim{
// 	Name: to.Ptr("testSim"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/simGroups/sims"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/simGroups/testSimGroup/sims/testSim"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Properties: &armmobilenetwork.SimPropertiesFormat{
// 		DeviceType: to.Ptr("Video camera"),
// 		IntegratedCircuitCardIdentifier: to.Ptr("8900000000000000000"),
// 		InternationalMobileSubscriberIdentity: to.Ptr("00000"),
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		SimPolicy: &armmobilenetwork.SimPolicyResourceID{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
// 		},
// 		SimState: to.Ptr(armmobilenetwork.SimStateEnabled),
// 		SiteProvisioningState: map[string]*armmobilenetwork.SiteProvisioningState{
// 			"/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
// 			"/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite2": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
// 		},
// 		StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
// 			{
// 				AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
// 				},
// 				Slice: &armmobilenetwork.SliceResourceID{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
// 				},
// 				StaticIP: &armmobilenetwork.SimStaticIPPropertiesStaticIP{
// 					IPv4Address: to.Ptr("2.4.0.1"),
// 				},
// 		}},
// 	},
// }

Output:

func (*SimsClient) BeginDelete 

func (client *SimsClient) BeginDelete(ctx context.Context, resourceGroupName string, simGroupName string, simName string, options *SimsClientBeginDeleteOptions) (*runtime.Poller[SimsClientDeleteResponse], error)

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

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • simGroupName - The name of the SIM Group.
  • simName - The name of the SIM.
  • options - SimsClientBeginDeleteOptions contains the optional parameters for the SimsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSimsClient().BeginDelete(ctx, "testResourceGroupName", "testSimGroup", "testSim", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*SimsClient) Get 

func (client *SimsClient) Get(ctx context.Context, resourceGroupName string, simGroupName string, simName string, options *SimsClientGetOptions) (SimsClientGetResponse, error)

Get - Gets information about the specified SIM. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • simGroupName - The name of the SIM Group.
  • simName - The name of the SIM.
  • options - SimsClientGetOptions contains the optional parameters for the SimsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSimsClient().Get(ctx, "testResourceGroupName", "testSimGroup", "testSimName", 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.Sim = armmobilenetwork.Sim{
// 	Name: to.Ptr("testSim"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/simGroups/sims"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/simGroups/testSimGroup/sims/testSim"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Properties: &armmobilenetwork.SimPropertiesFormat{
// 		DeviceType: to.Ptr("Video camera"),
// 		IntegratedCircuitCardIdentifier: to.Ptr("8900000000000000000"),
// 		InternationalMobileSubscriberIdentity: to.Ptr("00000"),
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		SimPolicy: &armmobilenetwork.SimPolicyResourceID{
// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
// 		},
// 		SimState: to.Ptr(armmobilenetwork.SimStateEnabled),
// 		SiteProvisioningState: map[string]*armmobilenetwork.SiteProvisioningState{
// 			"/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
// 			"/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite2": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
// 		},
// 		StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
// 			{
// 				AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
// 				},
// 				Slice: &armmobilenetwork.SliceResourceID{
// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
// 				},
// 				StaticIP: &armmobilenetwork.SimStaticIPPropertiesStaticIP{
// 					IPv4Address: to.Ptr("2.4.0.1"),
// 				},
// 		}},
// 	},
// }

Output:

func (*SimsClient) NewListByGroupPager 

func (client *SimsClient) NewListByGroupPager(resourceGroupName string, simGroupName string, options *SimsClientListByGroupOptions) *runtime.Pager[SimsClientListByGroupResponse]

NewListByGroupPager - Gets all the SIMs in a SIM group.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • simGroupName - The name of the SIM Group.
  • options - SimsClientListByGroupOptions contains the optional parameters for the SimsClient.NewListByGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SimListBySimGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSimsClient().NewListByGroupPager("rg1", "testSimGroup", 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.SimListResult = armmobilenetwork.SimListResult{
	// 	Value: []*armmobilenetwork.Sim{
	// 		{
	// 			Name: to.Ptr("testSim"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/simGroups/sims"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/simGroups/testSimGroup/sims/testSim"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Properties: &armmobilenetwork.SimPropertiesFormat{
	// 				DeviceType: to.Ptr("Video camera"),
	// 				IntegratedCircuitCardIdentifier: to.Ptr("8900000000000000000"),
	// 				InternationalMobileSubscriberIdentity: to.Ptr("00000"),
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 				SimPolicy: &armmobilenetwork.SimPolicyResourceID{
	// 					ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
	// 				},
	// 				SimState: to.Ptr(armmobilenetwork.SimStateEnabled),
	// 				SiteProvisioningState: map[string]*armmobilenetwork.SiteProvisioningState{
	// 					"/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
	// 					"/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite2": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
	// 				},
	// 				StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
	// 					{
	// 						AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
	// 						},
	// 						Slice: &armmobilenetwork.SliceResourceID{
	// 							ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
	// 						},
	// 						StaticIP: &armmobilenetwork.SimStaticIPPropertiesStaticIP{
	// 							IPv4Address: to.Ptr("2.4.0.1"),
	// 						},
	// 				}},
	// 			},
	// 	}},
	// }
}

Output:

type SimsClientBeginBulkDeleteOptions 

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

SimsClientBeginBulkDeleteOptions contains the optional parameters for the SimsClient.BeginBulkDelete method.

type SimsClientBeginBulkUploadEncryptedOptions 

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

SimsClientBeginBulkUploadEncryptedOptions contains the optional parameters for the SimsClient.BeginBulkUploadEncrypted method.

type SimsClientBeginBulkUploadOptions 

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

SimsClientBeginBulkUploadOptions contains the optional parameters for the SimsClient.BeginBulkUpload method.

type SimsClientBeginCreateOrUpdateOptions 

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

SimsClientBeginCreateOrUpdateOptions contains the optional parameters for the SimsClient.BeginCreateOrUpdate method.

type SimsClientBeginDeleteOptions 

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

SimsClientBeginDeleteOptions contains the optional parameters for the SimsClient.BeginDelete method.

type SimsClientBulkDeleteResponse 

type SimsClientBulkDeleteResponse struct {
	AsyncOperationStatus
}

SimsClientBulkDeleteResponse contains the response from method SimsClient.BeginBulkDelete.

type SimsClientBulkUploadEncryptedResponse 

type SimsClientBulkUploadEncryptedResponse struct {
	AsyncOperationStatus
}

SimsClientBulkUploadEncryptedResponse contains the response from method SimsClient.BeginBulkUploadEncrypted.

type SimsClientBulkUploadResponse 

type SimsClientBulkUploadResponse struct {
	AsyncOperationStatus
}

SimsClientBulkUploadResponse contains the response from method SimsClient.BeginBulkUpload.

type SimsClientCreateOrUpdateResponse 

type SimsClientCreateOrUpdateResponse struct {
	Sim
}

SimsClientCreateOrUpdateResponse contains the response from method SimsClient.BeginCreateOrUpdate.

type SimsClientDeleteResponse 

type SimsClientDeleteResponse struct {
}

SimsClientDeleteResponse contains the response from method SimsClient.BeginDelete.

type SimsClientGetOptions 

type SimsClientGetOptions struct {
}

SimsClientGetOptions contains the optional parameters for the SimsClient.Get method.

type SimsClientGetResponse 

type SimsClientGetResponse struct {
	Sim
}

SimsClientGetResponse contains the response from method SimsClient.Get.

type SimsClientListByGroupOptions 

type SimsClientListByGroupOptions struct {
}

SimsClientListByGroupOptions contains the optional parameters for the SimsClient.NewListByGroupPager method.

type SimsClientListByGroupResponse 

type SimsClientListByGroupResponse struct {
	SimListResult
}

SimsClientListByGroupResponse contains the response from method SimsClient.NewListByGroupPager.

type Site 

type Site struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// Site properties.
	Properties *SitePropertiesFormat

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

Site resource. Must be created in the same location as its parent mobile network.

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 SiteListResult 

type SiteListResult struct {
	// A list of sites in a mobile network.
	Value []*Site

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

SiteListResult - Response for sites API service call.

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 SitePropertiesFormat 

type SitePropertiesFormat struct {
	// READ-ONLY; An array of IDs of the network functions deployed in the site. Deleting the site will delete any network functions
	// that are deployed in the site.
	NetworkFunctions []*SubResource

	// READ-ONLY; The provisioning state of the site resource.
	ProvisioningState *ProvisioningState
}

SitePropertiesFormat - Site properties.

func (SitePropertiesFormat) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SitePropertiesFormat.

func (*SitePropertiesFormat) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SitePropertiesFormat.

type SiteProvisioningState 

type SiteProvisioningState string

SiteProvisioningState - The provisioning state of a resource e.g. SIM/SIM policy on a site. 

const (
	// SiteProvisioningStateAdding - The resource is being added to this site.
	SiteProvisioningStateAdding SiteProvisioningState = "Adding"
	// SiteProvisioningStateDeleting - The resource is being deleted from this site.
	SiteProvisioningStateDeleting SiteProvisioningState = "Deleting"
	// SiteProvisioningStateFailed - The resource failed to be provisioned on this site.
	SiteProvisioningStateFailed SiteProvisioningState = "Failed"
	// SiteProvisioningStateNotApplicable - The resource should not be provisioned on this site.
	SiteProvisioningStateNotApplicable SiteProvisioningState = "NotApplicable"
	// SiteProvisioningStateProvisioned - The resource is provisioned on this site.
	SiteProvisioningStateProvisioned SiteProvisioningState = "Provisioned"
	// SiteProvisioningStateUpdating - The resource is being updated on this site.
	SiteProvisioningStateUpdating SiteProvisioningState = "Updating"
)

func PossibleSiteProvisioningStateValues 

func PossibleSiteProvisioningStateValues() []SiteProvisioningState

PossibleSiteProvisioningStateValues returns the possible values for the SiteProvisioningState const type.

type SiteResourceID 

type SiteResourceID struct {
	// REQUIRED; Site resource ID.
	ID *string
}

SiteResourceID - Reference to a site resource.

func (SiteResourceID) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SiteResourceID.

func (*SiteResourceID) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SiteResourceID.

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.
  • 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, mobileNetworkName string, siteName string, parameters Site, options *SitesClientBeginCreateOrUpdateOptions) (*runtime.Poller[SitesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a mobile network site. Must be created in the same location as its parent mobile network. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • siteName - The name of the mobile network site.
  • parameters - Parameters supplied to the create or update mobile network site operation.
  • options - SitesClientBeginCreateOrUpdateOptions contains the optional parameters for the SitesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SiteCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSitesClient().BeginCreateOrUpdate(ctx, "rg1", "testMobileNetwork", "testSite", armmobilenetwork.Site{
	Location:   to.Ptr("testLocation"),
	Properties: &armmobilenetwork.SitePropertiesFormat{},
}, 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.Site = armmobilenetwork.Site{
// 	Name: to.Ptr("testSite"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks/sites"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("testLocation"),
// 	Properties: &armmobilenetwork.SitePropertiesFormat{
// 		NetworkFunctions: []*armmobilenetwork.SubResource{
// 		},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 	},
// }

Output:

func (*SitesClient) BeginDelete 

func (client *SitesClient) BeginDelete(ctx context.Context, resourceGroupName string, mobileNetworkName string, siteName string, options *SitesClientBeginDeleteOptions) (*runtime.Poller[SitesClientDeleteResponse], error)

BeginDelete - Deletes the specified mobile network site. This will also delete any network functions that are a part of this site. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • siteName - The name of the mobile network site.
  • options - SitesClientBeginDeleteOptions contains the optional parameters for the SitesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SiteDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSitesClient().BeginDelete(ctx, "rg1", "testMobileNetwork", "testSite", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*SitesClient) Get 

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

Get - Gets information about the specified mobile network site. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SiteGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSitesClient().Get(ctx, "rg1", "testMobileNetwork", "testSite", 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.Site = armmobilenetwork.Site{
// 	Name: to.Ptr("testSite"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks/sites"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("testLocation"),
// 	Properties: &armmobilenetwork.SitePropertiesFormat{
// 		NetworkFunctions: []*armmobilenetwork.SubResource{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HybridNetwork/networkFunctions/testNf"),
// 		}},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 	},
// }

Output:

func (*SitesClient) NewListByMobileNetworkPager 

func (client *SitesClient) NewListByMobileNetworkPager(resourceGroupName string, mobileNetworkName string, options *SitesClientListByMobileNetworkOptions) *runtime.Pager[SitesClientListByMobileNetworkResponse]

NewListByMobileNetworkPager - Lists all sites in the mobile network.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • options - SitesClientListByMobileNetworkOptions contains the optional parameters for the SitesClient.NewListByMobileNetworkPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SiteListByMobileNetwork.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSitesClient().NewListByMobileNetworkPager("rg1", "testMobileNetwork", 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.SiteListResult = armmobilenetwork.SiteListResult{
	// 	Value: []*armmobilenetwork.Site{
	// 		{
	// 			Name: to.Ptr("testSite"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks/sites"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("testLocation"),
	// 			Properties: &armmobilenetwork.SitePropertiesFormat{
	// 				NetworkFunctions: []*armmobilenetwork.SubResource{
	// 					{
	// 						ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HybridNetwork/networkFunctions/testNf"),
	// 				}},
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 			},
	// 	}},
	// }
}

Output:

func (*SitesClient) UpdateTags 

func (client *SitesClient) UpdateTags(ctx context.Context, resourceGroupName string, mobileNetworkName string, siteName string, parameters TagsObject, options *SitesClientUpdateTagsOptions) (SitesClientUpdateTagsResponse, error)

UpdateTags - Updates site tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • siteName - The name of the mobile network site.
  • parameters - Parameters supplied to update network site tags.
  • options - SitesClientUpdateTagsOptions contains the optional parameters for the SitesClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SiteUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSitesClient().UpdateTags(ctx, "rg1", "testMobileNetwork", "testSite", armmobilenetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, 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.Site = armmobilenetwork.Site{
// 	Name: to.Ptr("testSite"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks/sites"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("testLocation"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Properties: &armmobilenetwork.SitePropertiesFormat{
// 		NetworkFunctions: []*armmobilenetwork.SubResource{
// 			{
// 				ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.HybridNetwork/networkFunctions/testNf"),
// 		}},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 	},
// }

Output:

type SitesClientBeginCreateOrUpdateOptions 

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

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

type SitesClientBeginDeleteOptions 

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

SitesClientBeginDeleteOptions contains the optional parameters for the SitesClient.BeginDelete method.

type SitesClientCreateOrUpdateResponse 

type SitesClientCreateOrUpdateResponse struct {
	Site
}

SitesClientCreateOrUpdateResponse contains the response from method SitesClient.BeginCreateOrUpdate.

type SitesClientDeleteResponse 

type SitesClientDeleteResponse struct {
}

SitesClientDeleteResponse contains the response from method SitesClient.BeginDelete.

type SitesClientGetOptions 

type SitesClientGetOptions struct {
}

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

type SitesClientGetResponse 

type SitesClientGetResponse struct {
	Site
}

SitesClientGetResponse contains the response from method SitesClient.Get.

type SitesClientListByMobileNetworkOptions 

type SitesClientListByMobileNetworkOptions struct {
}

SitesClientListByMobileNetworkOptions contains the optional parameters for the SitesClient.NewListByMobileNetworkPager method.

type SitesClientListByMobileNetworkResponse 

type SitesClientListByMobileNetworkResponse struct {
	SiteListResult
}

SitesClientListByMobileNetworkResponse contains the response from method SitesClient.NewListByMobileNetworkPager.

type SitesClientUpdateTagsOptions 

type SitesClientUpdateTagsOptions struct {
}

SitesClientUpdateTagsOptions contains the optional parameters for the SitesClient.UpdateTags method.

type SitesClientUpdateTagsResponse 

type SitesClientUpdateTagsResponse struct {
	Site
}

SitesClientUpdateTagsResponse contains the response from method SitesClient.UpdateTags.

type Slice 

type Slice struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// REQUIRED; Slice properties.
	Properties *SlicePropertiesFormat

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

Slice - Network slice resource. Must be created in the same location as its parent mobile network.

func (Slice) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Slice.

func (*Slice) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Slice.

type SliceConfiguration 

type SliceConfiguration struct {
	// REQUIRED; The allowed data networks and the settings to use for them. The list must not contain duplicate items and must
	// contain at least one item.
	DataNetworkConfigurations []*DataNetworkConfiguration

	// REQUIRED; The default data network to use if the UE does not explicitly specify it. Configuration for this object must
	// exist in the dataNetworkConfigurations map. The data network must be in the same location
	// as the SIM policy.
	DefaultDataNetwork *DataNetworkResourceID

	// REQUIRED; A reference to the slice that these settings apply to. The slice must be in the same location as the SIM policy.
	Slice *SliceResourceID
}

SliceConfiguration - Per-slice settings

func (SliceConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SliceConfiguration.

func (*SliceConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SliceConfiguration.

type SliceListResult 

type SliceListResult struct {
	// A list of network slices in a mobile network.
	Value []*Slice

	// READ-ONLY; The URL to get the next set of results.
	NextLink *string
}

SliceListResult - Response for network slice API service call.

func (SliceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SliceListResult.

func (*SliceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SliceListResult.

type SlicePropertiesFormat 

type SlicePropertiesFormat struct {
	// REQUIRED; Single-network slice selection assistance information (S-NSSAI). Unique at the scope of a mobile network.
	Snssai *Snssai

	// An optional description for this network slice.
	Description *string

	// READ-ONLY; The provisioning state of the network slice resource.
	ProvisioningState *ProvisioningState
}

SlicePropertiesFormat - Network slice properties.

func (SlicePropertiesFormat) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SlicePropertiesFormat.

func (*SlicePropertiesFormat) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SlicePropertiesFormat.

type SliceResourceID 

type SliceResourceID struct {
	// REQUIRED; Slice resource ID.
	ID *string
}

SliceResourceID - Reference to a slice resource.

func (SliceResourceID) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SliceResourceID.

func (*SliceResourceID) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SliceResourceID.

type SlicesClient 

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

SlicesClient contains the methods for the Slices group. Don't use this type directly, use NewSlicesClient() instead.

func NewSlicesClient 

func NewSlicesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SlicesClient, error)

NewSlicesClient creates a new instance of SlicesClient with the specified values.

  • subscriptionID - The ID of the target subscription.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*SlicesClient) BeginCreateOrUpdate 

func (client *SlicesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, mobileNetworkName string, sliceName string, parameters Slice, options *SlicesClientBeginCreateOrUpdateOptions) (*runtime.Poller[SlicesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a network slice. Must be created in the same location as its parent mobile network. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • sliceName - The name of the network slice.
  • parameters - Parameters supplied to the create or update network slice operation.
  • options - SlicesClientBeginCreateOrUpdateOptions contains the optional parameters for the SlicesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SliceCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSlicesClient().BeginCreateOrUpdate(ctx, "rg1", "testMobileNetwork", "testSlice", armmobilenetwork.Slice{
	Location: to.Ptr("eastus"),
	Properties: &armmobilenetwork.SlicePropertiesFormat{
		Description: to.Ptr("myFavouriteSlice"),
		Snssai: &armmobilenetwork.Snssai{
			Sd:  to.Ptr("1abcde"),
			Sst: to.Ptr[int32](1),
		},
	},
}, 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.Slice = armmobilenetwork.Slice{
// 	Name: to.Ptr("testSlice"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks/slices"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.SlicePropertiesFormat{
// 		Description: to.Ptr("myFavouriteSlice"),
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		Snssai: &armmobilenetwork.Snssai{
// 			Sd: to.Ptr("1abcde"),
// 			Sst: to.Ptr[int32](1),
// 		},
// 	},
// }

Output:

func (*SlicesClient) BeginDelete 

func (client *SlicesClient) BeginDelete(ctx context.Context, resourceGroupName string, mobileNetworkName string, sliceName string, options *SlicesClientBeginDeleteOptions) (*runtime.Poller[SlicesClientDeleteResponse], error)

BeginDelete - Deletes the specified network slice. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • sliceName - The name of the network slice.
  • options - SlicesClientBeginDeleteOptions contains the optional parameters for the SlicesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SliceDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewSlicesClient().BeginDelete(ctx, "rg1", "testMobileNetwork", "testSlice", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*SlicesClient) Get 

func (client *SlicesClient) Get(ctx context.Context, resourceGroupName string, mobileNetworkName string, sliceName string, options *SlicesClientGetOptions) (SlicesClientGetResponse, error)

Get - Gets information about the specified network slice. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • sliceName - The name of the network slice.
  • options - SlicesClientGetOptions contains the optional parameters for the SlicesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SliceGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSlicesClient().Get(ctx, "rg1", "testMobileNetwork", "testSlice", 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.Slice = armmobilenetwork.Slice{
// 	Name: to.Ptr("testSlice"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks/slices"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 	},
// 	Properties: &armmobilenetwork.SlicePropertiesFormat{
// 		Description: to.Ptr("myFavouriteSlice"),
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		Snssai: &armmobilenetwork.Snssai{
// 			Sd: to.Ptr("1abcde"),
// 			Sst: to.Ptr[int32](1),
// 		},
// 	},
// }

Output:

func (*SlicesClient) NewListByMobileNetworkPager 

func (client *SlicesClient) NewListByMobileNetworkPager(resourceGroupName string, mobileNetworkName string, options *SlicesClientListByMobileNetworkOptions) *runtime.Pager[SlicesClientListByMobileNetworkResponse]

NewListByMobileNetworkPager - Lists all slices in the mobile network.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • options - SlicesClientListByMobileNetworkOptions contains the optional parameters for the SlicesClient.NewListByMobileNetworkPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SliceListByMobileNetwork.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSlicesClient().NewListByMobileNetworkPager("rg1", "testMobileNetwork", 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.SliceListResult = armmobilenetwork.SliceListResult{
	// 	Value: []*armmobilenetwork.Slice{
	// 		{
	// 			Name: to.Ptr("testSlice"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks/slices"),
	// 			ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
	// 			SystemData: &armmobilenetwork.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
	// 				LastModifiedBy: to.Ptr("user2"),
	// 				LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("eastus"),
	// 			Tags: map[string]*string{
	// 			},
	// 			Properties: &armmobilenetwork.SlicePropertiesFormat{
	// 				Description: to.Ptr("myFavouriteSlice"),
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 				Snssai: &armmobilenetwork.Snssai{
	// 					Sd: to.Ptr("1abcde"),
	// 					Sst: to.Ptr[int32](1),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

func (*SlicesClient) UpdateTags 

func (client *SlicesClient) UpdateTags(ctx context.Context, resourceGroupName string, mobileNetworkName string, sliceName string, parameters TagsObject, options *SlicesClientUpdateTagsOptions) (SlicesClientUpdateTagsResponse, error)

UpdateTags - Updates slice tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • mobileNetworkName - The name of the mobile network.
  • sliceName - The name of the network slice.
  • parameters - Parameters supplied to update network slice tags.
  • options - SlicesClientUpdateTagsOptions contains the optional parameters for the SlicesClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/340d577969b7bff5ad0488d79543314bc17daa50/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2022-11-01/examples/SliceUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armmobilenetwork.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSlicesClient().UpdateTags(ctx, "rg1", "testMobileNetwork", "testSlice", armmobilenetwork.TagsObject{
	Tags: map[string]*string{
		"tag1": to.Ptr("value1"),
		"tag2": to.Ptr("value2"),
	},
}, 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.Slice = armmobilenetwork.Slice{
// 	Name: to.Ptr("testSlice"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/mobileNetworks/slices"),
// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/slices/testSlice"),
// 	SystemData: &armmobilenetwork.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.1234567Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.1234567Z"); return t}()),
// 		LastModifiedBy: to.Ptr("user2"),
// 		LastModifiedByType: to.Ptr(armmobilenetwork.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("eastus"),
// 	Tags: map[string]*string{
// 		"tag1": to.Ptr("value1"),
// 		"tag2": to.Ptr("value2"),
// 	},
// 	Properties: &armmobilenetwork.SlicePropertiesFormat{
// 		Description: to.Ptr("myFavouriteSlice"),
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		Snssai: &armmobilenetwork.Snssai{
// 			Sd: to.Ptr("1abcde"),
// 			Sst: to.Ptr[int32](1),
// 		},
// 	},
// }

Output:

type SlicesClientBeginCreateOrUpdateOptions 

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

SlicesClientBeginCreateOrUpdateOptions contains the optional parameters for the SlicesClient.BeginCreateOrUpdate method.

type SlicesClientBeginDeleteOptions 

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

SlicesClientBeginDeleteOptions contains the optional parameters for the SlicesClient.BeginDelete method.

type SlicesClientCreateOrUpdateResponse 

type SlicesClientCreateOrUpdateResponse struct {
	Slice
}

SlicesClientCreateOrUpdateResponse contains the response from method SlicesClient.BeginCreateOrUpdate.

type SlicesClientDeleteResponse 

type SlicesClientDeleteResponse struct {
}

SlicesClientDeleteResponse contains the response from method SlicesClient.BeginDelete.

type SlicesClientGetOptions 

type SlicesClientGetOptions struct {
}

SlicesClientGetOptions contains the optional parameters for the SlicesClient.Get method.

type SlicesClientGetResponse 

type SlicesClientGetResponse struct {
	Slice
}

SlicesClientGetResponse contains the response from method SlicesClient.Get.

type SlicesClientListByMobileNetworkOptions 

type SlicesClientListByMobileNetworkOptions struct {
}

SlicesClientListByMobileNetworkOptions contains the optional parameters for the SlicesClient.NewListByMobileNetworkPager method.

type SlicesClientListByMobileNetworkResponse 

type SlicesClientListByMobileNetworkResponse struct {
	SliceListResult
}

SlicesClientListByMobileNetworkResponse contains the response from method SlicesClient.NewListByMobileNetworkPager.

type SlicesClientUpdateTagsOptions 

type SlicesClientUpdateTagsOptions struct {
}

SlicesClientUpdateTagsOptions contains the optional parameters for the SlicesClient.UpdateTags method.

type SlicesClientUpdateTagsResponse 

type SlicesClientUpdateTagsResponse struct {
	Slice
}

SlicesClientUpdateTagsResponse contains the response from method SlicesClient.UpdateTags.

type Snssai 

type Snssai struct {
	// REQUIRED; Slice/service type (SST).
	Sst *int32

	// Slice differentiator (SD).
	Sd *string
}

Snssai - Single-network slice selection assistance information (S-NSSAI).

func (Snssai) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Snssai.

func (*Snssai) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Snssai.

type SubResource 

type SubResource struct {
	// REQUIRED; Resource ID.
	ID *string
}

SubResource - Reference to another sub resource.

func (SubResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SubResource.

func (*SubResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SubResource.

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.

type TagsObject 

type TagsObject struct {
	// Resource tags.
	Tags map[string]*string
}

TagsObject - Tags object for patch operations.

func (TagsObject) MarshalJSON 

func (t TagsObject) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TagsObject.

func (*TagsObject) UnmarshalJSON 

func (t *TagsObject) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TagsObject.

type TrackedResource 

type TrackedResource struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

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

TrackedResource - The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location'

func (TrackedResource) MarshalJSON 

func (t TrackedResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TrackedResource.

func (*TrackedResource) UnmarshalJSON 

func (t *TrackedResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TrackedResource.

type TrafficControlPermission 

type TrafficControlPermission string

TrafficControlPermission - Traffic control permission. 

const (
	// TrafficControlPermissionBlocked - Traffic matching this rule is not allowed to flow.
	TrafficControlPermissionBlocked TrafficControlPermission = "Blocked"
	// TrafficControlPermissionEnabled - Traffic matching this rule is allowed to flow.
	TrafficControlPermissionEnabled TrafficControlPermission = "Enabled"
)

func PossibleTrafficControlPermissionValues 

func PossibleTrafficControlPermissionValues() []TrafficControlPermission

PossibleTrafficControlPermissionValues returns the possible values for the TrafficControlPermission const type.

type UserAssignedIdentity 

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
}

UserAssignedIdentity - User assigned identity properties

func (UserAssignedIdentity) MarshalJSON 

func (u UserAssignedIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity.

func (*UserAssignedIdentity) UnmarshalJSON 

func (u *UserAssignedIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity.

type VersionState 

type VersionState string

VersionState - The state of this packet core control plane version. 

const (
	// VersionStateActive - This version is active and suitable for production use.
	VersionStateActive VersionState = "Active"
	// VersionStateDeprecated - This version is deprecated and is no longer supported.
	VersionStateDeprecated VersionState = "Deprecated"
	// VersionStatePreview - This version is a preview and is not suitable for production use.
	VersionStatePreview VersionState = "Preview"
	// VersionStateUnknown - The state of this version is unknown.
	VersionStateUnknown VersionState = "Unknown"
	// VersionStateValidating - This version is currently being validated.
	VersionStateValidating VersionState = "Validating"
	// VersionStateValidationFailed - This version failed validation.
	VersionStateValidationFailed VersionState = "ValidationFailed"
)

func PossibleVersionStateValues 

func PossibleVersionStateValues() []VersionState

PossibleVersionStateValues returns the possible values for the VersionState const type.

Source Files

View all Source files

Jump to

Keyboard shortcuts

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