armmobilenetwork

package module
v4.0.0 Latest Latest
Warning

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

 Go to latest Published: Mar 21, 2024 License: MIT Imports: 14 Imported by: 0

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

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.NewAttachedDataNetworksClient()

Fakes

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

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

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the 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 AmfID 

type AmfID struct {
	// REQUIRED; AMF pointer
	Pointer *int32

	// REQUIRED; AMF region identifier
	RegionID *int32

	// REQUIRED; AMF set identifier
	SetID *int32
}

AmfID - AMF identifier

func (AmfID) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AmfID.

func (*AmfID) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AmfID.

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. E.g. "/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. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 {
	// Attached data network resource. Must be created in the same location as its parent packet core data plane.
	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 {
	// Attached data network resource. Must be created in the same location as its parent packet core data plane.
	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 {
	// Response for attached data network API service call.
	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 {
	// Attached data network resource. Must be created in the same location as its parent packet core data plane.
	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, 2 RANs
	BillingSKUG0 BillingSKU = "G0"
	// BillingSKUG1 - 1 Gbps, 100 active SIMs plan, 5 RANs
	BillingSKUG1 BillingSKU = "G1"
	// BillingSKUG10 - 10 Gbps, 1000 active SIMs plan
	BillingSKUG10 BillingSKU = "G10"
	// BillingSKUG2 - 2 Gbps, 200 active SIMs plan, 10 RANs
	BillingSKUG2 BillingSKU = "G2"
	// 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 

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

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

func NewClientFactory 

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

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

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

func (*ClientFactory) NewAttachedDataNetworksClient 

func (c *ClientFactory) NewAttachedDataNetworksClient() *AttachedDataNetworksClient

NewAttachedDataNetworksClient creates a new instance of AttachedDataNetworksClient.

func (*ClientFactory) NewDataNetworksClient 

func (c *ClientFactory) NewDataNetworksClient() *DataNetworksClient

NewDataNetworksClient creates a new instance of DataNetworksClient.

func (*ClientFactory) NewDiagnosticsPackagesClient 

func (c *ClientFactory) NewDiagnosticsPackagesClient() *DiagnosticsPackagesClient

NewDiagnosticsPackagesClient creates a new instance of DiagnosticsPackagesClient.

func (*ClientFactory) NewExtendedUeInformationClient 

func (c *ClientFactory) NewExtendedUeInformationClient() *ExtendedUeInformationClient

NewExtendedUeInformationClient creates a new instance of ExtendedUeInformationClient.

func (*ClientFactory) NewMobileNetworksClient 

func (c *ClientFactory) NewMobileNetworksClient() *MobileNetworksClient

NewMobileNetworksClient creates a new instance of MobileNetworksClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewPacketCapturesClient 

func (c *ClientFactory) NewPacketCapturesClient() *PacketCapturesClient

NewPacketCapturesClient creates a new instance of PacketCapturesClient.

func (*ClientFactory) NewPacketCoreControlPlaneVersionsClient 

func (c *ClientFactory) NewPacketCoreControlPlaneVersionsClient() *PacketCoreControlPlaneVersionsClient

NewPacketCoreControlPlaneVersionsClient creates a new instance of PacketCoreControlPlaneVersionsClient.

func (*ClientFactory) NewPacketCoreControlPlanesClient 

func (c *ClientFactory) NewPacketCoreControlPlanesClient() *PacketCoreControlPlanesClient

NewPacketCoreControlPlanesClient creates a new instance of PacketCoreControlPlanesClient.

func (*ClientFactory) NewPacketCoreDataPlanesClient 

func (c *ClientFactory) NewPacketCoreDataPlanesClient() *PacketCoreDataPlanesClient

NewPacketCoreDataPlanesClient creates a new instance of PacketCoreDataPlanesClient.

func (*ClientFactory) NewServicesClient 

func (c *ClientFactory) NewServicesClient() *ServicesClient

NewServicesClient creates a new instance of ServicesClient.

func (*ClientFactory) NewSimGroupsClient 

func (c *ClientFactory) NewSimGroupsClient() *SimGroupsClient

NewSimGroupsClient creates a new instance of SimGroupsClient.

func (*ClientFactory) NewSimPoliciesClient 

func (c *ClientFactory) NewSimPoliciesClient() *SimPoliciesClient

NewSimPoliciesClient creates a new instance of SimPoliciesClient.

func (*ClientFactory) NewSimsClient 

func (c *ClientFactory) NewSimsClient() *SimsClient

NewSimsClient creates a new instance of SimsClient.

func (*ClientFactory) NewSitesClient 

func (c *ClientFactory) NewSitesClient() *SitesClient

NewSitesClient creates a new instance of SitesClient.

func (*ClientFactory) NewSlicesClient 

func (c *ClientFactory) NewSlicesClient() *SlicesClient

NewSlicesClient creates a new instance of SlicesClient.

func (*ClientFactory) NewUeInformationClient 

func (c *ClientFactory) NewUeInformationClient() *UeInformationClient

NewUeInformationClient creates a new instance of UeInformationClient.

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, EPC / 4G core or EPC / 4G + 5G core). 

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

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. E.g. "/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 5G QoS Flow Indicator value. The 5QI identifies a specific QoS forwarding treatment to be provided to a flow. 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 the 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. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 {
	// Data network resource. Must be created in the same location as its parent mobile network.
	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 {
	// Data network resource. Must be created in the same location as its parent mobile network.
	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 {
	// Response for data network API service call.
	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 {
	// Data network resource. Must be created in the same location as its parent mobile network.
	DataNetwork
}

DataNetworksClientUpdateTagsResponse contains the response from method DataNetworksClient.UpdateTags.

type DesiredInstallationState 

type DesiredInstallationState string

DesiredInstallationState - The desired installation state of the packet core. 

const (
	// DesiredInstallationStateInstalled - Install the packet core.
	DesiredInstallationStateInstalled DesiredInstallationState = "Installed"
	// DesiredInstallationStateUninstalled - Don't install the packet core.
	DesiredInstallationStateUninstalled DesiredInstallationState = "Uninstalled"
)

func PossibleDesiredInstallationStateValues 

func PossibleDesiredInstallationStateValues() []DesiredInstallationState

PossibleDesiredInstallationStateValues returns the possible values for the DesiredInstallationState const type.

type DiagnosticsPackage 

type DiagnosticsPackage struct {
	// REQUIRED; Diagnostics package properties. A diagnostics package file derived from the name of this resource will be uploaded
	// to the Storage Account Container URL in the packet core control plane properties
	Properties *DiagnosticsPackagePropertiesFormat

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/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
}

DiagnosticsPackage - Diagnostics package resource.

func (DiagnosticsPackage) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DiagnosticsPackage.

func (*DiagnosticsPackage) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DiagnosticsPackage.

type DiagnosticsPackageListResult 

type DiagnosticsPackageListResult struct {
	// A list of diagnostics packages under a packet core control plane.
	Value []*DiagnosticsPackage

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

DiagnosticsPackageListResult - Response for diagnostics package API service call.

func (DiagnosticsPackageListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DiagnosticsPackageListResult.

func (*DiagnosticsPackageListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DiagnosticsPackageListResult.

type DiagnosticsPackagePropertiesFormat 

type DiagnosticsPackagePropertiesFormat struct {
	// READ-ONLY; The provisioning state of the diagnostics package resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The reason for the current state of the diagnostics package collection.
	Reason *string

	// READ-ONLY; The status of the diagnostics package collection.
	Status *DiagnosticsPackageStatus
}

DiagnosticsPackagePropertiesFormat - Diagnostics package properties.

func (DiagnosticsPackagePropertiesFormat) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DiagnosticsPackagePropertiesFormat.

func (*DiagnosticsPackagePropertiesFormat) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DiagnosticsPackagePropertiesFormat.

type DiagnosticsPackageStatus 

type DiagnosticsPackageStatus string

DiagnosticsPackageStatus - The status of the diagnostics package collection. 

const (
	DiagnosticsPackageStatusCollected  DiagnosticsPackageStatus = "Collected"
	DiagnosticsPackageStatusCollecting DiagnosticsPackageStatus = "Collecting"
	DiagnosticsPackageStatusError      DiagnosticsPackageStatus = "Error"
	DiagnosticsPackageStatusNotStarted DiagnosticsPackageStatus = "NotStarted"
)

func PossibleDiagnosticsPackageStatusValues 

func PossibleDiagnosticsPackageStatusValues() []DiagnosticsPackageStatus

PossibleDiagnosticsPackageStatusValues returns the possible values for the DiagnosticsPackageStatus const type.

type DiagnosticsPackagesClient 

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

DiagnosticsPackagesClient contains the methods for the DiagnosticsPackages group. Don't use this type directly, use NewDiagnosticsPackagesClient() instead.

func NewDiagnosticsPackagesClient 

func NewDiagnosticsPackagesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*DiagnosticsPackagesClient, error)

NewDiagnosticsPackagesClient creates a new instance of DiagnosticsPackagesClient with the specified values.

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

func (*DiagnosticsPackagesClient) BeginCreateOrUpdate 

func (client *DiagnosticsPackagesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, diagnosticsPackageName string, options *DiagnosticsPackagesClientBeginCreateOrUpdateOptions) (*runtime.Poller[DiagnosticsPackagesClientCreateOrUpdateResponse], error)

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

Generated from API version 2024-02-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • diagnosticsPackageName - The name of the diagnostics package.
  • options - DiagnosticsPackagesClientBeginCreateOrUpdateOptions contains the optional parameters for the DiagnosticsPackagesClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/DiagnosticsPackageCreate.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.NewDiagnosticsPackagesClient().BeginCreateOrUpdate(ctx, "rg1", "TestPacketCoreCP", "dp1", 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.DiagnosticsPackage = armmobilenetwork.DiagnosticsPackage{
// 	Name: to.Ptr("dp1"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/diagnosticsPackages/dp1"),
// 	Properties: &armmobilenetwork.DiagnosticsPackagePropertiesFormat{
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		Status: to.Ptr(armmobilenetwork.DiagnosticsPackageStatusCollected),
// 	},
// }

Output:

func (*DiagnosticsPackagesClient) BeginDelete 

func (client *DiagnosticsPackagesClient) BeginDelete(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, diagnosticsPackageName string, options *DiagnosticsPackagesClientBeginDeleteOptions) (*runtime.Poller[DiagnosticsPackagesClientDeleteResponse], error)

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

Generated from API version 2024-02-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • diagnosticsPackageName - The name of the diagnostics package.
  • options - DiagnosticsPackagesClientBeginDeleteOptions contains the optional parameters for the DiagnosticsPackagesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/DiagnosticsPackageDelete.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.NewDiagnosticsPackagesClient().BeginDelete(ctx, "rg1", "TestPacketCoreCP", "dp1", 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 (*DiagnosticsPackagesClient) Get 

func (client *DiagnosticsPackagesClient) Get(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, diagnosticsPackageName string, options *DiagnosticsPackagesClientGetOptions) (DiagnosticsPackagesClientGetResponse, error)

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

Generated from API version 2024-02-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • diagnosticsPackageName - The name of the diagnostics package.
  • options - DiagnosticsPackagesClientGetOptions contains the optional parameters for the DiagnosticsPackagesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/DiagnosticsPackageGet.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.NewDiagnosticsPackagesClient().Get(ctx, "rg1", "TestPacketCoreCP", "dp1", 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.DiagnosticsPackage = armmobilenetwork.DiagnosticsPackage{
// 	Name: to.Ptr("dp1"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/diagnosticsPackages/dp1"),
// 	Properties: &armmobilenetwork.DiagnosticsPackagePropertiesFormat{
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		Status: to.Ptr(armmobilenetwork.DiagnosticsPackageStatus("Stopped")),
// 	},
// }

Output:

func (*DiagnosticsPackagesClient) NewListByPacketCoreControlPlanePager 

func (client *DiagnosticsPackagesClient) NewListByPacketCoreControlPlanePager(resourceGroupName string, packetCoreControlPlaneName string, options *DiagnosticsPackagesClientListByPacketCoreControlPlaneOptions) *runtime.Pager[DiagnosticsPackagesClientListByPacketCoreControlPlaneResponse]

NewListByPacketCoreControlPlanePager - Lists all the diagnostics packages under a packet core control plane.

Generated from API version 2024-02-01

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/DiagnosticsPackageListByPacketCoreControlPlane.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.NewDiagnosticsPackagesClient().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.DiagnosticsPackageListResult = armmobilenetwork.DiagnosticsPackageListResult{
	// 	Value: []*armmobilenetwork.DiagnosticsPackage{
	// 		{
	// 			Name: to.Ptr("dp1"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/diagnosticsPackages/pc1"),
	// 			Properties: &armmobilenetwork.DiagnosticsPackagePropertiesFormat{
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 				Status: to.Ptr(armmobilenetwork.DiagnosticsPackageStatus("Stopped")),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("dp2"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/diagnosticsPackages/dp2"),
	// 			Properties: &armmobilenetwork.DiagnosticsPackagePropertiesFormat{
	// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 				Status: to.Ptr(armmobilenetwork.DiagnosticsPackageStatus("Stopped")),
	// 			},
	// 	}},
	// }
}

Output:

type DiagnosticsPackagesClientBeginCreateOrUpdateOptions 

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

DiagnosticsPackagesClientBeginCreateOrUpdateOptions contains the optional parameters for the DiagnosticsPackagesClient.BeginCreateOrUpdate method.

type DiagnosticsPackagesClientBeginDeleteOptions 

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

DiagnosticsPackagesClientBeginDeleteOptions contains the optional parameters for the DiagnosticsPackagesClient.BeginDelete method.

type DiagnosticsPackagesClientCreateOrUpdateResponse 

type DiagnosticsPackagesClientCreateOrUpdateResponse struct {
	// Diagnostics package resource.
	DiagnosticsPackage
}

DiagnosticsPackagesClientCreateOrUpdateResponse contains the response from method DiagnosticsPackagesClient.BeginCreateOrUpdate.

type DiagnosticsPackagesClientDeleteResponse 

type DiagnosticsPackagesClientDeleteResponse struct {
}

DiagnosticsPackagesClientDeleteResponse contains the response from method DiagnosticsPackagesClient.BeginDelete.

type DiagnosticsPackagesClientGetOptions 

type DiagnosticsPackagesClientGetOptions struct {
}

DiagnosticsPackagesClientGetOptions contains the optional parameters for the DiagnosticsPackagesClient.Get method.

type DiagnosticsPackagesClientGetResponse 

type DiagnosticsPackagesClientGetResponse struct {
	// Diagnostics package resource.
	DiagnosticsPackage
}

DiagnosticsPackagesClientGetResponse contains the response from method DiagnosticsPackagesClient.Get.

type DiagnosticsPackagesClientListByPacketCoreControlPlaneOptions 

type DiagnosticsPackagesClientListByPacketCoreControlPlaneOptions struct {
}

DiagnosticsPackagesClientListByPacketCoreControlPlaneOptions contains the optional parameters for the DiagnosticsPackagesClient.NewListByPacketCoreControlPlanePager method.

type DiagnosticsPackagesClientListByPacketCoreControlPlaneResponse 

type DiagnosticsPackagesClientListByPacketCoreControlPlaneResponse struct {
	// Response for diagnostics package API service call.
	DiagnosticsPackageListResult
}

DiagnosticsPackagesClientListByPacketCoreControlPlaneResponse contains the response from method DiagnosticsPackagesClient.NewListByPacketCoreControlPlanePager.

type DiagnosticsUploadConfiguration 

type DiagnosticsUploadConfiguration struct {
	// REQUIRED; The Storage Account Container URL to upload diagnostics to.
	StorageAccountContainerURL *string
}

DiagnosticsUploadConfiguration - Configuration for uploading packet core diagnostics.

func (DiagnosticsUploadConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DiagnosticsUploadConfiguration.

func (*DiagnosticsUploadConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DiagnosticsUploadConfiguration.

type DnnIPPair 

type DnnIPPair struct {
	// Data network name
	Dnn *string

	// UE IP address
	UeIPAddress *UeIPAddress
}

DnnIPPair - DNN and UE IP address

func (DnnIPPair) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DnnIPPair.

func (*DnnIPPair) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DnnIPPair.

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 EventHubConfiguration 

type EventHubConfiguration struct {
	// REQUIRED; Resource ID of Azure Event Hub to send packet core events to.
	ID *string

	// The duration (in seconds) between UE usage reports.
	ReportingInterval *int32
}

EventHubConfiguration - Configuration for sending packet core events to Azure Event Hub.

func (EventHubConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type EventHubConfiguration.

func (*EventHubConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type EventHubConfiguration.

type ExtendedUeInfo 

type ExtendedUeInfo struct {
	// REQUIRED; Extended UE Information Properties.
	Properties ExtendedUeInfoPropertiesClassification

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/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
}

ExtendedUeInfo - Extended User Equipment (UE) information.

func (ExtendedUeInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtendedUeInfo.

func (*ExtendedUeInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtendedUeInfo.

type ExtendedUeInfoProperties 

type ExtendedUeInfoProperties struct {
	// REQUIRED; RAT Type
	RatType *RatType

	// The timestamp of last UE info read from the packet core (UTC).
	LastReadAt *time.Time
}

ExtendedUeInfoProperties - Extended UE Information Properties.

func (*ExtendedUeInfoProperties) GetExtendedUeInfoProperties 

func (e *ExtendedUeInfoProperties) GetExtendedUeInfoProperties() *ExtendedUeInfoProperties

GetExtendedUeInfoProperties implements the ExtendedUeInfoPropertiesClassification interface for type ExtendedUeInfoProperties.

func (ExtendedUeInfoProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtendedUeInfoProperties.

func (*ExtendedUeInfoProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtendedUeInfoProperties.

type ExtendedUeInfoPropertiesClassification 

type ExtendedUeInfoPropertiesClassification interface {
	// GetExtendedUeInfoProperties returns the ExtendedUeInfoProperties content of the underlying type.
	GetExtendedUeInfoProperties() *ExtendedUeInfoProperties
}

ExtendedUeInfoPropertiesClassification provides polymorphic access to related types. Call the interface's GetExtendedUeInfoProperties() method to access the common type. Use a type switch to determine the concrete type. The possible types are: - *ExtendedUeInfoProperties, *UeInfo4G, *UeInfo5G

type ExtendedUeInformationClient 

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

ExtendedUeInformationClient contains the methods for the ExtendedUeInformation group. Don't use this type directly, use NewExtendedUeInformationClient() instead.

func NewExtendedUeInformationClient 

func NewExtendedUeInformationClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ExtendedUeInformationClient, error)

NewExtendedUeInformationClient creates a new instance of ExtendedUeInformationClient with the specified values.

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

func (*ExtendedUeInformationClient) Get 

func (client *ExtendedUeInformationClient) Get(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, ueID string, options *ExtendedUeInformationClientGetOptions) (ExtendedUeInformationClientGetResponse, error)

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

Generated from API version 2024-02-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • ueID - IMSI of a UE.
  • options - ExtendedUeInformationClientGetOptions contains the optional parameters for the ExtendedUeInformationClient.Get method.
Example (GetUeInformation4G)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/ExtendedUeInfo4GGet.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.NewExtendedUeInformationClient().Get(ctx, "rg1", "TestPacketCoreCP", "84449105622", 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.ExtendedUeInfo = armmobilenetwork.ExtendedUeInfo{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlanes/ues/extendedInformation"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/ues/84449105622/extendedInformation/default"),
// 	Properties: &armmobilenetwork.UeInfo4G{
// 		LastReadAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
// 		RatType: to.Ptr(armmobilenetwork.RatTypeFourG),
// 		Info: &armmobilenetwork.UeInfo4GProperties{
// 			ConnectionInfo: &armmobilenetwork.UeConnectionInfo4G{
// 				EnbS1ApID: to.Ptr[int32](12345678),
// 				GlobalRanNodeID: &armmobilenetwork.GlobalRanNodeID{
// 					ENbID: to.Ptr("MacroeNB-ABCDE"),
// 					PlmnID: &armmobilenetwork.PlmnID{
// 						Mcc: to.Ptr("001"),
// 						Mnc: to.Ptr("01"),
// 					},
// 				},
// 				LastActivityTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
// 				LastVisitedTai: to.Ptr("00101 000001"),
// 				LocationInfo: &armmobilenetwork.UeLocationInfo{
// 					LocationType: to.Ptr("EUTRA"),
// 					Plmn: &armmobilenetwork.PlmnID{
// 						Mcc: to.Ptr("001"),
// 						Mnc: to.Ptr("01"),
// 					},
// 					Tac: to.Ptr("000001"),
// 				},
// 				MmeS1ApID: to.Ptr[int32](12345678),
// 				PerUeTnla: to.Ptr("00101.0.macroEnbId-10.232.228.84:36412"),
// 				RrcEstablishmentCause: to.Ptr(armmobilenetwork.RrcEstablishmentCauseEmergency),
// 				UeState: to.Ptr(armmobilenetwork.UeStateConnected),
// 				UeUsageSetting: to.Ptr(armmobilenetwork.UeUsageSettingDataCentric),
// 			},
// 			Guti: &armmobilenetwork.Guti4G{
// 				MTmsi: to.Ptr[int32](907),
// 				MmeID: &armmobilenetwork.MmeID{
// 					Code: to.Ptr[int32](1),
// 					GroupID: to.Ptr[int32](1),
// 				},
// 				Plmn: &armmobilenetwork.PlmnID{
// 					Mcc: to.Ptr("001"),
// 					Mnc: to.Ptr("01"),
// 				},
// 			},
// 			Imei: to.Ptr("123456789012345"),
// 			Imeisv: to.Ptr("2993972087439794"),
// 			Imsi: to.Ptr("84449105622"),
// 			SessionInfo: []*armmobilenetwork.UeSessionInfo4G{
// 				{
// 					Apn: to.Ptr("internet"),
// 					Ebi: to.Ptr[int32](15),
// 					PdnType: to.Ptr(armmobilenetwork.PdnTypeIPV4),
// 					UeIPAddress: &armmobilenetwork.UeIPAddress{
// 						IPV4Addr: to.Ptr("10.10.0.1"),
// 					},
// 			}},
// 		},
// 	},
// }

Output:
Example (GetUeInformation5G)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/ExtendedUeInfo5GGet.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.NewExtendedUeInformationClient().Get(ctx, "rg1", "TestPacketCoreCP", "84449105622", 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.ExtendedUeInfo = armmobilenetwork.ExtendedUeInfo{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlanes/ues/extendedInformation"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/ues/84449105622/extendedInformation/default"),
// 	Properties: &armmobilenetwork.UeInfo5G{
// 		LastReadAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
// 		RatType: to.Ptr(armmobilenetwork.RatTypeFiveG),
// 		Info: &armmobilenetwork.UeInfo5GProperties{
// 			ConnectionInfo: &armmobilenetwork.UeConnectionInfo5G{
// 				AllowedNssai: []*armmobilenetwork.Snssai{
// 					{
// 						Sst: to.Ptr[int32](1),
// 					},
// 					{
// 						Sd: to.Ptr("abcdef"),
// 						Sst: to.Ptr[int32](2),
// 				}},
// 				AmfUeNgapID: to.Ptr[int64](549755813888),
// 				GlobalRanNodeID: &armmobilenetwork.GlobalRanNodeID{
// 					GNbID: &armmobilenetwork.GNbID{
// 						BitLength: to.Ptr[int32](32),
// 						GNBValue: to.Ptr("01234567"),
// 					},
// 					PlmnID: &armmobilenetwork.PlmnID{
// 						Mcc: to.Ptr("001"),
// 						Mnc: to.Ptr("01"),
// 					},
// 				},
// 				LastActivityTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
// 				LastVisitedTai: to.Ptr("00101 000001"),
// 				LocationInfo: &armmobilenetwork.UeLocationInfo{
// 					LocationType: to.Ptr("EUTRA"),
// 					Plmn: &armmobilenetwork.PlmnID{
// 						Mcc: to.Ptr("001"),
// 						Mnc: to.Ptr("01"),
// 					},
// 					Tac: to.Ptr("000001"),
// 				},
// 				PerUeTnla: to.Ptr("00101.0.macroEnbId-10.232.228.84:36412"),
// 				RanUeNgapID: to.Ptr[int32](12345678),
// 				RrcEstablishmentCause: to.Ptr(armmobilenetwork.RrcEstablishmentCauseEmergency),
// 				UeState: to.Ptr(armmobilenetwork.UeStateConnected),
// 				UeUsageSetting: to.Ptr(armmobilenetwork.UeUsageSettingDataCentric),
// 			},
// 			FivegGuti: &armmobilenetwork.Guti5G{
// 				AmfID: &armmobilenetwork.AmfID{
// 					Pointer: to.Ptr[int32](1),
// 					RegionID: to.Ptr[int32](1),
// 					SetID: to.Ptr[int32](1),
// 				},
// 				FivegTmsi: to.Ptr[int32](907),
// 				Plmn: &armmobilenetwork.PlmnID{
// 					Mcc: to.Ptr("001"),
// 					Mnc: to.Ptr("01"),
// 				},
// 			},
// 			Pei: to.Ptr("imei-123456789012345"),
// 			SessionInfo: []*armmobilenetwork.UeSessionInfo5G{
// 				{
// 					Ambr: &armmobilenetwork.Ambr{
// 						Downlink: to.Ptr("2 Gbps"),
// 						Uplink: to.Ptr("2 Gbps"),
// 					},
// 					Dnn: to.Ptr("internet"),
// 					PdnType: to.Ptr(armmobilenetwork.PdnTypeIPV4),
// 					PduSessionID: to.Ptr[int32](15),
// 					QosFlow: []*armmobilenetwork.UeQOSFlow{
// 						{
// 							Fiveqi: to.Ptr[int32](9),
// 							Qfi: to.Ptr[int32](9),
// 						},
// 						{
// 							Fiveqi: to.Ptr[int32](1),
// 							Gbr: &armmobilenetwork.Ambr{
// 								Downlink: to.Ptr("10.0 Mbps"),
// 								Uplink: to.Ptr("100.0 Mbps"),
// 							},
// 							Mbr: &armmobilenetwork.Ambr{
// 								Downlink: to.Ptr("10.0 Kbps"),
// 								Uplink: to.Ptr("100.0 Kbps"),
// 							},
// 							Qfi: to.Ptr[int32](1),
// 					}},
// 					Snssai: &armmobilenetwork.Snssai{
// 						Sd: to.Ptr("abcdef"),
// 						Sst: to.Ptr[int32](1),
// 					},
// 					UeIPAddress: &armmobilenetwork.UeIPAddress{
// 						IPV4Addr: to.Ptr("10.10.0.1"),
// 					},
// 			}},
// 			Supi: to.Ptr("imsi-84449105622"),
// 		},
// 	},
// }

Output:

type ExtendedUeInformationClientGetOptions 

type ExtendedUeInformationClientGetOptions struct {
}

ExtendedUeInformationClientGetOptions contains the optional parameters for the ExtendedUeInformationClient.Get method.

type ExtendedUeInformationClientGetResponse 

type ExtendedUeInformationClientGetResponse struct {
	// Extended User Equipment (UE) information.
	ExtendedUeInfo
}

ExtendedUeInformationClientGetResponse contains the response from method ExtendedUeInformationClient.Get.

type GNbID 

type GNbID struct {
	BitLength *int32
	GNBValue  *string
}

GNbID - gNodeB identifier

func (GNbID) MarshalJSON 

func (g GNbID) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GNbID.

func (*GNbID) UnmarshalJSON 

func (g *GNbID) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GNbID.

type GlobalRanNodeID 

type GlobalRanNodeID struct {
	// REQUIRED; PLMN Identifier
	PlmnID *PlmnID

	// eNodeB identifier
	ENbID *string

	// gNodeB identifier
	GNbID *GNbID

	// N3 IWF identifier
	N3IwfID *string

	// NG-eNodeB identifier
	NgeNbID *string

	// Network identifier
	Nid *string

	// TNGF identifier
	TngfID *string

	// W-AGF identifier
	WagfID *string
}

GlobalRanNodeID - Global RAN Node ID

func (GlobalRanNodeID) MarshalJSON 

func (g GlobalRanNodeID) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GlobalRanNodeID.

func (*GlobalRanNodeID) UnmarshalJSON 

func (g *GlobalRanNodeID) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type GlobalRanNodeID.

type Guti4G 

type Guti4G struct {
	// REQUIRED; MME Temporary Mobile Subscriber Identity
	MTmsi *int32

	// REQUIRED; MME identifier
	MmeID *MmeID

	// REQUIRED; Public land mobile network (PLMN) ID. 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.
	Plmn *PlmnID
}

Guti4G - Globally Unique Temporary Identifier (4G)

func (Guti4G) MarshalJSON 

func (g Guti4G) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Guti4G.

func (*Guti4G) UnmarshalJSON 

func (g *Guti4G) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Guti4G.

type Guti5G 

type Guti5G struct {
	// REQUIRED; AMF identifier
	AmfID *AmfID

	// REQUIRED; 5G Temporary Mobile Subscriber Identity
	FivegTmsi *int32

	// REQUIRED; Public land mobile network (PLMN) ID. 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.
	Plmn *PlmnID
}

Guti5G - 5G GUTI

func (Guti5G) MarshalJSON 

func (g Guti5G) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Guti5G.

func (*Guti5G) UnmarshalJSON 

func (g *Guti5G) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Guti5G.

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 HomeNetworkPrivateKeysProvisioning 

type HomeNetworkPrivateKeysProvisioning struct {
	// READ-ONLY; The provisioning state of the private keys for SUPI concealment.
	State *HomeNetworkPrivateKeysProvisioningState
}

func (HomeNetworkPrivateKeysProvisioning) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type HomeNetworkPrivateKeysProvisioning.

func (*HomeNetworkPrivateKeysProvisioning) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type HomeNetworkPrivateKeysProvisioning.

type HomeNetworkPrivateKeysProvisioningState 

type HomeNetworkPrivateKeysProvisioningState string

HomeNetworkPrivateKeysProvisioningState - The provisioning state of the private keys for SUPI concealment. 

const (
	// HomeNetworkPrivateKeysProvisioningStateFailed - Provisioning of the private keys for SUPI concealment has failed.
	HomeNetworkPrivateKeysProvisioningStateFailed HomeNetworkPrivateKeysProvisioningState = "Failed"
	// HomeNetworkPrivateKeysProvisioningStateNotProvisioned - Provisioning of the private keys for SUPI concealment has not been
	// attempted.
	HomeNetworkPrivateKeysProvisioningStateNotProvisioned HomeNetworkPrivateKeysProvisioningState = "NotProvisioned"
	// HomeNetworkPrivateKeysProvisioningStateProvisioned - The private keys for SUPI concealment are successfully provisioned.
	HomeNetworkPrivateKeysProvisioningStateProvisioned HomeNetworkPrivateKeysProvisioningState = "Provisioned"
)

func PossibleHomeNetworkPrivateKeysProvisioningStateValues 

func PossibleHomeNetworkPrivateKeysProvisioningStateValues() []HomeNetworkPrivateKeysProvisioningState

PossibleHomeNetworkPrivateKeysProvisioningStateValues returns the possible values for the HomeNetworkPrivateKeysProvisioningState const type.

type HomeNetworkPublicKey 

type HomeNetworkPublicKey struct {
	// REQUIRED; The Home Network Public Key Identifier determines which public key was used to generate the SUCI sent to the
	// AMF. See TS 23.003 Section 2.2B Section 5.
	ID *int32

	// The URL of Azure Key Vault secret containing the private key, versioned or unversioned. For example: https://contosovault.vault.azure.net/secrets/mySuciPrivateKey/562a4bb76b524a1493a6afe8e536ee78.
	URL *string
}

HomeNetworkPublicKey - A key used for SUPI concealment.

func (HomeNetworkPublicKey) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type HomeNetworkPublicKey.

func (*HomeNetworkPublicKey) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type HomeNetworkPublicKey.

type IdentityAndTagsObject 

type IdentityAndTagsObject struct {
	// The managed service identity associated with this resource.
	Identity *ManagedServiceIdentity

	// Resource tags.
	Tags map[string]*string
}

IdentityAndTagsObject - Identity and Tags object for patch operations.

func (IdentityAndTagsObject) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IdentityAndTagsObject.

func (*IdentityAndTagsObject) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IdentityAndTagsObject.

type Installation 

type Installation struct {
	// The desired installation state
	DesiredState *DesiredInstallationState

	// READ-ONLY; A reference to an in-progress installation operation
	Operation *AsyncOperationID

	// READ-ONLY; Reason(s) for the current installation state of the packet core.
	Reasons []*InstallationReason

	// READ-ONLY; Whether a reinstall of the packet core is required to pick up the latest configuration changes.
	ReinstallRequired *ReinstallRequired

	// READ-ONLY; 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 InstallationReason 

type InstallationReason string

InstallationReason - The reason or list of reasons why a packet core has not been installed or requires a reinstall. 

const (
	// InstallationReasonControlPlaneAccessInterfaceHasChanged - A reinstall is required as the packet core is running with out-of-date
	// control plane access interface information.
	InstallationReasonControlPlaneAccessInterfaceHasChanged InstallationReason = "ControlPlaneAccessInterfaceHasChanged"
	// InstallationReasonControlPlaneAccessVirtualIPv4AddressesHasChanged - A reinstall is required as the packet core is running
	// with out-of-date control plane access network virtual IP address.
	InstallationReasonControlPlaneAccessVirtualIPv4AddressesHasChanged InstallationReason = "ControlPlaneAccessVirtualIpv4AddressesHasChanged"
	// InstallationReasonNoAttachedDataNetworks - The packet core has not been installed as the packet core has no attached data
	// networks.
	InstallationReasonNoAttachedDataNetworks InstallationReason = "NoAttachedDataNetworks"
	// InstallationReasonNoPacketCoreDataPlane - The packet core has not been installed as there is no configured data plane for
	// this packet core.
	InstallationReasonNoPacketCoreDataPlane InstallationReason = "NoPacketCoreDataPlane"
	// InstallationReasonNoSlices - The packet core has not been installed as the mobile network does not have any applicable
	// configured slices.
	InstallationReasonNoSlices InstallationReason = "NoSlices"
	// InstallationReasonPublicLandMobileNetworkIdentifierHasChanged - A reinstall is required as the packet core is running with
	// out-of-date PLMN ID.
	InstallationReasonPublicLandMobileNetworkIdentifierHasChanged InstallationReason = "PublicLandMobileNetworkIdentifierHasChanged"
	// InstallationReasonUserPlaneAccessInterfaceHasChanged - A reinstall is required as the packet core is running with out-of-date
	// user plane core interface.
	InstallationReasonUserPlaneAccessInterfaceHasChanged InstallationReason = "UserPlaneAccessInterfaceHasChanged"
	// InstallationReasonUserPlaneAccessVirtualIPv4AddressesHasChanged - A reinstall is required as the packet core is running
	// with out-of-date user plane access network virtual IP address.
	InstallationReasonUserPlaneAccessVirtualIPv4AddressesHasChanged InstallationReason = "UserPlaneAccessVirtualIpv4AddressesHasChanged"
	// InstallationReasonUserPlaneDataInterfaceHasChanged - A reinstall is required as the packet core is running with out-of-date
	// user plane access interface.
	InstallationReasonUserPlaneDataInterfaceHasChanged InstallationReason = "UserPlaneDataInterfaceHasChanged"
)

func PossibleInstallationReasonValues 

func PossibleInstallationReasonValues() []InstallationReason

PossibleInstallationReasonValues returns the possible values for the InstallationReason const type.

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 (currently only UserAssigned 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
}

ManagedServiceIdentity - Managed service identity (User assigned identity)

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 (currently only UserAssigned allowed). 

const (
	ManagedServiceIdentityTypeNone         ManagedServiceIdentityType = "None"
	ManagedServiceIdentityTypeUserAssigned ManagedServiceIdentityType = "UserAssigned"
)

func PossibleManagedServiceIdentityTypeValues 

func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType

PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.

type MmeID 

type MmeID struct {
	// REQUIRED; MME code
	Code *int32

	// REQUIRED; MME group identifier
	GroupID *int32
}

MmeID - MME identifier

func (MmeID) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MmeID.

func (*MmeID) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MmeID.

type MobileNetwork 

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

	// REQUIRED; Mobile network properties.
	Properties *PropertiesFormat

	// The identity used to retrieve any private keys used for SUPI concealment from Azure key vault.
	Identity *ManagedServiceIdentity

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/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. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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"),
		},
		PublicLandMobileNetworks: []*armmobilenetwork.PublicLandMobileNetwork{
			{
				Mcc: to.Ptr("001"),
				Mnc: to.Ptr("01"),
				HomeNetworkPublicKeys: &armmobilenetwork.PublicLandMobileNetworkHomeNetworkPublicKeys{
					ProfileA: []*armmobilenetwork.HomeNetworkPublicKey{
						{
							ID:  to.Ptr[int32](1),
							URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpk"),
						},
						{
							ID:  to.Ptr[int32](2),
							URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpk2/5e4876e9140e4e16bfe6e2cf92e0cbd2"),
						}},
					ProfileB: []*armmobilenetwork.HomeNetworkPublicKey{
						{
							ID:  to.Ptr[int32](1),
							URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpkProfileB"),
						}},
				},
			}},
	},
}, 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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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"),
// 		},
// 		PublicLandMobileNetworks: []*armmobilenetwork.PublicLandMobileNetwork{
// 			{
// 				Mcc: to.Ptr("001"),
// 				Mnc: to.Ptr("01"),
// 				HomeNetworkPublicKeys: &armmobilenetwork.PublicLandMobileNetworkHomeNetworkPublicKeys{
// 					ProfileA: []*armmobilenetwork.HomeNetworkPublicKey{
// 						{
// 							ID: to.Ptr[int32](1),
// 							URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpk"),
// 						},
// 						{
// 							ID: to.Ptr[int32](2),
// 							URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpk2/5e4876e9140e4e16bfe6e2cf92e0cbd2"),
// 					}},
// 					ProfileB: []*armmobilenetwork.HomeNetworkPublicKey{
// 						{
// 							ID: to.Ptr[int32](1),
// 							URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpkProfileB"),
// 					}},
// 				},
// 		}},
// 	},
// }

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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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"),
// 		},
// 		PublicLandMobileNetworks: []*armmobilenetwork.PublicLandMobileNetwork{
// 			{
// 				Mcc: to.Ptr("001"),
// 				Mnc: to.Ptr("01"),
// 				HomeNetworkPublicKeys: &armmobilenetwork.PublicLandMobileNetworkHomeNetworkPublicKeys{
// 					ProfileA: []*armmobilenetwork.HomeNetworkPublicKey{
// 						{
// 							ID: to.Ptr[int32](1),
// 							URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpk"),
// 						},
// 						{
// 							ID: to.Ptr[int32](2),
// 							URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpk2/5e4876e9140e4e16bfe6e2cf92e0cbd2"),
// 					}},
// 					ProfileB: []*armmobilenetwork.HomeNetworkPublicKey{
// 						{
// 							ID: to.Ptr[int32](1),
// 							URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpkProfileB"),
// 					}},
// 				},
// 		}},
// 	},
// }

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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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"),
	// 				},
	// 				PublicLandMobileNetworks: []*armmobilenetwork.PublicLandMobileNetwork{
	// 					{
	// 						Mcc: to.Ptr("001"),
	// 						Mnc: to.Ptr("01"),
	// 						HomeNetworkPublicKeys: &armmobilenetwork.PublicLandMobileNetworkHomeNetworkPublicKeys{
	// 							ProfileA: []*armmobilenetwork.HomeNetworkPublicKey{
	// 								{
	// 									ID: to.Ptr[int32](1),
	// 									URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpk"),
	// 								},
	// 								{
	// 									ID: to.Ptr[int32](2),
	// 									URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpk2/5e4876e9140e4e16bfe6e2cf92e0cbd2"),
	// 							}},
	// 							ProfileB: []*armmobilenetwork.HomeNetworkPublicKey{
	// 								{
	// 									ID: to.Ptr[int32](1),
	// 									URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpkProfileB"),
	// 							}},
	// 						},
	// 				}},
	// 			},
	// 	}},
	// }
}

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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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"),
	// 				},
	// 				PublicLandMobileNetworks: []*armmobilenetwork.PublicLandMobileNetwork{
	// 					{
	// 						Mcc: to.Ptr("001"),
	// 						Mnc: to.Ptr("01"),
	// 						HomeNetworkPublicKeys: &armmobilenetwork.PublicLandMobileNetworkHomeNetworkPublicKeys{
	// 							ProfileA: []*armmobilenetwork.HomeNetworkPublicKey{
	// 								{
	// 									ID: to.Ptr[int32](1),
	// 									URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpk"),
	// 								},
	// 								{
	// 									ID: to.Ptr[int32](2),
	// 									URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpk2/5e4876e9140e4e16bfe6e2cf92e0cbd2"),
	// 							}},
	// 							ProfileB: []*armmobilenetwork.HomeNetworkPublicKey{
	// 								{
	// 									ID: to.Ptr[int32](1),
	// 									URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpkProfileB"),
	// 							}},
	// 						},
	// 				}},
	// 			},
	// 	}},
	// }
}

Output:

func (*MobileNetworksClient) UpdateTags 

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

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

Generated from API version 2024-02-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 and/or identity.
  • 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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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.IdentityAndTagsObject{
	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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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"),
// 		},
// 		PublicLandMobileNetworks: []*armmobilenetwork.PublicLandMobileNetwork{
// 			{
// 				Mcc: to.Ptr("001"),
// 				Mnc: to.Ptr("01"),
// 				HomeNetworkPublicKeys: &armmobilenetwork.PublicLandMobileNetworkHomeNetworkPublicKeys{
// 					ProfileA: []*armmobilenetwork.HomeNetworkPublicKey{
// 						{
// 							ID: to.Ptr[int32](1),
// 							URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpk"),
// 						},
// 						{
// 							ID: to.Ptr[int32](2),
// 							URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpk2/5e4876e9140e4e16bfe6e2cf92e0cbd2"),
// 					}},
// 					ProfileB: []*armmobilenetwork.HomeNetworkPublicKey{
// 						{
// 							ID: to.Ptr[int32](1),
// 							URL: to.Ptr("https://contosovault.vault.azure.net/secrets/exampleHnpkProfileB"),
// 					}},
// 				},
// 		}},
// 	},
// }

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 {
	// Mobile network resource.
	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 {
	// Mobile network resource.
	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 {
	// Response for mobile networks API service call.
	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 {
	// Response for mobile networks API service call.
	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 {
	// Mobile network resource.
	MobileNetwork
}

MobileNetworksClientUpdateTagsResponse contains the response from method MobileNetworksClient.UpdateTags.

type NASRerouteConfiguration 

type NASRerouteConfiguration struct {
	// REQUIRED; The macro network's MME group ID. This is where unknown UEs are sent to via NAS reroute.
	MacroMmeGroupID *int32
}

NASRerouteConfiguration - Configuration enabling NAS reroute.

func (NASRerouteConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type NASRerouteConfiguration.

func (*NASRerouteConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type NASRerouteConfiguration.

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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 {
	// List of the operations.
	OperationList
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type PacketCapture 

type PacketCapture struct {
	// REQUIRED; Packet capture session properties. Packet capture file(s) derived from the name of this session will be uploaded
	// to the Storage Account Container URL in the packet core control plane properties
	Properties *PacketCapturePropertiesFormat

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/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
}

PacketCapture - Packet capture session resource.

func (PacketCapture) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PacketCapture.

func (*PacketCapture) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCapture.

type PacketCaptureListResult 

type PacketCaptureListResult struct {
	// A list of packet capture sessions under a packet core control plane.
	Value []*PacketCapture

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

PacketCaptureListResult - Response for packet capture API service call.

func (PacketCaptureListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PacketCaptureListResult.

func (*PacketCaptureListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCaptureListResult.

type PacketCapturePropertiesFormat 

type PacketCapturePropertiesFormat struct {
	// Number of bytes captured per packet, the remaining bytes are truncated. The default "0" means the entire packet is captured.
	BytesToCapturePerPacket *int64

	// List of network interfaces to capture on.
	NetworkInterfaces []*string

	// Maximum duration of the capture session in seconds.
	TimeLimitInSeconds *int32

	// Maximum size of the capture output.
	TotalBytesPerSession *int64

	// READ-ONLY; The start time of the packet capture session.
	CaptureStartTime *time.Time

	// READ-ONLY; The list of output files of a packet capture session.
	OutputFiles []*string

	// READ-ONLY; The provisioning state of the packet capture session resource.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The reason the current packet capture session state.
	Reason *string

	// READ-ONLY; The status of the packet capture session.
	Status *PacketCaptureStatus
}

PacketCapturePropertiesFormat - Packet capture session properties.

func (PacketCapturePropertiesFormat) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PacketCapturePropertiesFormat.

func (*PacketCapturePropertiesFormat) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCapturePropertiesFormat.

type PacketCaptureStatus 

type PacketCaptureStatus string

PacketCaptureStatus - The status of the packet capture session. 

const (
	PacketCaptureStatusError      PacketCaptureStatus = "Error"
	PacketCaptureStatusNotStarted PacketCaptureStatus = "NotStarted"
	PacketCaptureStatusRunning    PacketCaptureStatus = "Running"
	PacketCaptureStatusStopped    PacketCaptureStatus = "Stopped"
)

func PossiblePacketCaptureStatusValues 

func PossiblePacketCaptureStatusValues() []PacketCaptureStatus

PossiblePacketCaptureStatusValues returns the possible values for the PacketCaptureStatus const type.

type PacketCapturesClient 

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

PacketCapturesClient contains the methods for the PacketCaptures group. Don't use this type directly, use NewPacketCapturesClient() instead.

func NewPacketCapturesClient 

func NewPacketCapturesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PacketCapturesClient, error)

NewPacketCapturesClient creates a new instance of PacketCapturesClient with the specified values.

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

func (*PacketCapturesClient) BeginCreateOrUpdate 

func (client *PacketCapturesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, packetCaptureName string, parameters PacketCapture, options *PacketCapturesClientBeginCreateOrUpdateOptions) (*runtime.Poller[PacketCapturesClientCreateOrUpdateResponse], error)

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

Generated from API version 2024-02-01

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/PacketCaptureCreate.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.NewPacketCapturesClient().BeginCreateOrUpdate(ctx, "rg1", "TestPacketCoreCP", "pc1", armmobilenetwork.PacketCapture{
	Properties: &armmobilenetwork.PacketCapturePropertiesFormat{
		BytesToCapturePerPacket: to.Ptr[int64](10000),
		NetworkInterfaces: []*string{
			to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP"),
			to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP"),
			to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestADN")},
		TimeLimitInSeconds:   to.Ptr[int32](100),
		TotalBytesPerSession: to.Ptr[int64](100000),
	},
}, 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.PacketCapture = armmobilenetwork.PacketCapture{
// 	Name: to.Ptr("pc1"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCaptures/pc1"),
// 	Properties: &armmobilenetwork.PacketCapturePropertiesFormat{
// 		BytesToCapturePerPacket: to.Ptr[int64](10000),
// 		NetworkInterfaces: []*string{
// 			to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP"),
// 			to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP"),
// 			to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestADN")},
// 			ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 			Status: to.Ptr(armmobilenetwork.PacketCaptureStatusStopped),
// 			TimeLimitInSeconds: to.Ptr[int32](100),
// 			TotalBytesPerSession: to.Ptr[int64](100000),
// 		},
// 	}

Output:

func (*PacketCapturesClient) BeginDelete 

func (client *PacketCapturesClient) BeginDelete(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, packetCaptureName string, options *PacketCapturesClientBeginDeleteOptions) (*runtime.Poller[PacketCapturesClientDeleteResponse], error)

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

Generated from API version 2024-02-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • packetCaptureName - The name of the packet capture session.
  • options - PacketCapturesClientBeginDeleteOptions contains the optional parameters for the PacketCapturesClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/PacketCaptureDelete.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.NewPacketCapturesClient().BeginDelete(ctx, "rg1", "TestPacketCoreCP", "pc1", 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 (*PacketCapturesClient) BeginStop 

func (client *PacketCapturesClient) BeginStop(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, packetCaptureName string, options *PacketCapturesClientBeginStopOptions) (*runtime.Poller[PacketCapturesClientStopResponse], error)

BeginStop - Stop a packet capture session. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • packetCaptureName - The name of the packet capture session.
  • options - PacketCapturesClientBeginStopOptions contains the optional parameters for the PacketCapturesClient.BeginStop method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/PacketCaptureStop.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.NewPacketCapturesClient().BeginStop(ctx, "rg1", "TestPacketCoreCP", "pc1", 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 (*PacketCapturesClient) Get 

func (client *PacketCapturesClient) Get(ctx context.Context, resourceGroupName string, packetCoreControlPlaneName string, packetCaptureName string, options *PacketCapturesClientGetOptions) (PacketCapturesClientGetResponse, error)

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

Generated from API version 2024-02-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • packetCoreControlPlaneName - The name of the packet core control plane.
  • packetCaptureName - The name of the packet capture session.
  • options - PacketCapturesClientGetOptions contains the optional parameters for the PacketCapturesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/PacketCaptureGet.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.NewPacketCapturesClient().Get(ctx, "rg1", "TestPacketCoreCP", "pc1", 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.PacketCapture = armmobilenetwork.PacketCapture{
// 	Name: to.Ptr("pc1"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCaptures/pc1"),
// 	Properties: &armmobilenetwork.PacketCapturePropertiesFormat{
// 		BytesToCapturePerPacket: to.Ptr[int64](10000),
// 		NetworkInterfaces: []*string{
// 			to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP"),
// 			to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP"),
// 			to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestADN")},
// 			OutputFiles: []*string{
// 				to.Ptr("https://constoso.blob.core.windows.net/diagscontainer/pc1_pcaps-1.tar.zip"),
// 				to.Ptr("https://constoso.blob.core.windows.net/diagscontainer/pc1_pcaps-2.tar.zip")},
// 				ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 				Status: to.Ptr(armmobilenetwork.PacketCaptureStatusStopped),
// 				TimeLimitInSeconds: to.Ptr[int32](100),
// 				TotalBytesPerSession: to.Ptr[int64](100000),
// 			},
// 		}

Output:

func (*PacketCapturesClient) NewListByPacketCoreControlPlanePager 

func (client *PacketCapturesClient) NewListByPacketCoreControlPlanePager(resourceGroupName string, packetCoreControlPlaneName string, options *PacketCapturesClientListByPacketCoreControlPlaneOptions) *runtime.Pager[PacketCapturesClientListByPacketCoreControlPlaneResponse]

NewListByPacketCoreControlPlanePager - Lists all the packet capture sessions under a packet core control plane.

Generated from API version 2024-02-01

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/PacketCaptureListByPacketCoreControlPlane.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.NewPacketCapturesClient().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.PacketCaptureListResult = armmobilenetwork.PacketCaptureListResult{
	// 	Value: []*armmobilenetwork.PacketCapture{
	// 		{
	// 			Name: to.Ptr("pc1"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCaptures/pc1"),
	// 			Properties: &armmobilenetwork.PacketCapturePropertiesFormat{
	// 				BytesToCapturePerPacket: to.Ptr[int64](10000),
	// 				NetworkInterfaces: []*string{
	// 					to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP"),
	// 					to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP"),
	// 					to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestADN")},
	// 					ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 					Status: to.Ptr(armmobilenetwork.PacketCaptureStatusStopped),
	// 					TimeLimitInSeconds: to.Ptr[int32](100),
	// 					TotalBytesPerSession: to.Ptr[int64](100000),
	// 				},
	// 			},
	// 			{
	// 				Name: to.Ptr("pc2"),
	// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCaptures/pc2"),
	// 				Properties: &armmobilenetwork.PacketCapturePropertiesFormat{
	// 					BytesToCapturePerPacket: to.Ptr[int64](10000),
	// 					NetworkInterfaces: []*string{
	// 						to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP"),
	// 						to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP"),
	// 						to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestADN")},
	// 						ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
	// 						Status: to.Ptr(armmobilenetwork.PacketCaptureStatusStopped),
	// 						TimeLimitInSeconds: to.Ptr[int32](100),
	// 						TotalBytesPerSession: to.Ptr[int64](100000),
	// 					},
	// 			}},
	// 		}
}

Output:

type PacketCapturesClientBeginCreateOrUpdateOptions 

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

PacketCapturesClientBeginCreateOrUpdateOptions contains the optional parameters for the PacketCapturesClient.BeginCreateOrUpdate method.

type PacketCapturesClientBeginDeleteOptions 

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

PacketCapturesClientBeginDeleteOptions contains the optional parameters for the PacketCapturesClient.BeginDelete method.

type PacketCapturesClientBeginStopOptions 

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

PacketCapturesClientBeginStopOptions contains the optional parameters for the PacketCapturesClient.BeginStop method.

type PacketCapturesClientCreateOrUpdateResponse 

type PacketCapturesClientCreateOrUpdateResponse struct {
	// Packet capture session resource.
	PacketCapture
}

PacketCapturesClientCreateOrUpdateResponse contains the response from method PacketCapturesClient.BeginCreateOrUpdate.

type PacketCapturesClientDeleteResponse 

type PacketCapturesClientDeleteResponse struct {
}

PacketCapturesClientDeleteResponse contains the response from method PacketCapturesClient.BeginDelete.

type PacketCapturesClientGetOptions 

type PacketCapturesClientGetOptions struct {
}

PacketCapturesClientGetOptions contains the optional parameters for the PacketCapturesClient.Get method.

type PacketCapturesClientGetResponse 

type PacketCapturesClientGetResponse struct {
	// Packet capture session resource.
	PacketCapture
}

PacketCapturesClientGetResponse contains the response from method PacketCapturesClient.Get.

type PacketCapturesClientListByPacketCoreControlPlaneOptions 

type PacketCapturesClientListByPacketCoreControlPlaneOptions struct {
}

PacketCapturesClientListByPacketCoreControlPlaneOptions contains the optional parameters for the PacketCapturesClient.NewListByPacketCoreControlPlanePager method.

type PacketCapturesClientListByPacketCoreControlPlaneResponse 

type PacketCapturesClientListByPacketCoreControlPlaneResponse struct {
	// Response for packet capture API service call.
	PacketCaptureListResult
}

PacketCapturesClientListByPacketCoreControlPlaneResponse contains the response from method PacketCapturesClient.NewListByPacketCoreControlPlanePager.

type PacketCapturesClientStopResponse 

type PacketCapturesClientStopResponse struct {
	// The current status of an async operation.
	AsyncOperationStatus
}

PacketCapturesClientStopResponse contains the response from method PacketCapturesClient.BeginStop.

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. E.g. "/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 virtual IP address(es) for the control plane on the access network in a High Availability (HA) system. In an HA deployment
	// the access network router should be configured to anycast traffic for
	// this address to the control plane access interfaces on the active and standby nodes. In non-HA system this list should
	// be omitted or empty.
	ControlPlaneAccessVirtualIPv4Addresses []*string

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

	// Configuration for uploading packet core diagnostics
	DiagnosticsUpload *DiagnosticsUploadConfiguration

	// Configuration for sending packet core events to an Azure Event Hub.
	EventHub *EventHubConfiguration

	// The installation state of the packet core control plane resource.
	Installation *Installation

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

	// Signaling configuration for the packet core.
	Signaling *SignalingConfiguration

	// 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 desired version of the packet core software.
	Version *string

	// READ-ONLY; The provisioning state of the secret containing private keys and keyIds for SUPI concealment.
	HomeNetworkPrivateKeysProvisioning *HomeNetworkPrivateKeysProvisioning

	// READ-ONLY; The currently installed version of the packet core software.
	InstalledVersion *string

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

type PacketCoreControlPlaneResourceID struct {
	// REQUIRED; Packet core control plane resource ID.
	ID *string
}

PacketCoreControlPlaneResourceID - Reference to an packet core control plane resource.

func (PacketCoreControlPlaneResourceID) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PacketCoreControlPlaneResourceID.

func (*PacketCoreControlPlaneResourceID) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PacketCoreControlPlaneResourceID.

type PacketCoreControlPlaneVersion 

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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) GetBySubscription 

func (client *PacketCoreControlPlaneVersionsClient) GetBySubscription(ctx context.Context, versionName string, subscriptionID string, options *PacketCoreControlPlaneVersionsClientGetBySubscriptionOptions) (PacketCoreControlPlaneVersionsClientGetBySubscriptionResponse, error)

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

Generated from API version 2024-02-01

  • versionName - The name of the packet core control plane version.
  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • options - PacketCoreControlPlaneVersionsClientGetBySubscriptionOptions contains the optional parameters for the PacketCoreControlPlaneVersionsClient.GetBySubscription method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/PacketCoreControlPlaneVersionGetBySubscription.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().GetBySubscription(ctx, "PMN-4-11-1", "00000000-0000-0000-0000-000000000000", 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("/subscriptions/00000000-0000-0000-0000-000000000000/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) NewListBySubscriptionPager 

func (client *PacketCoreControlPlaneVersionsClient) NewListBySubscriptionPager(subscriptionID string, options *PacketCoreControlPlaneVersionsClientListBySubscriptionOptions) *runtime.Pager[PacketCoreControlPlaneVersionsClientListBySubscriptionResponse]

NewListBySubscriptionPager - Lists all supported packet core control planes versions.

Generated from API version 2024-02-01

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • options - PacketCoreControlPlaneVersionsClientListBySubscriptionOptions contains the optional parameters for the PacketCoreControlPlaneVersionsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/PacketCoreControlPlaneVersionListBySubscription.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().NewListBySubscriptionPager("00000000-0000-0000-0000-000000000000", 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("/subscriptions/00000000-0000-0000-0000-000000000000/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("/subscriptions/00000000-0000-0000-0000-000000000000/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("/subscriptions/00000000-0000-0000-0000-000000000000/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:

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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 PacketCoreControlPlaneVersionsClientGetBySubscriptionOptions 

type PacketCoreControlPlaneVersionsClientGetBySubscriptionOptions struct {
}

PacketCoreControlPlaneVersionsClientGetBySubscriptionOptions contains the optional parameters for the PacketCoreControlPlaneVersionsClient.GetBySubscription method.

type PacketCoreControlPlaneVersionsClientGetBySubscriptionResponse 

type PacketCoreControlPlaneVersionsClientGetBySubscriptionResponse struct {
	// Packet core control plane version resource.
	PacketCoreControlPlaneVersion
}

PacketCoreControlPlaneVersionsClientGetBySubscriptionResponse contains the response from method PacketCoreControlPlaneVersionsClient.GetBySubscription.

type PacketCoreControlPlaneVersionsClientGetOptions 

type PacketCoreControlPlaneVersionsClientGetOptions struct {
}

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

type PacketCoreControlPlaneVersionsClientGetResponse 

type PacketCoreControlPlaneVersionsClientGetResponse struct {
	// Packet core control plane version resource.
	PacketCoreControlPlaneVersion
}

PacketCoreControlPlaneVersionsClientGetResponse contains the response from method PacketCoreControlPlaneVersionsClient.Get.

type PacketCoreControlPlaneVersionsClientListBySubscriptionOptions 

type PacketCoreControlPlaneVersionsClientListBySubscriptionOptions struct {
}

PacketCoreControlPlaneVersionsClientListBySubscriptionOptions contains the optional parameters for the PacketCoreControlPlaneVersionsClient.NewListBySubscriptionPager method.

type PacketCoreControlPlaneVersionsClientListBySubscriptionResponse 

type PacketCoreControlPlaneVersionsClientListBySubscriptionResponse struct {
	// Response for packet core control plane version API service call.
	PacketCoreControlPlaneVersionListResult
}

PacketCoreControlPlaneVersionsClientListBySubscriptionResponse contains the response from method PacketCoreControlPlaneVersionsClient.NewListBySubscriptionPager.

type PacketCoreControlPlaneVersionsClientListOptions 

type PacketCoreControlPlaneVersionsClientListOptions struct {
}

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

type PacketCoreControlPlaneVersionsClientListResponse 

type PacketCoreControlPlaneVersionsClientListResponse struct {
	// Response for packet core control plane version API service call.
	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. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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),
		EventHub: &armmobilenetwork.EventHubConfiguration{
			ID:                to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.EventHub/namespaces/contosoNamespace/eventHubs/contosoHub"),
			ReportingInterval: to.Ptr[int32](60),
		},
		Installation: &armmobilenetwork.Installation{
			DesiredState: to.Ptr(armmobilenetwork.DesiredInstallationStateInstalled),
		},
		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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
			},
			ConnectedCluster: &armmobilenetwork.ConnectedClusterResourceID{
				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/TestConnectedCluster"),
			},
			CustomLocation: &armmobilenetwork.CustomLocationResourceID{
				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.ExtendedLocation/customLocations/TestCustomLocation"),
			},
		},
		Signaling: &armmobilenetwork.SignalingConfiguration{
			NasReroute: &armmobilenetwork.NASRerouteConfiguration{
				MacroMmeGroupID: to.Ptr[int32](1024),
			},
		},
		Sites: []*armmobilenetwork.SiteResourceID{
			{
				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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),
// 		EventHub: &armmobilenetwork.EventHubConfiguration{
// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.EventHub/namespaces/contosoNamespace/eventHubs/contosoHub"),
// 			ReportingInterval: to.Ptr[int32](60),
// 		},
// 		Installation: &armmobilenetwork.Installation{
// 			DesiredState: to.Ptr(armmobilenetwork.DesiredInstallationStateInstalled),
// 			ReinstallRequired: to.Ptr(armmobilenetwork.ReinstallRequiredNotRequired),
// 			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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
// 			},
// 			AzureStackEdgeDevices: []*armmobilenetwork.AzureStackEdgeDeviceResourceID{
// 				{
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
// 				},
// 				{
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice2"),
// 			}},
// 			ConnectedCluster: &armmobilenetwork.ConnectedClusterResourceID{
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/TestConnectedCluster"),
// 			},
// 			CustomLocation: &armmobilenetwork.CustomLocationResourceID{
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.ExtendedLocation/customLocations/TestCustomLocation"),
// 			},
// 		},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		Signaling: &armmobilenetwork.SignalingConfiguration{
// 			NasReroute: &armmobilenetwork.NASRerouteConfiguration{
// 				MacroMmeGroupID: to.Ptr[int32](1024),
// 			},
// 		},
// 		Sites: []*armmobilenetwork.SiteResourceID{
// 			{
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 try to restore the packet core to the installed state that was disrupted by a transient failure. This action will cause a service outage. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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),
// 		EventHub: &armmobilenetwork.EventHubConfiguration{
// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.EventHub/namespaces/contosoNamespace/eventHubs/contosoHub"),
// 			ReportingInterval: to.Ptr[int32](60),
// 		},
// 		HomeNetworkPrivateKeysProvisioning: &armmobilenetwork.HomeNetworkPrivateKeysProvisioning{
// 			State: to.Ptr(armmobilenetwork.HomeNetworkPrivateKeysProvisioningStateProvisioned),
// 		},
// 		Installation: &armmobilenetwork.Installation{
// 			Operation: &armmobilenetwork.AsyncOperationID{
// 				ID: to.Ptr("/providers/Microsoft.MobileNetwork/locations/EASTUS/operationStatuses/abc"),
// 			},
// 			State: to.Ptr(armmobilenetwork.InstallationStateInstalling),
// 		},
// 		InstalledVersion: to.Ptr("0.2.0"),
// 		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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
// 			},
// 			AzureStackEdgeDevices: []*armmobilenetwork.AzureStackEdgeDeviceResourceID{
// 				{
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
// 				},
// 				{
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice2"),
// 			}},
// 			ConnectedCluster: &armmobilenetwork.ConnectedClusterResourceID{
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/TestConnectedCluster"),
// 			},
// 			CustomLocation: &armmobilenetwork.CustomLocationResourceID{
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.ExtendedLocation/customLocations/TestCustomLocation"),
// 			},
// 		},
// 		ProvisioningState: to.Ptr(armmobilenetwork.ProvisioningStateSucceeded),
// 		RollbackVersion: to.Ptr("0.1.0"),
// 		Signaling: &armmobilenetwork.SignalingConfiguration{
// 			NasReroute: &armmobilenetwork.NASRerouteConfiguration{
// 				MacroMmeGroupID: to.Ptr[int32](1024),
// 			},
// 		},
// 		Sites: []*armmobilenetwork.SiteResourceID{
// 			{
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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),
	// 				HomeNetworkPrivateKeysProvisioning: &armmobilenetwork.HomeNetworkPrivateKeysProvisioning{
	// 					State: to.Ptr(armmobilenetwork.HomeNetworkPrivateKeysProvisioningStateProvisioned),
	// 				},
	// 				Installation: &armmobilenetwork.Installation{
	// 					Reasons: []*armmobilenetwork.InstallationReason{
	// 						to.Ptr(armmobilenetwork.InstallationReasonNoSlices)},
	// 						State: to.Ptr(armmobilenetwork.InstallationStateUninstalled),
	// 					},
	// 					InstalledVersion: to.Ptr("0.2.0"),
	// 					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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
	// 						},
	// 						AzureStackEdgeDevices: []*armmobilenetwork.AzureStackEdgeDeviceResourceID{
	// 							{
	// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
	// 							},
	// 							{
	// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice2"),
	// 						}},
	// 						ConnectedCluster: &armmobilenetwork.ConnectedClusterResourceID{
	// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/TestConnectedCluster"),
	// 						},
	// 						CustomLocation: &armmobilenetwork.CustomLocationResourceID{
	// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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),
	// 				},
	// 				InstalledVersion: to.Ptr("0.2.0"),
	// 				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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
	// 					},
	// 					AzureStackEdgeDevices: []*armmobilenetwork.AzureStackEdgeDeviceResourceID{
	// 						{
	// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
	// 						},
	// 						{
	// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice2"),
	// 					}},
	// 					ConnectedCluster: &armmobilenetwork.ConnectedClusterResourceID{
	// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/TestConnectedCluster"),
	// 					},
	// 					CustomLocation: &armmobilenetwork.CustomLocationResourceID{
	// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/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 IdentityAndTagsObject, options *PacketCoreControlPlanesClientUpdateTagsOptions) (PacketCoreControlPlanesClientUpdateTagsResponse, error)

UpdateTags - Patch packet core control plane resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-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 patch packet core control plane resource.
  • 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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/PacketCoreControlPlanePatch.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.IdentityAndTagsObject{
	Identity: &armmobilenetwork.ManagedServiceIdentity{
		Type: to.Ptr(armmobilenetwork.ManagedServiceIdentityTypeUserAssigned),
		UserAssignedIdentities: map[string]*armmobilenetwork.UserAssignedIdentity{
			"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testUserAssignedManagedIdentity": {},
		},
	},
	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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/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.PacketCoreControlPlanePropertiesFormat{
// 		ControlPlaneAccessInterface: &armmobilenetwork.InterfaceProperties{
// 			Name: to.Ptr("N2"),
// 		},
// 		CoreNetworkTechnology: to.Ptr(armmobilenetwork.CoreNetworkTypeFiveGC),
// 		Installation: &armmobilenetwork.Installation{
// 			State: to.Ptr(armmobilenetwork.InstallationStateInstalled),
// 		},
// 		InstalledVersion: to.Ptr("0.2.0"),
// 		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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
// 			},
// 			AzureStackEdgeDevices: []*armmobilenetwork.AzureStackEdgeDeviceResourceID{
// 				{
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice"),
// 				},
// 				{
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.DataBoxEdge/dataBoxEdgeDevices/TestAzureStackEdgeDevice2"),
// 			}},
// 			ConnectedCluster: &armmobilenetwork.ConnectedClusterResourceID{
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/TestConnectedCluster"),
// 			},
// 			CustomLocation: &armmobilenetwork.CustomLocationResourceID{
// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/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 {
	// The current status of an async operation.
	AsyncOperationStatus
}

PacketCoreControlPlanesClientCollectDiagnosticsPackageResponse contains the response from method PacketCoreControlPlanesClient.BeginCollectDiagnosticsPackage.

type PacketCoreControlPlanesClientCreateOrUpdateResponse 

type PacketCoreControlPlanesClientCreateOrUpdateResponse struct {
	// Packet core control plane resource.
	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 {
	// Packet core control plane resource.
	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 {
	// Response for packet core control planes API service call.
	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 {
	// Response for packet core control planes API service call.
	PacketCoreControlPlaneListResult
}

PacketCoreControlPlanesClientListBySubscriptionResponse contains the response from method PacketCoreControlPlanesClient.NewListBySubscriptionPager.

type PacketCoreControlPlanesClientReinstallResponse 

type PacketCoreControlPlanesClientReinstallResponse struct {
	// The current status of an async operation.
	AsyncOperationStatus
}

PacketCoreControlPlanesClientReinstallResponse contains the response from method PacketCoreControlPlanesClient.BeginReinstall.

type PacketCoreControlPlanesClientRollbackResponse 

type PacketCoreControlPlanesClientRollbackResponse struct {
	// The current status of an async operation.
	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 {
	// Packet core control plane resource.
	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. E.g. "/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

	// The virtual IP address(es) for the user plane on the access network in a High Availability (HA) system. In an HA deployment
	// the access network router should be configured to forward traffic for this
	// address to the control plane access interface on the active or standby node. In non-HA system this list should be omitted
	// or empty.
	UserPlaneAccessVirtualIPv4Addresses []*string

	// 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. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 {
	// Packet core data plane resource. Must be created in the same location as its parent packet core control plane.
	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 {
	// Packet core data plane resource. Must be created in the same location as its parent packet core control plane.
	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 {
	// Response for packet core data planes API service call.
	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 {
	// Packet core data plane resource. Must be created in the same location as its parent packet core control plane.
	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

	// 5G QoS Flow Indicator value. The 5QI identifies a specific QoS forwarding treatment to be provided to a flow. 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 the 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 PdnType 

type PdnType string

PdnType - Packet Data Network Type 

const (
	PdnTypeIPV4 PdnType = "IPV4"
)

func PossiblePdnTypeValues 

func PossiblePdnTypeValues() []PdnType

PossiblePdnTypeValues returns the possible values for the PdnType const type.

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. 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.

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. If both 'publicLandMobileNetworks' and 'publicLandMobileNetworkIdentifier'
	// are specified, then the 'publicLandMobileNetworks' will
	// take precedence.
	PublicLandMobileNetworkIdentifier *PlmnID

	// A list of public land mobile networks including their identifiers. If both 'publicLandMobileNetworks' and 'publicLandMobileNetworkIdentifier'
	// are specified, then the 'publicLandMobileNetworks' will
	// take precedence.
	PublicLandMobileNetworks []*PublicLandMobileNetwork

	// 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. E.g. "/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 PublicLandMobileNetwork 

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

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

	// Configuration relating to SUPI concealment.
	HomeNetworkPublicKeys *PublicLandMobileNetworkHomeNetworkPublicKeys
}

PublicLandMobileNetwork - Configuration relating to a particular PLMN

func (PublicLandMobileNetwork) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PublicLandMobileNetwork.

func (*PublicLandMobileNetwork) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PublicLandMobileNetwork.

type PublicLandMobileNetworkHomeNetworkPublicKeys 

type PublicLandMobileNetworkHomeNetworkPublicKeys struct {
	// This provides a mapping to identify which public key has been used for SUPI concealment using the Profile A Protection
	// Scheme.
	ProfileA []*HomeNetworkPublicKey

	// This provides a mapping to identify which public key has been used for SUPI concealment using the Profile B Protection
	// Scheme.
	ProfileB []*HomeNetworkPublicKey
}

PublicLandMobileNetworkHomeNetworkPublicKeys - Configuration relating to SUPI concealment.

func (PublicLandMobileNetworkHomeNetworkPublicKeys) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PublicLandMobileNetworkHomeNetworkPublicKeys.

func (*PublicLandMobileNetworkHomeNetworkPublicKeys) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PublicLandMobileNetworkHomeNetworkPublicKeys.

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

	// 5G QoS Flow Indicator value. The 5QI identifies a specific QoS forwarding treatment to be provided to a flow. 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 the 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 RatType 

type RatType string

RatType - RAT Type 

const (
	RatTypeFiveG RatType = "5G"
	RatTypeFourG RatType = "4G"
)

func PossibleRatTypeValues 

func PossibleRatTypeValues() []RatType

PossibleRatTypeValues returns the possible values for the RatType const type.

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 ReinstallRequired 

type ReinstallRequired string

ReinstallRequired - Whether a reinstall of the packet core is required to pick up the latest configuration changes. 

const (
	// ReinstallRequiredNotRequired - A reinstall of the packet core is not required.
	ReinstallRequiredNotRequired ReinstallRequired = "NotRequired"
	// ReinstallRequiredRequired - A reinstall of the packet core is required.
	ReinstallRequiredRequired ReinstallRequired = "Required"
)

func PossibleReinstallRequiredValues 

func PossibleReinstallRequiredValues() []ReinstallRequired

PossibleReinstallRequiredValues returns the possible values for the ReinstallRequired const type.

type Resource 

type Resource struct {
	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/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 RrcEstablishmentCause 

type RrcEstablishmentCause string

RrcEstablishmentCause - Radio connection establishment cause 

const (
	RrcEstablishmentCauseEmergency                 RrcEstablishmentCause = "Emergency"
	RrcEstablishmentCauseMobileOriginatedData      RrcEstablishmentCause = "MobileOriginatedData"
	RrcEstablishmentCauseMobileOriginatedSignaling RrcEstablishmentCause = "MobileOriginatedSignaling"
	RrcEstablishmentCauseMobileTerminatedData      RrcEstablishmentCause = "MobileTerminatedData"
	RrcEstablishmentCauseMobileTerminatedSignaling RrcEstablishmentCause = "MobileTerminatedSignaling"
	RrcEstablishmentCauseSMS                       RrcEstablishmentCause = "SMS"
)

func PossibleRrcEstablishmentCauseValues 

func PossibleRrcEstablishmentCauseValues() []RrcEstablishmentCause

PossibleRrcEstablishmentCauseValues returns the possible values for the RrcEstablishmentCause const type.

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. E.g. "/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. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 resource. Must be created in the same location as its parent mobile network.
	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 resource. Must be created in the same location as its parent mobile network.
	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 {
	// Response for services API service call.
	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 resource. Must be created in the same location as its parent mobile network.
	Service
}

ServicesClientUpdateTagsResponse contains the response from method ServicesClient.UpdateTags.

type SignalingConfiguration 

type SignalingConfiguration struct {
	// Configuration enabling 4G NAS reroute.
	NasReroute *NASRerouteConfiguration
}

SignalingConfiguration - Signaling configuration for the packet core.

func (SignalingConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SignalingConfiguration.

func (*SignalingConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SignalingConfiguration.

type Sim 

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

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/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. E.g. "/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. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/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 IdentityAndTagsObject, options *SimGroupsClientUpdateTagsOptions) (SimGroupsClientUpdateTagsResponse, error)

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

Generated from API version 2024-02-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • simGroupName - The name of the SIM Group.
  • parameters - Parameters supplied to patch SIM group resource.
  • 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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/SimGroupPatch.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.IdentityAndTagsObject{
	Identity: &armmobilenetwork.ManagedServiceIdentity{
		Type: to.Ptr(armmobilenetwork.ManagedServiceIdentityTypeUserAssigned),
		UserAssignedIdentities: map[string]*armmobilenetwork.UserAssignedIdentity{
			"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/testUserAssignedManagedIdentity": {},
		},
	},
	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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/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 {
	// SIM group resource.
	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 {
	// SIM group resource.
	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 {
	// Response for list SIM groups API service call.
	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 {
	// Response for list SIM groups API service call.
	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 {
	// SIM group resource.
	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. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/testService"),
							}},
						DataNetwork: &armmobilenetwork.DataNetworkResourceID{
							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
				},
				Slice: &armmobilenetwork.SliceResourceID{
					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
// 			"/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/testService"),
// 						}},
// 						DataNetwork: &armmobilenetwork.DataNetworkResourceID{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
// 				},
// 				Slice: &armmobilenetwork.SliceResourceID{
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite": to.Ptr(armmobilenetwork.SiteProvisioningStateAdding),
// 			"/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/testService"),
// 						}},
// 						DataNetwork: &armmobilenetwork.DataNetworkResourceID{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
// 				},
// 				Slice: &armmobilenetwork.SliceResourceID{
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/testService"),
	// 								}},
	// 								DataNetwork: &armmobilenetwork.DataNetworkResourceID{
	// 									ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
	// 						},
	// 						Slice: &armmobilenetwork.SliceResourceID{
	// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/services/testService"),
// 						}},
// 						DataNetwork: &armmobilenetwork.DataNetworkResourceID{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/dataNetworks/testdataNetwork"),
// 				},
// 				Slice: &armmobilenetwork.SliceResourceID{
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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 {
	// SIM policy resource.
	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 {
	// SIM policy resource.
	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 {
	// Response for SIM policies API service call.
	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 {
	// SIM policy resource.
	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. E.g. "/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

	// UE periodic registration update timer (5G) or UE periodic tracking area update timer (4G), 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. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
				},
				StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
					{
						AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
						},
						Slice: &armmobilenetwork.SliceResourceID{
							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
				},
				StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
					{
						AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
						},
						Slice: &armmobilenetwork.SliceResourceID{
							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
				},
				StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
					{
						AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
						},
						Slice: &armmobilenetwork.SliceResourceID{
							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
				},
				StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
					{
						AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
						},
						Slice: &armmobilenetwork.SliceResourceID{
							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
		},
		StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
			{
				AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
				},
				Slice: &armmobilenetwork.SliceResourceID{
					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
// 		},
// 		SimState: to.Ptr(armmobilenetwork.SimStateEnabled),
// 		SiteProvisioningState: map[string]*armmobilenetwork.SiteProvisioningState{
// 			"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
// 			"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite2": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
// 		},
// 		StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
// 			{
// 				AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
// 				},
// 				Slice: &armmobilenetwork.SliceResourceID{
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
// 		},
// 		SimState: to.Ptr(armmobilenetwork.SimStateEnabled),
// 		SiteProvisioningState: map[string]*armmobilenetwork.SiteProvisioningState{
// 			"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
// 			"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite2": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
// 		},
// 		StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
// 			{
// 				AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
// 				},
// 				Slice: &armmobilenetwork.SliceResourceID{
// 					ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/simPolicies/MySimPolicy"),
	// 				},
	// 				SimState: to.Ptr(armmobilenetwork.SimStateEnabled),
	// 				SiteProvisioningState: map[string]*armmobilenetwork.SiteProvisioningState{
	// 					"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
	// 					"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/mobileNetworks/testMobileNetwork/sites/testSite2": to.Ptr(armmobilenetwork.SiteProvisioningStateProvisioned),
	// 				},
	// 				StaticIPConfiguration: []*armmobilenetwork.SimStaticIPProperties{
	// 					{
	// 						AttachedDataNetwork: &armmobilenetwork.AttachedDataNetworkResourceID{
	// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/packetCoreDataPlanes/TestPacketCoreDP/attachedDataNetworks/TestAttachedDataNetwork"),
	// 						},
	// 						Slice: &armmobilenetwork.SliceResourceID{
	// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/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 {
	// The current status of an async operation.
	AsyncOperationStatus
}

SimsClientBulkDeleteResponse contains the response from method SimsClient.BeginBulkDelete.

type SimsClientBulkUploadEncryptedResponse 

type SimsClientBulkUploadEncryptedResponse struct {
	// The current status of an async operation.
	AsyncOperationStatus
}

SimsClientBulkUploadEncryptedResponse contains the response from method SimsClient.BeginBulkUploadEncrypted.

type SimsClientBulkUploadResponse 

type SimsClientBulkUploadResponse struct {
	// The current status of an async operation.
	AsyncOperationStatus
}

SimsClientBulkUploadResponse contains the response from method SimsClient.BeginBulkUpload.

type SimsClientCreateOrUpdateResponse 

type SimsClientCreateOrUpdateResponse struct {
	// SIM resource.
	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 resource.
	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 {
	// Response for list SIMs API service call.
	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. E.g. "/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 SiteDeletePacketCore 

type SiteDeletePacketCore struct {
	// Reference to an packet core control plane resource.
	PacketCore *PacketCoreControlPlaneResourceID
}

SiteDeletePacketCore - The packet core to delete under a site.

func (SiteDeletePacketCore) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SiteDeletePacketCore.

func (*SiteDeletePacketCore) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SiteDeletePacketCore.

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

func (*SitesClient) BeginCreateOrUpdate 

func (client *SitesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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) BeginDeletePacketCore 

func (client *SitesClient) BeginDeletePacketCore(ctx context.Context, resourceGroupName string, mobileNetworkName string, siteName string, parameters SiteDeletePacketCore, options *SitesClientBeginDeletePacketCoreOptions) (*runtime.Poller[SitesClientDeletePacketCoreResponse], error)

BeginDeletePacketCore - Deletes a packet core under the specified mobile network site. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-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 delete a packet core under a site.
  • options - SitesClientBeginDeletePacketCoreOptions contains the optional parameters for the SitesClient.BeginDeletePacketCore method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/SiteDeletePacketCore.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().BeginDeletePacketCore(ctx, "rg1", "testMobileNetwork", "testSite", armmobilenetwork.SiteDeletePacketCore{
	PacketCore: &armmobilenetwork.PacketCoreControlPlaneResourceID{
		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/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 (*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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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/00000000-0000-0000-0000-000000000000/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 SitesClientBeginDeletePacketCoreOptions 

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

SitesClientBeginDeletePacketCoreOptions contains the optional parameters for the SitesClient.BeginDeletePacketCore method.

type SitesClientCreateOrUpdateResponse 

type SitesClientCreateOrUpdateResponse struct {
	// Site resource. Must be created in the same location as its parent mobile network.
	Site
}

SitesClientCreateOrUpdateResponse contains the response from method SitesClient.BeginCreateOrUpdate.

type SitesClientDeletePacketCoreResponse 

type SitesClientDeletePacketCoreResponse struct {
}

SitesClientDeletePacketCoreResponse contains the response from method SitesClient.BeginDeletePacketCore.

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 resource. Must be created in the same location as its parent mobile network.
	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 {
	// Response for sites API service call.
	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 resource. Must be created in the same location as its parent mobile network.
	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. E.g. "/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. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 2024-02-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/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-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/00000000-0000-0000-0000-000000000000/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.123Z"); 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.123Z"); 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 {
	// Network slice resource. Must be created in the same location as its parent mobile network.
	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 {
	// Network slice resource. Must be created in the same location as its parent mobile network.
	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 {
	// Response for network slice API service call.
	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 {
	// Network slice resource. Must be created in the same location as its parent mobile network.
	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. E.g. "/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 UeConnectionInfo4G 

type UeConnectionInfo4G struct {
	// REQUIRED; eNodeB S1AP identifier
	EnbS1ApID *int32

	// REQUIRED; Global RAN Node ID
	GlobalRanNodeID *GlobalRanNodeID

	// REQUIRED; MME S1AP identifier
	MmeS1ApID *int32

	// REQUIRED; Radio connection establishment cause
	RrcEstablishmentCause *RrcEstablishmentCause

	// REQUIRED; State of the UE.
	UeState *UeState

	// The timestamp of last activity of UE (UTC).
	LastActivityTime *time.Time

	// Last Visited TAI
	LastVisitedTai *string

	// UE Location Info properties
	LocationInfo *UeLocationInfo

	// Per-UE transport network layer association
	PerUeTnla *string

	// The UE's usage setting
	UeUsageSetting *UeUsageSetting
}

UeConnectionInfo4G - UE Connection Info for 4G

func (UeConnectionInfo4G) MarshalJSON 

func (u UeConnectionInfo4G) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeConnectionInfo4G.

func (*UeConnectionInfo4G) UnmarshalJSON 

func (u *UeConnectionInfo4G) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeConnectionInfo4G.

type UeConnectionInfo5G 

type UeConnectionInfo5G struct {
	// REQUIRED; The AMF UE NGAP ID
	AmfUeNgapID *int64

	// REQUIRED; Global RAN Node ID
	GlobalRanNodeID *GlobalRanNodeID

	// REQUIRED; The RAN UE NGAP ID
	RanUeNgapID *int32

	// REQUIRED; Radio connection establishment cause
	RrcEstablishmentCause *RrcEstablishmentCause

	// REQUIRED; State of the UE.
	UeState *UeState

	// Allowed Network Slice Selection Assistance Information
	AllowedNssai []*Snssai

	// The timestamp of last activity of UE (UTC).
	LastActivityTime *time.Time

	// Last Visited TAI
	LastVisitedTai *string

	// UE Location Info properties
	LocationInfo *UeLocationInfo

	// Per-UE transport network layer association
	PerUeTnla *string

	// The UE's usage setting
	UeUsageSetting *UeUsageSetting
}

UeConnectionInfo5G - UE Connection Info for 5G.

func (UeConnectionInfo5G) MarshalJSON 

func (u UeConnectionInfo5G) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeConnectionInfo5G.

func (*UeConnectionInfo5G) UnmarshalJSON 

func (u *UeConnectionInfo5G) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeConnectionInfo5G.

type UeIPAddress 

type UeIPAddress struct {
	// IPv4 address.
	IPV4Addr *string
}

UeIPAddress - UE IP address

func (UeIPAddress) MarshalJSON 

func (u UeIPAddress) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeIPAddress.

func (*UeIPAddress) UnmarshalJSON 

func (u *UeIPAddress) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeIPAddress.

type UeInfo 

type UeInfo struct {
	// REQUIRED; Basic UE Information Properties.
	Properties *UeInfoPropertiesFormat

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/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
}

UeInfo - Basic UE Information.

func (UeInfo) MarshalJSON 

func (u UeInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeInfo.

func (*UeInfo) UnmarshalJSON 

func (u *UeInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeInfo.

type UeInfo4G 

type UeInfo4G struct {
	// REQUIRED; UE Information properties for 4G.
	Info *UeInfo4GProperties

	// REQUIRED; RAT Type
	RatType *RatType

	// The timestamp of last UE info read from the packet core (UTC).
	LastReadAt *time.Time
}

UeInfo4G - UE Information for 4G.

func (*UeInfo4G) GetExtendedUeInfoProperties 

func (u *UeInfo4G) GetExtendedUeInfoProperties() *ExtendedUeInfoProperties

GetExtendedUeInfoProperties implements the ExtendedUeInfoPropertiesClassification interface for type UeInfo4G.

func (UeInfo4G) MarshalJSON 

func (u UeInfo4G) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeInfo4G.

func (*UeInfo4G) UnmarshalJSON 

func (u *UeInfo4G) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeInfo4G.

type UeInfo4GProperties 

type UeInfo4GProperties struct {
	// REQUIRED; Globally Unique Temporary Identifier (4G)
	Guti *Guti4G

	// REQUIRED; International mobile subscriber identifier
	Imsi *string

	// UE Connection Info for 4G
	ConnectionInfo *UeConnectionInfo4G

	// International mobile equipment identity
	Imei *string

	// International mobile equipment identity – software version
	Imeisv      *string
	SessionInfo []*UeSessionInfo4G
}

UeInfo4GProperties - UE Information properties for 4G.

func (UeInfo4GProperties) MarshalJSON 

func (u UeInfo4GProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeInfo4GProperties.

func (*UeInfo4GProperties) UnmarshalJSON 

func (u *UeInfo4GProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeInfo4GProperties.

type UeInfo5G 

type UeInfo5G struct {
	// REQUIRED; UE Information properties for 5G.
	Info *UeInfo5GProperties

	// REQUIRED; RAT Type
	RatType *RatType

	// The timestamp of last UE info read from the packet core (UTC).
	LastReadAt *time.Time
}

UeInfo5G - UE Information for 5G.

func (*UeInfo5G) GetExtendedUeInfoProperties 

func (u *UeInfo5G) GetExtendedUeInfoProperties() *ExtendedUeInfoProperties

GetExtendedUeInfoProperties implements the ExtendedUeInfoPropertiesClassification interface for type UeInfo5G.

func (UeInfo5G) MarshalJSON 

func (u UeInfo5G) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeInfo5G.

func (*UeInfo5G) UnmarshalJSON 

func (u *UeInfo5G) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeInfo5G.

type UeInfo5GProperties 

type UeInfo5GProperties struct {
	// REQUIRED; 5G GUTI
	FivegGuti *Guti5G

	// REQUIRED; Subscription Permanent Identifier
	Supi *string

	// UE Connection Info for 5G.
	ConnectionInfo *UeConnectionInfo5G

	// Permanent Equipment Identifier
	Pei         *string
	SessionInfo []*UeSessionInfo5G
}

UeInfo5GProperties - UE Information properties for 5G.

func (UeInfo5GProperties) MarshalJSON 

func (u UeInfo5GProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeInfo5GProperties.

func (*UeInfo5GProperties) UnmarshalJSON 

func (u *UeInfo5GProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeInfo5GProperties.

type UeInfoList 

type UeInfoList struct {
	// A list of UEs in a packet core and their basic information.
	Value []*UeInfo

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

UeInfoList - Response for packet core list UEs API call.

func (UeInfoList) MarshalJSON 

func (u UeInfoList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeInfoList.

func (*UeInfoList) UnmarshalJSON 

func (u *UeInfoList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeInfoList.

type UeInfoPropertiesFormat 

type UeInfoPropertiesFormat struct {
	// REQUIRED; RAT Type
	RatType *RatType

	// REQUIRED; State of the UE.
	UeState *UeState

	// The timestamp of last list UEs call to the packet core (UTC).
	LastReadAt    *time.Time
	UeIPAddresses []*DnnIPPair
}

UeInfoPropertiesFormat - Basic UE Information Properties.

func (UeInfoPropertiesFormat) MarshalJSON 

func (u UeInfoPropertiesFormat) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeInfoPropertiesFormat.

func (*UeInfoPropertiesFormat) UnmarshalJSON 

func (u *UeInfoPropertiesFormat) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeInfoPropertiesFormat.

type UeInformationClient 

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

UeInformationClient contains the methods for the UeInformation group. Don't use this type directly, use NewUeInformationClient() instead.

func NewUeInformationClient 

func NewUeInformationClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*UeInformationClient, error)

NewUeInformationClient creates a new instance of UeInformationClient with the specified values.

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

func (*UeInformationClient) NewListPager 

func (client *UeInformationClient) NewListPager(resourceGroupName string, packetCoreControlPlaneName string, options *UeInformationClientListOptions) *runtime.Pager[UeInformationClientListResponse]

NewListPager - List all UEs and their state in a packet core.

Generated from API version 2024-02-01

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/mobilenetwork/resource-manager/Microsoft.MobileNetwork/stable/2024-02-01/examples/UeInfoList.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.NewUeInformationClient().NewListPager("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.UeInfoList = armmobilenetwork.UeInfoList{
	// 	Value: []*armmobilenetwork.UeInfo{
	// 		{
	// 			Name: to.Ptr("001016789123456"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlanes/ues"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/ues/001016789123456"),
	// 			Properties: &armmobilenetwork.UeInfoPropertiesFormat{
	// 				LastReadAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
	// 				RatType: to.Ptr(armmobilenetwork.RatTypeFourG),
	// 				UeIPAddresses: []*armmobilenetwork.DnnIPPair{
	// 					{
	// 						Dnn: to.Ptr("Dnn1"),
	// 						UeIPAddress: &armmobilenetwork.UeIPAddress{
	// 							IPV4Addr: to.Ptr("10.0.0.1"),
	// 						},
	// 					},
	// 					{
	// 						Dnn: to.Ptr("Dnn2"),
	// 						UeIPAddress: &armmobilenetwork.UeIPAddress{
	// 							IPV4Addr: to.Ptr("10.0.0.2"),
	// 						},
	// 				}},
	// 				UeState: to.Ptr(armmobilenetwork.UeStateConnected),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("001016789123457"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlanes/ues"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/ues/001016789123457"),
	// 			Properties: &armmobilenetwork.UeInfoPropertiesFormat{
	// 				LastReadAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
	// 				RatType: to.Ptr(armmobilenetwork.RatTypeFourG),
	// 				UeIPAddresses: []*armmobilenetwork.DnnIPPair{
	// 					{
	// 						Dnn: to.Ptr("Dnn1"),
	// 						UeIPAddress: &armmobilenetwork.UeIPAddress{
	// 							IPV4Addr: to.Ptr("10.0.0.1"),
	// 						},
	// 					},
	// 					{
	// 						Dnn: to.Ptr("Dnn2"),
	// 						UeIPAddress: &armmobilenetwork.UeIPAddress{
	// 							IPV4Addr: to.Ptr("10.0.0.2"),
	// 						},
	// 				}},
	// 				UeState: to.Ptr(armmobilenetwork.UeStateIdle),
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("001016789123458"),
	// 			Type: to.Ptr("Microsoft.MobileNetwork/packetCoreControlPlanes/ues"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.MobileNetwork/packetCoreControlPlanes/TestPacketCoreCP/ues/001016789123458"),
	// 			Properties: &armmobilenetwork.UeInfoPropertiesFormat{
	// 				LastReadAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
	// 				RatType: to.Ptr(armmobilenetwork.RatTypeFourG),
	// 				UeState: to.Ptr(armmobilenetwork.UeStateDetached),
	// 			},
	// 	}},
	// }
}

Output:

type UeInformationClientListOptions 

type UeInformationClientListOptions struct {
}

UeInformationClientListOptions contains the optional parameters for the UeInformationClient.NewListPager method.

type UeInformationClientListResponse 

type UeInformationClientListResponse struct {
	// Response for packet core list UEs API call.
	UeInfoList
}

UeInformationClientListResponse contains the response from method UeInformationClient.NewListPager.

type UeLocationInfo 

type UeLocationInfo struct {
	// REQUIRED; Location Type
	LocationType *string

	// REQUIRED; PLMN Identifier
	Plmn *PlmnID

	// REQUIRED; Type Allocation Code of UE
	Tac *string
}

UeLocationInfo - UE Location Info properties

func (UeLocationInfo) MarshalJSON 

func (u UeLocationInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeLocationInfo.

func (*UeLocationInfo) UnmarshalJSON 

func (u *UeLocationInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeLocationInfo.

type UeQOSFlow 

type UeQOSFlow struct {
	// REQUIRED; 5G QoS Identifier.
	Fiveqi *int32

	// REQUIRED; Qos Flow Identifier
	Qfi *int32

	// Guaranteed Bit Rate
	Gbr *Ambr

	// Maximum Bit Rate
	Mbr *Ambr
}

UeQOSFlow - QoS Flow

func (UeQOSFlow) MarshalJSON 

func (u UeQOSFlow) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeQOSFlow.

func (*UeQOSFlow) UnmarshalJSON 

func (u *UeQOSFlow) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeQOSFlow.

type UeSessionInfo4G 

type UeSessionInfo4G struct {
	// REQUIRED; Access point name
	Apn *string

	// REQUIRED; EPS bearer identifier
	Ebi *int32

	// REQUIRED; Packet Data Network Type
	PdnType *PdnType

	// REQUIRED; UE IP address
	UeIPAddress *UeIPAddress
}

UeSessionInfo4G - UE Session Info for 4G

func (UeSessionInfo4G) MarshalJSON 

func (u UeSessionInfo4G) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeSessionInfo4G.

func (*UeSessionInfo4G) UnmarshalJSON 

func (u *UeSessionInfo4G) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeSessionInfo4G.

type UeSessionInfo5G 

type UeSessionInfo5G struct {
	// REQUIRED; Aggregate maximum bit rate.
	Ambr *Ambr

	// REQUIRED; Data network name
	Dnn *string

	// REQUIRED; Packet Data Network Type
	PdnType *PdnType

	// REQUIRED; PDU session identifier
	PduSessionID *int32

	// REQUIRED
	QosFlow []*UeQOSFlow

	// REQUIRED; Single-network slice selection assistance information (S-NSSAI).
	Snssai *Snssai

	// REQUIRED; UE IP address
	UeIPAddress *UeIPAddress
}

UeSessionInfo5G - UE Session Info for 5G.

func (UeSessionInfo5G) MarshalJSON 

func (u UeSessionInfo5G) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UeSessionInfo5G.

func (*UeSessionInfo5G) UnmarshalJSON 

func (u *UeSessionInfo5G) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UeSessionInfo5G.

type UeState 

type UeState string

UeState - State of the UE. 

const (
	UeStateConnected    UeState = "Connected"
	UeStateDeregistered UeState = "Deregistered"
	UeStateDetached     UeState = "Detached"
	UeStateIdle         UeState = "Idle"
	UeStateUnknown      UeState = "Unknown"
)

func PossibleUeStateValues 

func PossibleUeStateValues() []UeState

PossibleUeStateValues returns the possible values for the UeState const type.

type UeUsageSetting 

type UeUsageSetting string

UeUsageSetting - The UE's usage setting 

const (
	UeUsageSettingDataCentric  UeUsageSetting = "DataCentric"
	UeUsageSettingVoiceCentric UeUsageSetting = "VoiceCentric"
)

func PossibleUeUsageSettingValues 

func PossibleUeUsageSettingValues() []UeUsageSetting

PossibleUeUsageSettingValues returns the possible values for the UeUsageSetting 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

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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