armprogrammableconnectivity

package module
v0.1.0 Latest Latest
Warning

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

 Go to latest Published: May 20, 2025 License: MIT Imports: 15 Imported by: 0

README

Azure Programmable Connectivity Module for Go

The armprogrammableconnectivity module provides operations for working with Azure Programmable Connectivity.

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 Programmable Connectivity module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/programmableconnectivity/armprogrammableconnectivity

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Programmable Connectivity. 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 Programmable Connectivity 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 := armprogrammableconnectivity.NewClientFactory(<subscriptionID>, 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 := armprogrammableconnectivity.NewClientFactory(<subscriptionID>, 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.NewGatewaysClient()

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 Programmableconnectivity 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 AccountType 

type AccountType string

AccountType - The Account Type of the Operator API Connections. 

const (
	// AccountTypeAzureManaged - Managed by Azure on-behalf-of the user.
	AccountTypeAzureManaged AccountType = "AzureManaged"
	// AccountTypeUserManaged - Managed by the User themselves on the Operator end.
	AccountTypeUserManaged AccountType = "UserManaged"
)

func PossibleAccountTypeValues 

func PossibleAccountTypeValues() []AccountType

PossibleAccountTypeValues returns the possible values for the AccountType const type.

type ActionType 

type ActionType string

ActionType - Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. 

const (
	// ActionTypeInternal - Actions are for internal-only APIs.
	ActionTypeInternal ActionType = "Internal"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type ApplicationProperties 

type ApplicationProperties struct {
	// Description of the application.
	ApplicationDescription *string

	// The category that describes the application.
	ApplicationType *string

	// Legal name of the organization owning the application.
	LegalName *string

	// Name of the application. Example: Contoso App.
	Name *string

	// A description of the organization owning the application.
	OrganizationDescription *string

	// Email address of the Privacy contact or Data Protection officer of the organization.
	PrivacyContactEmailAddress *string

	// Unique Tax Number for the user's organization in the country/region the APC Gateway is being purchased.
	TaxNumber *string
}

ApplicationProperties - Details about the Application that would use the Operator's Network APIs.

func (ApplicationProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ApplicationProperties.

func (*ApplicationProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationProperties.

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

func (c *ClientFactory) NewGatewaysClient() *GatewaysClient

NewGatewaysClient creates a new instance of GatewaysClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewOperatorAPIConnectionsClient 

func (c *ClientFactory) NewOperatorAPIConnectionsClient() *OperatorAPIConnectionsClient

NewOperatorAPIConnectionsClient creates a new instance of OperatorAPIConnectionsClient.

func (*ClientFactory) NewOperatorAPIPlansClient 

func (c *ClientFactory) NewOperatorAPIPlansClient() *OperatorAPIPlansClient

NewOperatorAPIPlansClient creates a new instance of OperatorAPIPlansClient.

type CreatedByType 

type CreatedByType string

CreatedByType - The kind of entity that created the resource. 

const (
	// CreatedByTypeApplication - The entity was created by an application.
	CreatedByTypeApplication CreatedByType = "Application"
	// CreatedByTypeKey - The entity was created by a key.
	CreatedByTypeKey CreatedByType = "Key"
	// CreatedByTypeManagedIdentity - The entity was created by a managed identity.
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	// CreatedByTypeUser - The entity was created by a user.
	CreatedByTypeUser CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type Gateway 

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

	// The resource-specific properties for this resource.
	Properties *GatewayProperties

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

	// READ-ONLY; Azure Programmable Connectivity Gateway Name
	Name *string

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *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
}

Gateway - A Programmable Connectivity Gateway resource

func (Gateway) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Gateway.

func (*Gateway) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Gateway.

type GatewayListResult 

type GatewayListResult struct {
	// REQUIRED; The Gateway items on this page
	Value []*Gateway

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

GatewayListResult - The response of a Gateway list operation.

func (GatewayListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type GatewayListResult.

func (*GatewayListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type GatewayListResult.

type GatewayProperties 

type GatewayProperties struct {
	// READ-ONLY; Base URL of the Gateway resource. This is the URL that the users would use to make Open API Gateway requests
	// to the Operators via Azure.
	GatewayBaseURL *string

	// READ-ONLY; List of Operator API Connections selected by the user
	OperatorAPIConnections []*string

	// READ-ONLY; The status of the last operation on the Gateway resource.
	ProvisioningState *ProvisioningState
}

GatewayProperties - Gateway resource properties

func (GatewayProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type GatewayProperties.

func (*GatewayProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type GatewayProperties.

type GatewayTagsUpdate 

type GatewayTagsUpdate struct {
	// Resource tags.
	Tags map[string]*string
}

GatewayTagsUpdate - The type used for updating tags in Gateway resources.

func (GatewayTagsUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type GatewayTagsUpdate.

func (*GatewayTagsUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type GatewayTagsUpdate.

type GatewaysClient 

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

GatewaysClient contains the methods for the Gateways group. Don't use this type directly, use NewGatewaysClient() instead.

func NewGatewaysClient 

func NewGatewaysClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*GatewaysClient, error)

NewGatewaysClient creates a new instance of GatewaysClient 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 (*GatewaysClient) BeginCreateOrUpdate 

func (client *GatewaysClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, gatewayName string, resource Gateway, options *GatewaysClientBeginCreateOrUpdateOptions) (*runtime.Poller[GatewaysClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or update an APC Gateway. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-01-15-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • gatewayName - Azure Programmable Connectivity Gateway Name
  • resource - Resource create parameters.
  • options - GatewaysClientBeginCreateOrUpdateOptions contains the optional parameters for the GatewaysClient.BeginCreateOrUpdate method.
Example

Generated from example definition: 2024-01-15-preview/Gateways_CreateOrUpdate_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/programmableconnectivity/armprogrammableconnectivity"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewGatewaysClient().BeginCreateOrUpdate(ctx, "rgopenapi", "pgzk", armprogrammableconnectivity.Gateway{
		Properties: &armprogrammableconnectivity.GatewayProperties{},
		Tags: map[string]*string{
			"key2642": to.Ptr("ykmlftvwwpvcmriffxqh"),
		},
		Location: to.Ptr("oryhozfmeohscezl"),
	}, 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 = armprogrammableconnectivity.GatewaysClientCreateOrUpdateResponse{
	// 	Gateway: &armprogrammableconnectivity.Gateway{
	// 		Properties: &armprogrammableconnectivity.GatewayProperties{
	// 			OperatorAPIConnections: []*string{
	// 				to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/operatorApiConnections/uecwablqeufseigocrwf"),
	// 			},
	// 			GatewayBaseURL: to.Ptr("gfohvglkp"),
	// 			ProvisioningState: to.Ptr(armprogrammableconnectivity.ProvisioningStateSucceeded),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key2642": to.Ptr("ykmlftvwwpvcmriffxqh"),
	// 		},
	// 		Location: to.Ptr("oryhozfmeohscezl"),
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/gateways/cdvcixxcdhjqw"),
	// 		Name: to.Ptr("qwlnmndshgfrtkp"),
	// 		Type: to.Ptr("qqkelyjugwyforzd"),
	// 		SystemData: &armprogrammableconnectivity.SystemData{
	// 			CreatedBy: to.Ptr("kuprrapuolhnvju"),
	// 			CreatedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("lsmrhxnvkpmrxncylgqpkr"),
	// 			LastModifiedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*GatewaysClient) BeginDelete 

func (client *GatewaysClient) BeginDelete(ctx context.Context, resourceGroupName string, gatewayName string, options *GatewaysClientBeginDeleteOptions) (*runtime.Poller[GatewaysClientDeleteResponse], error)

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

Generated from API version 2024-01-15-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • gatewayName - Azure Programmable Connectivity Gateway Name
  • options - GatewaysClientBeginDeleteOptions contains the optional parameters for the GatewaysClient.BeginDelete method.
Example

Generated from example definition: 2024-01-15-preview/Gateways_Delete_MinimumSet_Gen.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewGatewaysClient().BeginDelete(ctx, "rgopenapi", "udveaau", 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)
	}
}

func (*GatewaysClient) Get 

func (client *GatewaysClient) Get(ctx context.Context, resourceGroupName string, gatewayName string, options *GatewaysClientGetOptions) (GatewaysClientGetResponse, error)

Get - Get a Gateway resource by name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-01-15-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • gatewayName - Azure Programmable Connectivity Gateway Name
  • options - GatewaysClientGetOptions contains the optional parameters for the GatewaysClient.Get method.
Example

Generated from example definition: 2024-01-15-preview/Gateways_Get_MaximumSet_Gen.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewGatewaysClient().Get(ctx, "rgopenapi", "kdgpdkrucfphqtgafao", 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 = armprogrammableconnectivity.GatewaysClientGetResponse{
	// 	Gateway: &armprogrammableconnectivity.Gateway{
	// 		Properties: &armprogrammableconnectivity.GatewayProperties{
	// 			OperatorAPIConnections: []*string{
	// 				to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/operatorApiConnections/uecwablqeufseigocrwf"),
	// 			},
	// 			GatewayBaseURL: to.Ptr("gfohvglkp"),
	// 			ProvisioningState: to.Ptr(armprogrammableconnectivity.ProvisioningStateSucceeded),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key2642": to.Ptr("ykmlftvwwpvcmriffxqh"),
	// 		},
	// 		Location: to.Ptr("oryhozfmeohscezl"),
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/gateways/cdvcixxcdhjqw"),
	// 		Name: to.Ptr("qwlnmndshgfrtkp"),
	// 		Type: to.Ptr("qqkelyjugwyforzd"),
	// 		SystemData: &armprogrammableconnectivity.SystemData{
	// 			CreatedBy: to.Ptr("kuprrapuolhnvju"),
	// 			CreatedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("lsmrhxnvkpmrxncylgqpkr"),
	// 			LastModifiedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*GatewaysClient) NewListByResourceGroupPager 

func (client *GatewaysClient) NewListByResourceGroupPager(resourceGroupName string, options *GatewaysClientListByResourceGroupOptions) *runtime.Pager[GatewaysClientListByResourceGroupResponse]

NewListByResourceGroupPager - List Gateway resources by resource group.

Generated from API version 2024-01-15-preview

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

Generated from example definition: 2024-01-15-preview/Gateways_ListByResourceGroup_MaximumSet_Gen.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewGatewaysClient().NewListByResourceGroupPager("rgopenapi", 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 = armprogrammableconnectivity.GatewaysClientListByResourceGroupResponse{
		// 	GatewayListResult: armprogrammableconnectivity.GatewayListResult{
		// 		Value: []*armprogrammableconnectivity.Gateway{
		// 			{
		// 				Properties: &armprogrammableconnectivity.GatewayProperties{
		// 					OperatorAPIConnections: []*string{
		// 						to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/operatorApiConnections/uecwablqeufseigocrwf"),
		// 					},
		// 					GatewayBaseURL: to.Ptr("gfohvglkp"),
		// 					ProvisioningState: to.Ptr(armprogrammableconnectivity.ProvisioningStateSucceeded),
		// 				},
		// 				Tags: map[string]*string{
		// 					"key2642": to.Ptr("ykmlftvwwpvcmriffxqh"),
		// 				},
		// 				Location: to.Ptr("oryhozfmeohscezl"),
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/gateways/cdvcixxcdhjqw"),
		// 				Name: to.Ptr("qwlnmndshgfrtkp"),
		// 				Type: to.Ptr("qqkelyjugwyforzd"),
		// 				SystemData: &armprogrammableconnectivity.SystemData{
		// 					CreatedBy: to.Ptr("kuprrapuolhnvju"),
		// 					CreatedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("lsmrhxnvkpmrxncylgqpkr"),
		// 					LastModifiedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

func (*GatewaysClient) NewListBySubscriptionPager 

func (client *GatewaysClient) NewListBySubscriptionPager(options *GatewaysClientListBySubscriptionOptions) *runtime.Pager[GatewaysClientListBySubscriptionResponse]

NewListBySubscriptionPager - List Gateway resources by subscription ID.

Generated from API version 2024-01-15-preview

  • options - GatewaysClientListBySubscriptionOptions contains the optional parameters for the GatewaysClient.NewListBySubscriptionPager method.
Example

Generated from example definition: 2024-01-15-preview/Gateways_ListBySubscription_MaximumSet_Gen.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewGatewaysClient().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 = armprogrammableconnectivity.GatewaysClientListBySubscriptionResponse{
		// 	GatewayListResult: armprogrammableconnectivity.GatewayListResult{
		// 		Value: []*armprogrammableconnectivity.Gateway{
		// 			{
		// 				Properties: &armprogrammableconnectivity.GatewayProperties{
		// 					OperatorAPIConnections: []*string{
		// 						to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/operatorApiConnections/uecwablqeufseigocrwf"),
		// 					},
		// 					GatewayBaseURL: to.Ptr("gfohvglkp"),
		// 					ProvisioningState: to.Ptr(armprogrammableconnectivity.ProvisioningStateSucceeded),
		// 				},
		// 				Tags: map[string]*string{
		// 					"key2642": to.Ptr("ykmlftvwwpvcmriffxqh"),
		// 				},
		// 				Location: to.Ptr("oryhozfmeohscezl"),
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/gateways/cdvcixxcdhjqw"),
		// 				Name: to.Ptr("qwlnmndshgfrtkp"),
		// 				Type: to.Ptr("qqkelyjugwyforzd"),
		// 				SystemData: &armprogrammableconnectivity.SystemData{
		// 					CreatedBy: to.Ptr("kuprrapuolhnvju"),
		// 					CreatedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("lsmrhxnvkpmrxncylgqpkr"),
		// 					LastModifiedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

func (*GatewaysClient) Update 

func (client *GatewaysClient) Update(ctx context.Context, resourceGroupName string, gatewayName string, properties GatewayTagsUpdate, options *GatewaysClientUpdateOptions) (GatewaysClientUpdateResponse, error)

Update - Update Gateway tags. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-01-15-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • gatewayName - Azure Programmable Connectivity Gateway Name
  • properties - The resource properties to be updated.
  • options - GatewaysClientUpdateOptions contains the optional parameters for the GatewaysClient.Update method.
Example

Generated from example definition: 2024-01-15-preview/Gateways_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/programmableconnectivity/armprogrammableconnectivity"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewGatewaysClient().Update(ctx, "rgopenapi", "pgzk", armprogrammableconnectivity.GatewayTagsUpdate{
		Tags: map[string]*string{
			"key2642": to.Ptr("ykmlftvwwpvcmriffxqh"),
		},
	}, 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 = armprogrammableconnectivity.GatewaysClientUpdateResponse{
	// 	Gateway: &armprogrammableconnectivity.Gateway{
	// 		Properties: &armprogrammableconnectivity.GatewayProperties{
	// 			OperatorAPIConnections: []*string{
	// 				to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/operatorApiConnections/uecwablqeufseigocrwf"),
	// 			},
	// 			GatewayBaseURL: to.Ptr("gfohvglkp"),
	// 			ProvisioningState: to.Ptr(armprogrammableconnectivity.ProvisioningStateSucceeded),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key2642": to.Ptr("ykmlftvwwpvcmriffxqh"),
	// 		},
	// 		Location: to.Ptr("oryhozfmeohscezl"),
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/gateways/cdvcixxcdhjqw"),
	// 		Name: to.Ptr("qwlnmndshgfrtkp"),
	// 		Type: to.Ptr("qqkelyjugwyforzd"),
	// 		SystemData: &armprogrammableconnectivity.SystemData{
	// 			CreatedBy: to.Ptr("kuprrapuolhnvju"),
	// 			CreatedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("lsmrhxnvkpmrxncylgqpkr"),
	// 			LastModifiedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 		},
	// 	},
	// }
}

type GatewaysClientBeginCreateOrUpdateOptions 

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

GatewaysClientBeginCreateOrUpdateOptions contains the optional parameters for the GatewaysClient.BeginCreateOrUpdate method.

type GatewaysClientBeginDeleteOptions 

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

GatewaysClientBeginDeleteOptions contains the optional parameters for the GatewaysClient.BeginDelete method.

type GatewaysClientCreateOrUpdateResponse 

type GatewaysClientCreateOrUpdateResponse struct {
	// A Programmable Connectivity Gateway resource
	Gateway
}

GatewaysClientCreateOrUpdateResponse contains the response from method GatewaysClient.BeginCreateOrUpdate.

type GatewaysClientDeleteResponse 

type GatewaysClientDeleteResponse struct {
}

GatewaysClientDeleteResponse contains the response from method GatewaysClient.BeginDelete.

type GatewaysClientGetOptions 

type GatewaysClientGetOptions struct {
}

GatewaysClientGetOptions contains the optional parameters for the GatewaysClient.Get method.

type GatewaysClientGetResponse 

type GatewaysClientGetResponse struct {
	// A Programmable Connectivity Gateway resource
	Gateway
}

GatewaysClientGetResponse contains the response from method GatewaysClient.Get.

type GatewaysClientListByResourceGroupOptions 

type GatewaysClientListByResourceGroupOptions struct {
}

GatewaysClientListByResourceGroupOptions contains the optional parameters for the GatewaysClient.NewListByResourceGroupPager method.

type GatewaysClientListByResourceGroupResponse 

type GatewaysClientListByResourceGroupResponse struct {
	// The response of a Gateway list operation.
	GatewayListResult
}

GatewaysClientListByResourceGroupResponse contains the response from method GatewaysClient.NewListByResourceGroupPager.

type GatewaysClientListBySubscriptionOptions 

type GatewaysClientListBySubscriptionOptions struct {
}

GatewaysClientListBySubscriptionOptions contains the optional parameters for the GatewaysClient.NewListBySubscriptionPager method.

type GatewaysClientListBySubscriptionResponse 

type GatewaysClientListBySubscriptionResponse struct {
	// The response of a Gateway list operation.
	GatewayListResult
}

GatewaysClientListBySubscriptionResponse contains the response from method GatewaysClient.NewListBySubscriptionPager.

type GatewaysClientUpdateOptions 

type GatewaysClientUpdateOptions struct {
}

GatewaysClientUpdateOptions contains the optional parameters for the GatewaysClient.Update method.

type GatewaysClientUpdateResponse 

type GatewaysClientUpdateResponse struct {
	// A Programmable Connectivity Gateway resource
	Gateway
}

GatewaysClientUpdateResponse contains the response from method GatewaysClient.Update.

type MarketplaceProperties 

type MarketplaceProperties struct {
	// Azure marketplace Legacy Offer ID for this plan. This is used to fetch the details of the plan from the Azure marketplace.
	LegacyOfferID *string

	// Azure marketplace Offer ID for this plan.
	OfferID *string

	// Azure marketplace Plan ID for this plan.
	PlanID *string

	// Azure marketplace Publisher ID for this plan.
	PublisherID *string

	// Azure marketplace Term ID for this plan.
	TermID *string
}

MarketplaceProperties - Azure marketplace properties for a plan.

func (MarketplaceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type MarketplaceProperties.

func (*MarketplaceProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MarketplaceProperties.

type Operation 

type Operation struct {
	// Localized display information for this particular operation.
	Display *OperationDisplay

	// READ-ONLY; Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
	ActionType *ActionType

	// READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for Azure
	// Resource Manager/control-plane operations.
	IsDataAction *bool

	// READ-ONLY; The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write",
	// "Microsoft.Compute/virtualMachines/capture/action"
	Name *string

	// READ-ONLY; The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default
	// value is "user,system"
	Origin *Origin
}

Operation - Details of a REST API operation, returned from the Resource Provider Operations API

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 {
	// READ-ONLY; The short, localized friendly description of the operation; suitable for tool tips and detailed views.
	Description *string

	// READ-ONLY; The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual
	// Machine", "Restart Virtual Machine".
	Operation *string

	// READ-ONLY; The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft
	// Compute".
	Provider *string

	// READ-ONLY; The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job
	// Schedule Collections".
	Resource *string
}

OperationDisplay - Localized display information for and 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 OperationListResult 

type OperationListResult struct {
	// REQUIRED; The Operation items on this page
	Value []*Operation

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

OperationListResult - A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.

func (OperationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

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 - List the operations for the provider

Generated from API version 2024-01-15-preview

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

Generated from example definition: 2024-01-15-preview/Operations_List_MaximumSet_Gen.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("<subscriptionID>", 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 = armprogrammableconnectivity.OperationsClientListResponse{
		// 	OperationListResult: armprogrammableconnectivity.OperationListResult{
		// 		Value: []*armprogrammableconnectivity.Operation{
		// 			{
		// 				Name: to.Ptr("bxcouxawr"),
		// 				IsDataAction: to.Ptr(true),
		// 				Display: &armprogrammableconnectivity.OperationDisplay{
		// 					Provider: to.Ptr("carpnaflwqhmhzoxxc"),
		// 					Resource: to.Ptr("dezrphicaznvl"),
		// 					Operation: to.Ptr("pps"),
		// 					Description: to.Ptr("vndzeookxtho"),
		// 				},
		// 				Origin: to.Ptr(armprogrammableconnectivity.OriginUser),
		// 				ActionType: to.Ptr(armprogrammableconnectivity.ActionTypeInternal),
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type OperatorAPIConnection 

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

	// The resource-specific properties for this resource.
	Properties *OperatorAPIConnectionProperties

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

	// READ-ONLY; Azure Programmable Connectivity (APC) Operator API Connection Name.
	Name *string

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *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
}

OperatorAPIConnection - A Programmable Connectivity Operator API Connection resource

func (OperatorAPIConnection) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperatorAPIConnection.

func (*OperatorAPIConnection) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperatorAPIConnection.

type OperatorAPIConnectionListResult 

type OperatorAPIConnectionListResult struct {
	// REQUIRED; The OperatorApiConnection items on this page
	Value []*OperatorAPIConnection

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

OperatorAPIConnectionListResult - The response of a OperatorApiConnection list operation.

func (OperatorAPIConnectionListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperatorAPIConnectionListResult.

func (*OperatorAPIConnectionListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperatorAPIConnectionListResult.

type OperatorAPIConnectionProperties 

type OperatorAPIConnectionProperties struct {
	// REQUIRED; Type of the account the user has with the Operator's Network API infrastructure. AzureManaged | UserManaged.
	AccountType *AccountType

	// REQUIRED; Reference to the APC Gateway resource ID.
	GatewayID *string

	// REQUIRED; Reference to the Operator API Plan Resource ID.
	OperatorAPIPlanID *string

	// Application ID of the App Developer that is registered with the Operator in a specific country/region.
	AppID *string

	// Application secret linked to the 'appId'. This should be stored securely and is not returned back when the resource information
	// is read.
	AppSecret *string

	// Details about the Application that would use the Operator's Network APIs.
	ConfiguredApplication *ApplicationProperties

	// Details about the SaaS offer purchased from the marketplace.
	SaasProperties *SaasProperties

	// READ-ONLY; The Network API for the current operator in the country/region provided in the linked Operator API Plan.
	CamaraAPIName *string

	// READ-ONLY; Name of the Operator in the linked Operator API Plan belongs to.
	OperatorName *string

	// READ-ONLY; The status of the last operation.
	ProvisioningState *ProvisioningState

	// READ-ONLY; The status of the OperatorApiConnection resource.
	Status *Status
}

OperatorAPIConnectionProperties - Operator API Connection resource properties that cannot be updated once a resource has been created.

func (OperatorAPIConnectionProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperatorAPIConnectionProperties.

func (*OperatorAPIConnectionProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperatorAPIConnectionProperties.

type OperatorAPIConnectionUpdate 

type OperatorAPIConnectionUpdate struct {
	// The resource-specific properties for this resource.
	Properties *OperatorAPIConnectionUpdateProperties

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

OperatorAPIConnectionUpdate - The type used for update operations of the OperatorApiConnection.

func (OperatorAPIConnectionUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperatorAPIConnectionUpdate.

func (*OperatorAPIConnectionUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperatorAPIConnectionUpdate.

type OperatorAPIConnectionUpdateProperties 

type OperatorAPIConnectionUpdateProperties struct {
	// Application ID of the App Developer that is registered with the Operator in a specific country/region.
	AppID *string

	// Application secret linked to the 'appId'. This should be stored securely and is not returned back when the resource information
	// is read.
	AppSecret *string

	// Details about the Application that would use the Operator's Network APIs.
	ConfiguredApplication *ApplicationProperties

	// Reference to the Operator API Plan Resource ID.
	OperatorAPIPlanID *string

	// Details about the SaaS offer purchased from the marketplace.
	SaasProperties *SaasProperties
}

OperatorAPIConnectionUpdateProperties - The updatable properties of the OperatorApiConnection.

func (OperatorAPIConnectionUpdateProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperatorAPIConnectionUpdateProperties.

func (*OperatorAPIConnectionUpdateProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperatorAPIConnectionUpdateProperties.

type OperatorAPIConnectionsClient 

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

OperatorAPIConnectionsClient contains the methods for the OperatorAPIConnections group. Don't use this type directly, use NewOperatorAPIConnectionsClient() instead.

func NewOperatorAPIConnectionsClient 

func NewOperatorAPIConnectionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*OperatorAPIConnectionsClient, error)

NewOperatorAPIConnectionsClient creates a new instance of OperatorAPIConnectionsClient 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 (*OperatorAPIConnectionsClient) BeginCreate 

func (client *OperatorAPIConnectionsClient) BeginCreate(ctx context.Context, resourceGroupName string, operatorAPIConnectionName string, resource OperatorAPIConnection, options *OperatorAPIConnectionsClientBeginCreateOptions) (*runtime.Poller[OperatorAPIConnectionsClientCreateResponse], error)

BeginCreate - Create an Operator API Connection. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-01-15-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • operatorAPIConnectionName - Azure Programmable Connectivity (APC) Operator API Connection Name.
  • resource - Resource create parameters.
  • options - OperatorAPIConnectionsClientBeginCreateOptions contains the optional parameters for the OperatorAPIConnectionsClient.BeginCreate method.
Example

Generated from example definition: 2024-01-15-preview/OperatorApiConnections_Create_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/programmableconnectivity/armprogrammableconnectivity"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewOperatorAPIConnectionsClient().BeginCreate(ctx, "rgopenapi", "nzsdg", armprogrammableconnectivity.OperatorAPIConnection{
		Properties: &armprogrammableconnectivity.OperatorAPIConnectionProperties{
			OperatorAPIPlanID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/providers/Microsoft.ProgrammableConnectivity/operatorApiPlans/livmzrh"),
			SaasProperties: &armprogrammableconnectivity.SaasProperties{
				SaasSubscriptionID: to.Ptr("mgyusmqt"),
				SaasResourceID:     to.Ptr("pekejefyvfviabimdrmno"),
			},
			ConfiguredApplication: &armprogrammableconnectivity.ApplicationProperties{
				Name:                       to.Ptr("idzqqen"),
				ApplicationDescription:     to.Ptr("gjlwegnqvffvsc"),
				ApplicationType:            to.Ptr("f"),
				LegalName:                  to.Ptr("ar"),
				OrganizationDescription:    to.Ptr("fcueqzlxxr"),
				TaxNumber:                  to.Ptr("ngzv"),
				PrivacyContactEmailAddress: to.Ptr("l"),
			},
			AppID:       to.Ptr("czgrhbvgr"),
			GatewayID:   to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/gateways/cdvcixxcdhjqw"),
			AccountType: to.Ptr(armprogrammableconnectivity.AccountTypeAzureManaged),
			AppSecret:   to.Ptr("wtxnpes"),
			Status: &armprogrammableconnectivity.Status{
				State:  to.Ptr("rvez"),
				Reason: to.Ptr("fpteanxqzqixfmymib"),
			},
		},
		Tags: map[string]*string{
			"key5536": to.Ptr("bjhvpzsmtalqxmjjbsfdizhg"),
		},
		Location: to.Ptr("dwvzfkjoepbmksygazllqryyinn"),
	}, 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 = armprogrammableconnectivity.OperatorAPIConnectionsClientCreateResponse{
	// 	OperatorAPIConnection: &armprogrammableconnectivity.OperatorAPIConnection{
	// 		Properties: &armprogrammableconnectivity.OperatorAPIConnectionProperties{
	// 			OperatorAPIPlanID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/providers/Microsoft.ProgrammableConnectivity/operatorApiPlans/livmzrh"),
	// 			SaasProperties: &armprogrammableconnectivity.SaasProperties{
	// 				SaasSubscriptionID: to.Ptr("mgyusmqt"),
	// 				SaasResourceID: to.Ptr("pekejefyvfviabimdrmno"),
	// 			},
	// 			ConfiguredApplication: &armprogrammableconnectivity.ApplicationProperties{
	// 				Name: to.Ptr("idzqqen"),
	// 				ApplicationDescription: to.Ptr("gjlwegnqvffvsc"),
	// 				ApplicationType: to.Ptr("f"),
	// 				LegalName: to.Ptr("ar"),
	// 				OrganizationDescription: to.Ptr("fcueqzlxxr"),
	// 				TaxNumber: to.Ptr("ngzv"),
	// 				PrivacyContactEmailAddress: to.Ptr("l"),
	// 			},
	// 			AppID: to.Ptr("czgrhbvgr"),
	// 			GatewayID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/gateways/cdvcixxcdhjqw"),
	// 			AccountType: to.Ptr(armprogrammableconnectivity.AccountTypeAzureManaged),
	// 			OperatorName: to.Ptr("tjisxmigbgtejdnelabhc"),
	// 			CamaraAPIName: to.Ptr("lnktvqbqcdzmkubxwblwvgwifp"),
	// 			ProvisioningState: to.Ptr(armprogrammableconnectivity.ProvisioningStateSucceeded),
	// 			Status: &armprogrammableconnectivity.Status{
	// 				State: to.Ptr("rvez"),
	// 				Reason: to.Ptr("fpteanxqzqixfmymib"),
	// 			},
	// 		},
	// 		Tags: map[string]*string{
	// 			"key5536": to.Ptr("bjhvpzsmtalqxmjjbsfdizhg"),
	// 		},
	// 		Location: to.Ptr("dwvzfkjoepbmksygazllqryyinn"),
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/operatorApiConnections/uecwablqeufseigocrwf"),
	// 		Name: to.Ptr("zsilgtpflhroamaglfbywbn"),
	// 		Type: to.Ptr("stxhhdjwawmqtep"),
	// 		SystemData: &armprogrammableconnectivity.SystemData{
	// 			CreatedBy: to.Ptr("kuprrapuolhnvju"),
	// 			CreatedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("lsmrhxnvkpmrxncylgqpkr"),
	// 			LastModifiedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*OperatorAPIConnectionsClient) BeginDelete 

func (client *OperatorAPIConnectionsClient) BeginDelete(ctx context.Context, resourceGroupName string, operatorAPIConnectionName string, options *OperatorAPIConnectionsClientBeginDeleteOptions) (*runtime.Poller[OperatorAPIConnectionsClientDeleteResponse], error)

BeginDelete - Delete an Operator API Connection. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-01-15-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • operatorAPIConnectionName - Azure Programmable Connectivity (APC) Operator API Connection Name.
  • options - OperatorAPIConnectionsClientBeginDeleteOptions contains the optional parameters for the OperatorAPIConnectionsClient.BeginDelete method.
Example

Generated from example definition: 2024-01-15-preview/OperatorApiConnections_Delete_MinimumSet_Gen.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewOperatorAPIConnectionsClient().BeginDelete(ctx, "rgopenapi", "dawr", 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)
	}
}

func (*OperatorAPIConnectionsClient) BeginUpdate 

func (client *OperatorAPIConnectionsClient) BeginUpdate(ctx context.Context, resourceGroupName string, operatorAPIConnectionName string, properties OperatorAPIConnectionUpdate, options *OperatorAPIConnectionsClientBeginUpdateOptions) (*runtime.Poller[OperatorAPIConnectionsClientUpdateResponse], error)

BeginUpdate - Update an Operator API Connection. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-01-15-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • operatorAPIConnectionName - Azure Programmable Connectivity (APC) Operator API Connection Name.
  • properties - The resource properties to be updated.
  • options - OperatorAPIConnectionsClientBeginUpdateOptions contains the optional parameters for the OperatorAPIConnectionsClient.BeginUpdate method.
Example

Generated from example definition: 2024-01-15-preview/OperatorApiConnections_Update_MaximumSet_Gen.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/programmableconnectivity/armprogrammableconnectivity"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewOperatorAPIConnectionsClient().BeginUpdate(ctx, "rgopenapi", "syefewgf", armprogrammableconnectivity.OperatorAPIConnectionUpdate{
		Tags: map[string]*string{
			"key3150": to.Ptr("sfcwbiogxulvyyvvqkumfxhussk"),
		},
		Properties: &armprogrammableconnectivity.OperatorAPIConnectionUpdateProperties{
			OperatorAPIPlanID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/providers/Microsoft.ProgrammableConnectivity/operatorApiPlans/yhlygxdwvrzgazbfzyz"),
			SaasProperties: &armprogrammableconnectivity.SaasProperties{
				SaasSubscriptionID: to.Ptr("mgyusmqt"),
				SaasResourceID:     to.Ptr("pekejefyvfviabimdrmno"),
			},
			ConfiguredApplication: &armprogrammableconnectivity.ApplicationProperties{
				Name:                       to.Ptr("idzqqen"),
				ApplicationDescription:     to.Ptr("gjlwegnqvffvsc"),
				ApplicationType:            to.Ptr("f"),
				LegalName:                  to.Ptr("ar"),
				OrganizationDescription:    to.Ptr("fcueqzlxxr"),
				TaxNumber:                  to.Ptr("ngzv"),
				PrivacyContactEmailAddress: to.Ptr("l"),
			},
			AppID:     to.Ptr("mkfcrn"),
			AppSecret: to.Ptr("wtxnpes"),
		},
	}, 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 = armprogrammableconnectivity.OperatorAPIConnectionsClientUpdateResponse{
	// 	OperatorAPIConnection: &armprogrammableconnectivity.OperatorAPIConnection{
	// 		Properties: &armprogrammableconnectivity.OperatorAPIConnectionProperties{
	// 			OperatorAPIPlanID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/providers/Microsoft.ProgrammableConnectivity/operatorApiPlans/yhlygxdwvrzgazbfzyz"),
	// 			SaasProperties: &armprogrammableconnectivity.SaasProperties{
	// 				SaasSubscriptionID: to.Ptr("mgyusmqt"),
	// 				SaasResourceID: to.Ptr("pekejefyvfviabimdrmno"),
	// 			},
	// 			ConfiguredApplication: &armprogrammableconnectivity.ApplicationProperties{
	// 				Name: to.Ptr("idzqqen"),
	// 				ApplicationDescription: to.Ptr("gjlwegnqvffvsc"),
	// 				ApplicationType: to.Ptr("f"),
	// 				LegalName: to.Ptr("ar"),
	// 				OrganizationDescription: to.Ptr("fcueqzlxxr"),
	// 				TaxNumber: to.Ptr("ngzv"),
	// 				PrivacyContactEmailAddress: to.Ptr("l"),
	// 			},
	// 			AppID: to.Ptr("czgrhbvgr"),
	// 			GatewayID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/gateways/cdvcixxcdhjqw"),
	// 			AccountType: to.Ptr(armprogrammableconnectivity.AccountTypeAzureManaged),
	// 			OperatorName: to.Ptr("tjisxmigbgtejdnelabhc"),
	// 			CamaraAPIName: to.Ptr("lnktvqbqcdzmkubxwblwvgwifp"),
	// 			ProvisioningState: to.Ptr(armprogrammableconnectivity.ProvisioningStateSucceeded),
	// 			Status: &armprogrammableconnectivity.Status{
	// 				State: to.Ptr("rvez"),
	// 				Reason: to.Ptr("fpteanxqzqixfmymib"),
	// 			},
	// 		},
	// 		Tags: map[string]*string{
	// 			"key5536": to.Ptr("bjhvpzsmtalqxmjjbsfdizhg"),
	// 		},
	// 		Location: to.Ptr("dwvzfkjoepbmksygazllqryyinn"),
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/operatorApiConnections/uecwablqeufseigocrwf"),
	// 		Name: to.Ptr("zsilgtpflhroamaglfbywbn"),
	// 		Type: to.Ptr("stxhhdjwawmqtep"),
	// 		SystemData: &armprogrammableconnectivity.SystemData{
	// 			CreatedBy: to.Ptr("kuprrapuolhnvju"),
	// 			CreatedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("lsmrhxnvkpmrxncylgqpkr"),
	// 			LastModifiedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*OperatorAPIConnectionsClient) Get 

func (client *OperatorAPIConnectionsClient) Get(ctx context.Context, resourceGroupName string, operatorAPIConnectionName string, options *OperatorAPIConnectionsClientGetOptions) (OperatorAPIConnectionsClientGetResponse, error)

Get - Get an Operator API Connection. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-01-15-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • operatorAPIConnectionName - Azure Programmable Connectivity (APC) Operator API Connection Name.
  • options - OperatorAPIConnectionsClientGetOptions contains the optional parameters for the OperatorAPIConnectionsClient.Get method.
Example

Generated from example definition: 2024-01-15-preview/OperatorApiConnections_Get_MaximumSet_Gen.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOperatorAPIConnectionsClient().Get(ctx, "rgopenapi", "uetzqjrwqtkwgcirdqy", 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 = armprogrammableconnectivity.OperatorAPIConnectionsClientGetResponse{
	// 	OperatorAPIConnection: &armprogrammableconnectivity.OperatorAPIConnection{
	// 		Properties: &armprogrammableconnectivity.OperatorAPIConnectionProperties{
	// 			OperatorAPIPlanID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/providers/Microsoft.ProgrammableConnectivity/operatorApiPlans/livmzrh"),
	// 			SaasProperties: &armprogrammableconnectivity.SaasProperties{
	// 				SaasSubscriptionID: to.Ptr("mgyusmqt"),
	// 				SaasResourceID: to.Ptr("pekejefyvfviabimdrmno"),
	// 			},
	// 			ConfiguredApplication: &armprogrammableconnectivity.ApplicationProperties{
	// 				Name: to.Ptr("idzqqen"),
	// 				ApplicationDescription: to.Ptr("gjlwegnqvffvsc"),
	// 				ApplicationType: to.Ptr("f"),
	// 				LegalName: to.Ptr("ar"),
	// 				OrganizationDescription: to.Ptr("fcueqzlxxr"),
	// 				TaxNumber: to.Ptr("ngzv"),
	// 				PrivacyContactEmailAddress: to.Ptr("l"),
	// 			},
	// 			AppID: to.Ptr("czgrhbvgr"),
	// 			GatewayID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/gateways/cdvcixxcdhjqw"),
	// 			AccountType: to.Ptr(armprogrammableconnectivity.AccountTypeAzureManaged),
	// 			OperatorName: to.Ptr("tjisxmigbgtejdnelabhc"),
	// 			CamaraAPIName: to.Ptr("lnktvqbqcdzmkubxwblwvgwifp"),
	// 			ProvisioningState: to.Ptr(armprogrammableconnectivity.ProvisioningStateSucceeded),
	// 			Status: &armprogrammableconnectivity.Status{
	// 				State: to.Ptr("rvez"),
	// 				Reason: to.Ptr("fpteanxqzqixfmymib"),
	// 			},
	// 		},
	// 		Tags: map[string]*string{
	// 			"key5536": to.Ptr("bjhvpzsmtalqxmjjbsfdizhg"),
	// 		},
	// 		Location: to.Ptr("dwvzfkjoepbmksygazllqryyinn"),
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/operatorApiConnections/uecwablqeufseigocrwf"),
	// 		Name: to.Ptr("zsilgtpflhroamaglfbywbn"),
	// 		Type: to.Ptr("stxhhdjwawmqtep"),
	// 		SystemData: &armprogrammableconnectivity.SystemData{
	// 			CreatedBy: to.Ptr("kuprrapuolhnvju"),
	// 			CreatedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("lsmrhxnvkpmrxncylgqpkr"),
	// 			LastModifiedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*OperatorAPIConnectionsClient) NewListByResourceGroupPager 

func (client *OperatorAPIConnectionsClient) NewListByResourceGroupPager(resourceGroupName string, options *OperatorAPIConnectionsClientListByResourceGroupOptions) *runtime.Pager[OperatorAPIConnectionsClientListByResourceGroupResponse]

NewListByResourceGroupPager - List OperatorApiConnection resources by resource group.

Generated from API version 2024-01-15-preview

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

Generated from example definition: 2024-01-15-preview/OperatorApiConnections_ListByResourceGroup_MaximumSet_Gen.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOperatorAPIConnectionsClient().NewListByResourceGroupPager("rgopenapi", 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 = armprogrammableconnectivity.OperatorAPIConnectionsClientListByResourceGroupResponse{
		// 	OperatorAPIConnectionListResult: armprogrammableconnectivity.OperatorAPIConnectionListResult{
		// 		Value: []*armprogrammableconnectivity.OperatorAPIConnection{
		// 			{
		// 				Properties: &armprogrammableconnectivity.OperatorAPIConnectionProperties{
		// 					OperatorAPIPlanID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/providers/Microsoft.ProgrammableConnectivity/operatorApiPlans/livmzrh"),
		// 					SaasProperties: &armprogrammableconnectivity.SaasProperties{
		// 						SaasSubscriptionID: to.Ptr("mgyusmqt"),
		// 						SaasResourceID: to.Ptr("pekejefyvfviabimdrmno"),
		// 					},
		// 					ConfiguredApplication: &armprogrammableconnectivity.ApplicationProperties{
		// 						Name: to.Ptr("idzqqen"),
		// 						ApplicationDescription: to.Ptr("gjlwegnqvffvsc"),
		// 						ApplicationType: to.Ptr("f"),
		// 						LegalName: to.Ptr("ar"),
		// 						OrganizationDescription: to.Ptr("fcueqzlxxr"),
		// 						TaxNumber: to.Ptr("ngzv"),
		// 						PrivacyContactEmailAddress: to.Ptr("l"),
		// 					},
		// 					AppID: to.Ptr("czgrhbvgr"),
		// 					GatewayID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/gateways/cdvcixxcdhjqw"),
		// 					AccountType: to.Ptr(armprogrammableconnectivity.AccountTypeAzureManaged),
		// 					OperatorName: to.Ptr("tjisxmigbgtejdnelabhc"),
		// 					CamaraAPIName: to.Ptr("lnktvqbqcdzmkubxwblwvgwifp"),
		// 					ProvisioningState: to.Ptr(armprogrammableconnectivity.ProvisioningStateSucceeded),
		// 					Status: &armprogrammableconnectivity.Status{
		// 						State: to.Ptr("rvez"),
		// 						Reason: to.Ptr("fpteanxqzqixfmymib"),
		// 					},
		// 				},
		// 				Tags: map[string]*string{
		// 					"key5536": to.Ptr("bjhvpzsmtalqxmjjbsfdizhg"),
		// 				},
		// 				Location: to.Ptr("dwvzfkjoepbmksygazllqryyinn"),
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/operatorApiConnections/uecwablqeufseigocrwf"),
		// 				Name: to.Ptr("zsilgtpflhroamaglfbywbn"),
		// 				Type: to.Ptr("stxhhdjwawmqtep"),
		// 				SystemData: &armprogrammableconnectivity.SystemData{
		// 					CreatedBy: to.Ptr("kuprrapuolhnvju"),
		// 					CreatedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("lsmrhxnvkpmrxncylgqpkr"),
		// 					LastModifiedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

func (*OperatorAPIConnectionsClient) NewListBySubscriptionPager 

func (client *OperatorAPIConnectionsClient) NewListBySubscriptionPager(options *OperatorAPIConnectionsClientListBySubscriptionOptions) *runtime.Pager[OperatorAPIConnectionsClientListBySubscriptionResponse]

NewListBySubscriptionPager - List OperatorApiConnection resources by subscription ID.

Generated from API version 2024-01-15-preview

  • options - OperatorAPIConnectionsClientListBySubscriptionOptions contains the optional parameters for the OperatorAPIConnectionsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: 2024-01-15-preview/OperatorApiConnections_ListBySubscription_MaximumSet_Gen.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOperatorAPIConnectionsClient().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 = armprogrammableconnectivity.OperatorAPIConnectionsClientListBySubscriptionResponse{
		// 	OperatorAPIConnectionListResult: armprogrammableconnectivity.OperatorAPIConnectionListResult{
		// 		Value: []*armprogrammableconnectivity.OperatorAPIConnection{
		// 			{
		// 				Properties: &armprogrammableconnectivity.OperatorAPIConnectionProperties{
		// 					OperatorAPIPlanID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/providers/Microsoft.ProgrammableConnectivity/operatorApiPlans/livmzrh"),
		// 					SaasProperties: &armprogrammableconnectivity.SaasProperties{
		// 						SaasSubscriptionID: to.Ptr("mgyusmqt"),
		// 						SaasResourceID: to.Ptr("pekejefyvfviabimdrmno"),
		// 					},
		// 					ConfiguredApplication: &armprogrammableconnectivity.ApplicationProperties{
		// 						Name: to.Ptr("idzqqen"),
		// 						ApplicationDescription: to.Ptr("gjlwegnqvffvsc"),
		// 						ApplicationType: to.Ptr("f"),
		// 						LegalName: to.Ptr("ar"),
		// 						OrganizationDescription: to.Ptr("fcueqzlxxr"),
		// 						TaxNumber: to.Ptr("ngzv"),
		// 						PrivacyContactEmailAddress: to.Ptr("l"),
		// 					},
		// 					AppID: to.Ptr("czgrhbvgr"),
		// 					GatewayID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/gateways/cdvcixxcdhjqw"),
		// 					AccountType: to.Ptr(armprogrammableconnectivity.AccountTypeAzureManaged),
		// 					OperatorName: to.Ptr("tjisxmigbgtejdnelabhc"),
		// 					CamaraAPIName: to.Ptr("lnktvqbqcdzmkubxwblwvgwifp"),
		// 					ProvisioningState: to.Ptr(armprogrammableconnectivity.ProvisioningStateSucceeded),
		// 					Status: &armprogrammableconnectivity.Status{
		// 						State: to.Ptr("rvez"),
		// 						Reason: to.Ptr("fpteanxqzqixfmymib"),
		// 					},
		// 				},
		// 				Tags: map[string]*string{
		// 					"key5536": to.Ptr("bjhvpzsmtalqxmjjbsfdizhg"),
		// 				},
		// 				Location: to.Ptr("dwvzfkjoepbmksygazllqryyinn"),
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/resourceGroups/example-rg/providers/Microsoft.ProgrammableConnectivity/operatorApiConnections/uecwablqeufseigocrwf"),
		// 				Name: to.Ptr("zsilgtpflhroamaglfbywbn"),
		// 				Type: to.Ptr("stxhhdjwawmqtep"),
		// 				SystemData: &armprogrammableconnectivity.SystemData{
		// 					CreatedBy: to.Ptr("kuprrapuolhnvju"),
		// 					CreatedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("lsmrhxnvkpmrxncylgqpkr"),
		// 					LastModifiedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

type OperatorAPIConnectionsClientBeginCreateOptions 

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

OperatorAPIConnectionsClientBeginCreateOptions contains the optional parameters for the OperatorAPIConnectionsClient.BeginCreate method.

type OperatorAPIConnectionsClientBeginDeleteOptions 

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

OperatorAPIConnectionsClientBeginDeleteOptions contains the optional parameters for the OperatorAPIConnectionsClient.BeginDelete method.

type OperatorAPIConnectionsClientBeginUpdateOptions 

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

OperatorAPIConnectionsClientBeginUpdateOptions contains the optional parameters for the OperatorAPIConnectionsClient.BeginUpdate method.

type OperatorAPIConnectionsClientCreateResponse 

type OperatorAPIConnectionsClientCreateResponse struct {
	// A Programmable Connectivity Operator API Connection resource
	OperatorAPIConnection
}

OperatorAPIConnectionsClientCreateResponse contains the response from method OperatorAPIConnectionsClient.BeginCreate.

type OperatorAPIConnectionsClientDeleteResponse 

type OperatorAPIConnectionsClientDeleteResponse struct {
}

OperatorAPIConnectionsClientDeleteResponse contains the response from method OperatorAPIConnectionsClient.BeginDelete.

type OperatorAPIConnectionsClientGetOptions 

type OperatorAPIConnectionsClientGetOptions struct {
}

OperatorAPIConnectionsClientGetOptions contains the optional parameters for the OperatorAPIConnectionsClient.Get method.

type OperatorAPIConnectionsClientGetResponse 

type OperatorAPIConnectionsClientGetResponse struct {
	// A Programmable Connectivity Operator API Connection resource
	OperatorAPIConnection
}

OperatorAPIConnectionsClientGetResponse contains the response from method OperatorAPIConnectionsClient.Get.

type OperatorAPIConnectionsClientListByResourceGroupOptions 

type OperatorAPIConnectionsClientListByResourceGroupOptions struct {
}

OperatorAPIConnectionsClientListByResourceGroupOptions contains the optional parameters for the OperatorAPIConnectionsClient.NewListByResourceGroupPager method.

type OperatorAPIConnectionsClientListByResourceGroupResponse 

type OperatorAPIConnectionsClientListByResourceGroupResponse struct {
	// The response of a OperatorApiConnection list operation.
	OperatorAPIConnectionListResult
}

OperatorAPIConnectionsClientListByResourceGroupResponse contains the response from method OperatorAPIConnectionsClient.NewListByResourceGroupPager.

type OperatorAPIConnectionsClientListBySubscriptionOptions 

type OperatorAPIConnectionsClientListBySubscriptionOptions struct {
}

OperatorAPIConnectionsClientListBySubscriptionOptions contains the optional parameters for the OperatorAPIConnectionsClient.NewListBySubscriptionPager method.

type OperatorAPIConnectionsClientListBySubscriptionResponse 

type OperatorAPIConnectionsClientListBySubscriptionResponse struct {
	// The response of a OperatorApiConnection list operation.
	OperatorAPIConnectionListResult
}

OperatorAPIConnectionsClientListBySubscriptionResponse contains the response from method OperatorAPIConnectionsClient.NewListBySubscriptionPager.

type OperatorAPIConnectionsClientUpdateResponse 

type OperatorAPIConnectionsClientUpdateResponse struct {
	// A Programmable Connectivity Operator API Connection resource
	OperatorAPIConnection
}

OperatorAPIConnectionsClientUpdateResponse contains the response from method OperatorAPIConnectionsClient.BeginUpdate.

type OperatorAPIPlan 

type OperatorAPIPlan struct {
	// The resource-specific properties for this resource.
	Properties *OperatorAPIPlanProperties

	// READ-ONLY; APC Gateway Plan Name.
	Name *string

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *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
}

OperatorAPIPlan - A Programmable Connectivity Operator API Plans resource. This is a readonly resource that indicates which Operator Network APIs are available in the user's subscription.

func (OperatorAPIPlan) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperatorAPIPlan.

func (*OperatorAPIPlan) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperatorAPIPlan.

type OperatorAPIPlanListResult 

type OperatorAPIPlanListResult struct {
	// REQUIRED; The OperatorApiPlan items on this page
	Value []*OperatorAPIPlan

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

OperatorAPIPlanListResult - The response of a OperatorApiPlan list operation.

func (OperatorAPIPlanListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperatorAPIPlanListResult.

func (*OperatorAPIPlanListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperatorAPIPlanListResult.

type OperatorAPIPlanProperties 

type OperatorAPIPlanProperties struct {
	// Standardized Network API name defined by CAMARA specifications.
	CamaraAPIName *string

	// The limits, if any, will be imposed by the operator.
	Limits *string

	// Azure marketplace properties for this plan.
	MarketplaceProperties *MarketplaceProperties

	// List of country/region names where this plan is being supported by Azure Marketplace.
	Markets []*string

	// Name of the Operator this plan belongs to.
	OperatorName *string

	// List of country/region names where this plan is being supported by the Operator.
	OperatorRegions []*string

	// List of Azure regions where this offer is supported.
	SupportedLocations []*string

	// READ-ONLY; The status of the last operation on the Gateway resource.
	ProvisioningState *ProvisioningState
}

OperatorAPIPlanProperties - Operator API Plan properties.

func (OperatorAPIPlanProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperatorAPIPlanProperties.

func (*OperatorAPIPlanProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperatorAPIPlanProperties.

type OperatorAPIPlansClient 

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

OperatorAPIPlansClient contains the methods for the OperatorAPIPlans group. Don't use this type directly, use NewOperatorAPIPlansClient() instead.

func NewOperatorAPIPlansClient 

func NewOperatorAPIPlansClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*OperatorAPIPlansClient, error)

NewOperatorAPIPlansClient creates a new instance of OperatorAPIPlansClient 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 (*OperatorAPIPlansClient) Get 

func (client *OperatorAPIPlansClient) Get(ctx context.Context, operatorAPIPlanName string, options *OperatorAPIPlansClientGetOptions) (OperatorAPIPlansClientGetResponse, error)

Get - Get an OperatorApiPlan resource by name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-01-15-preview

  • operatorAPIPlanName - APC Gateway Plan Name.
  • options - OperatorAPIPlansClientGetOptions contains the optional parameters for the OperatorAPIPlansClient.Get method.
Example

Generated from example definition: 2024-01-15-preview/OperatorApiPlans_Get_MaximumSet_Gen.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOperatorAPIPlansClient().Get(ctx, "etzfxkqegslnxdhdmzvbtzxahnyq", 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 = armprogrammableconnectivity.OperatorAPIPlansClientGetResponse{
	// 	OperatorAPIPlan: &armprogrammableconnectivity.OperatorAPIPlan{
	// 		Properties: &armprogrammableconnectivity.OperatorAPIPlanProperties{
	// 			OperatorName: to.Ptr("csisc"),
	// 			CamaraAPIName: to.Ptr("vfugujiismnjtcwrzkdvxaj"),
	// 			SupportedLocations: []*string{
	// 				to.Ptr("m"),
	// 			},
	// 			OperatorRegions: []*string{
	// 				to.Ptr("licmuodzevtmowxdzzbstssmghl"),
	// 			},
	// 			Markets: []*string{
	// 				to.Ptr("yncxinbbsipilayubuq"),
	// 			},
	// 			Limits: to.Ptr("tdcuvjvnyctdlcxebcrcwquq"),
	// 			MarketplaceProperties: &armprogrammableconnectivity.MarketplaceProperties{
	// 				OfferID: to.Ptr("zlhnteqphbk"),
	// 				LegacyOfferID: to.Ptr("x"),
	// 				PublisherID: to.Ptr("zxlhmlhmkhuqggwmzyxg"),
	// 				PlanID: to.Ptr("ukdqvgtelddrssctjfbqjospcshfcg"),
	// 				TermID: to.Ptr("uuwqguxsrfnl"),
	// 			},
	// 			ProvisioningState: to.Ptr(armprogrammableconnectivity.ProvisioningStateSucceeded),
	// 		},
	// 		ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/providers/Microsoft.ProgrammableConnectivity/operatorApiPlans/livmzrh"),
	// 		Name: to.Ptr("bfrnaknndvhdkmaqgfwcmnxjsjtg"),
	// 		Type: to.Ptr("hclykzxrxyojkpfxnckjkcndlf"),
	// 		SystemData: &armprogrammableconnectivity.SystemData{
	// 			CreatedBy: to.Ptr("kuprrapuolhnvju"),
	// 			CreatedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("lsmrhxnvkpmrxncylgqpkr"),
	// 			LastModifiedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
	// 		},
	// 	},
	// }
}

func (*OperatorAPIPlansClient) NewListBySubscriptionPager 

func (client *OperatorAPIPlansClient) NewListBySubscriptionPager(options *OperatorAPIPlansClientListBySubscriptionOptions) *runtime.Pager[OperatorAPIPlansClientListBySubscriptionResponse]

NewListBySubscriptionPager - List OperatorApiPlan resources by subscription ID.

Generated from API version 2024-01-15-preview

  • options - OperatorAPIPlansClientListBySubscriptionOptions contains the optional parameters for the OperatorAPIPlansClient.NewListBySubscriptionPager method.
Example

Generated from example definition: 2024-01-15-preview/OperatorApiPlans_ListBySubscription_MaximumSet_Gen.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armprogrammableconnectivity.NewClientFactory("B976474B-99FA-4C25-A3BD-8B05C3C3D07A", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOperatorAPIPlansClient().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 = armprogrammableconnectivity.OperatorAPIPlansClientListBySubscriptionResponse{
		// 	OperatorAPIPlanListResult: armprogrammableconnectivity.OperatorAPIPlanListResult{
		// 		Value: []*armprogrammableconnectivity.OperatorAPIPlan{
		// 			{
		// 				Properties: &armprogrammableconnectivity.OperatorAPIPlanProperties{
		// 					OperatorName: to.Ptr("csisc"),
		// 					CamaraAPIName: to.Ptr("vfugujiismnjtcwrzkdvxaj"),
		// 					SupportedLocations: []*string{
		// 						to.Ptr("m"),
		// 					},
		// 					OperatorRegions: []*string{
		// 						to.Ptr("licmuodzevtmowxdzzbstssmghl"),
		// 					},
		// 					Markets: []*string{
		// 						to.Ptr("yncxinbbsipilayubuq"),
		// 					},
		// 					Limits: to.Ptr("tdcuvjvnyctdlcxebcrcwquq"),
		// 					MarketplaceProperties: &armprogrammableconnectivity.MarketplaceProperties{
		// 						OfferID: to.Ptr("zlhnteqphbk"),
		// 						LegacyOfferID: to.Ptr("x"),
		// 						PublisherID: to.Ptr("zxlhmlhmkhuqggwmzyxg"),
		// 						PlanID: to.Ptr("ukdqvgtelddrssctjfbqjospcshfcg"),
		// 						TermID: to.Ptr("uuwqguxsrfnl"),
		// 					},
		// 					ProvisioningState: to.Ptr(armprogrammableconnectivity.ProvisioningStateSucceeded),
		// 				},
		// 				ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-00000000000/providers/Microsoft.ProgrammableConnectivity/operatorApiPlans/livmzrh"),
		// 				Name: to.Ptr("bfrnaknndvhdkmaqgfwcmnxjsjtg"),
		// 				Type: to.Ptr("hclykzxrxyojkpfxnckjkcndlf"),
		// 				SystemData: &armprogrammableconnectivity.SystemData{
		// 					CreatedBy: to.Ptr("kuprrapuolhnvju"),
		// 					CreatedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("lsmrhxnvkpmrxncylgqpkr"),
		// 					LastModifiedByType: to.Ptr(armprogrammableconnectivity.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-01-30T16:41:38.838Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

type OperatorAPIPlansClientGetOptions 

type OperatorAPIPlansClientGetOptions struct {
}

OperatorAPIPlansClientGetOptions contains the optional parameters for the OperatorAPIPlansClient.Get method.

type OperatorAPIPlansClientGetResponse 

type OperatorAPIPlansClientGetResponse struct {
	// A Programmable Connectivity Operator API Plans resource. This is a readonly resource that indicates which Operator Network
	// APIs are available in the user's subscription.
	OperatorAPIPlan
}

OperatorAPIPlansClientGetResponse contains the response from method OperatorAPIPlansClient.Get.

type OperatorAPIPlansClientListBySubscriptionOptions 

type OperatorAPIPlansClientListBySubscriptionOptions struct {
	// An optional OData based filter expression to apply on the operation.
	Filter *string

	// An optional query parameter which specifies the number of records to be skipped.
	Skip *int32

	// An optional query parameter which specifies the maximum number of records to be returned.
	Top *int32
}

OperatorAPIPlansClientListBySubscriptionOptions contains the optional parameters for the OperatorAPIPlansClient.NewListBySubscriptionPager method.

type OperatorAPIPlansClientListBySubscriptionResponse 

type OperatorAPIPlansClientListBySubscriptionResponse struct {
	// The response of a OperatorApiPlan list operation.
	OperatorAPIPlanListResult
}

OperatorAPIPlansClientListBySubscriptionResponse contains the response from method OperatorAPIPlansClient.NewListBySubscriptionPager.

type Origin 

type Origin string

Origin - The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" 

const (
	// OriginSystem - Indicates the operation is initiated by a system.
	OriginSystem Origin = "system"
	// OriginUser - Indicates the operation is initiated by a user.
	OriginUser Origin = "user"
	// OriginUserSystem - Indicates the operation is initiated by a user or system.
	OriginUserSystem Origin = "user,system"
)

func PossibleOriginValues 

func PossibleOriginValues() []Origin

PossibleOriginValues returns the possible values for the Origin const type.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - The provisioning state of a resource. 

const (
	// ProvisioningStateAccepted - The resource create or update request has been accepted
	ProvisioningStateAccepted ProvisioningState = "Accepted"
	// ProvisioningStateCanceled - Resource creation was canceled.
	ProvisioningStateCanceled ProvisioningState = "Canceled"
	// ProvisioningStateDeleting - The resource is being deleted
	ProvisioningStateDeleting ProvisioningState = "Deleting"
	// ProvisioningStateFailed - Resource creation failed.
	ProvisioningStateFailed ProvisioningState = "Failed"
	// ProvisioningStateProvisioning - The resource is being provisioned
	ProvisioningStateProvisioning ProvisioningState = "Provisioning"
	// ProvisioningStateSucceeded - Resource has been created.
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
	// ProvisioningStateUpdating - The resource is updating
	ProvisioningStateUpdating ProvisioningState = "Updating"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type SaasProperties 

type SaasProperties struct {
	// Resource ID of the SaaS offer purchased from the marketplace.
	SaasResourceID *string

	// Subscription ID of the SaaS offer purchased from the marketplace.
	SaasSubscriptionID *string
}

SaasProperties - Details about the SaaS offer purchased from the marketplace.

func (SaasProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SaasProperties.

func (*SaasProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SaasProperties.

type Status 

type Status struct {
	// Explanation of the current state of the OperatorApiConnection resource.
	Reason *string

	// Current state of the OperatorApiConnection resource.
	State *string
}

Status - Description of the current status of the OperatorApiConnection resource.

func (Status) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Status.

func (*Status) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Status.

type SystemData 

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

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

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

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

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

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

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

func (SystemData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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