armconfluent

package module
v1.3.0 Latest Latest
Warning

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

 Go to latest Published: Mar 20, 2024 License: MIT Imports: 15 Imported by: 4

README

Azure Confluent Module for Go

PkgGoDev

The armconfluent module provides operations for working with Azure Confluent.

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 Confluent module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Confluent. 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 Confluent 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 := armconfluent.NewClientFactory(<subscription ID>, cred, nil)

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

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

Clients

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

client := clientFactory.NewAccessClient()

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 Confluent 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 APIKeyOwnerEntity added in v1.3.0 

type APIKeyOwnerEntity struct {
	// API Key owner id
	ID *string

	// Type of the owner service or user account
	Kind *string

	// API URL for accessing or modifying the referred object
	Related *string

	// CRN reference to the referred resource
	ResourceName *string
}

APIKeyOwnerEntity - API Key Owner details which can be a user or service account

func (APIKeyOwnerEntity) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type APIKeyOwnerEntity.

func (*APIKeyOwnerEntity) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type APIKeyOwnerEntity.

type APIKeyProperties added in v1.3.0 

type APIKeyProperties struct {
	// Metadata of the record
	Metadata *SCMetadataEntity

	// Specification of the API Key
	Spec *APIKeySpecEntity
}

APIKeyProperties - API Key Properties

func (APIKeyProperties) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type APIKeyProperties.

func (*APIKeyProperties) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type APIKeyProperties.

type APIKeyRecord added in v1.3.0 

type APIKeyRecord struct {
	// Id of the api key
	ID *string

	// Type of api key
	Kind *string

	// API Key Properties
	Properties *APIKeyProperties
}

APIKeyRecord - Details API key

func (APIKeyRecord) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type APIKeyRecord.

func (*APIKeyRecord) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type APIKeyRecord.

type APIKeyResourceEntity added in v1.3.0 

type APIKeyResourceEntity struct {
	// The environment of the api key
	Environment *string

	// Id of the resource
	ID *string

	// Type of the owner which can be service or user account
	Kind *string

	// API URL for accessing or modifying the api key resource object
	Related *string

	// CRN reference to the referred resource
	ResourceName *string
}

APIKeyResourceEntity - API Key Resource details which can be kafka cluster or schema registry cluster

func (APIKeyResourceEntity) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type APIKeyResourceEntity.

func (*APIKeyResourceEntity) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type APIKeyResourceEntity.

type APIKeySpecEntity added in v1.3.0 

type APIKeySpecEntity struct {
	// The description of the API Key
	Description *string

	// The name of the API Key
	Name *string

	// Specification of the cluster
	Owner *APIKeyOwnerEntity

	// Specification of the cluster
	Resource *APIKeyResourceEntity

	// API Key Secret
	Secret *string
}

APIKeySpecEntity - Spec of the API Key record

func (APIKeySpecEntity) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type APIKeySpecEntity.

func (*APIKeySpecEntity) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type APIKeySpecEntity.

type AccessClient added in v1.2.0 

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

AccessClient contains the methods for the Access group. Don't use this type directly, use NewAccessClient() instead.

func NewAccessClient added in v1.2.0 

func NewAccessClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AccessClient, error)

NewAccessClient creates a new instance of AccessClient with the specified values.

  • subscriptionID - Microsoft Azure subscription id
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AccessClient) CreateRoleBinding added in v1.3.0 

func (client *AccessClient) CreateRoleBinding(ctx context.Context, resourceGroupName string, organizationName string, body AccessCreateRoleBindingRequestModel, options *AccessClientCreateRoleBindingOptions) (AccessClientCreateRoleBindingResponse, error)

CreateRoleBinding - Organization role bindings If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • body - Create role binding Request Model
  • options - AccessClientCreateRoleBindingOptions contains the optional parameters for the AccessClient.CreateRoleBinding method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Access_CreateRoleBinding.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccessClient().CreateRoleBinding(ctx, "myResourceGroup", "myOrganization", armconfluent.AccessCreateRoleBindingRequestModel{
		CrnPattern: to.Ptr("crn://confluent.cloud/organization=1111aaaa-11aa-11aa-11aa-111111aaaaaa/environment=env-aaa1111/cloud-cluster=lkc-1111aaa"),
		Principal:  to.Ptr("User:u-111aaa"),
		RoleName:   to.Ptr("CloudClusterAdmin"),
	}, 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.RoleBindingRecord = armconfluent.RoleBindingRecord{
	// 	CrnPattern: to.Ptr("crn://confluent.cloud/organization=1111aaaa-11aa-11aa-11aa-111111aaaaaa/environment=env-aaa1111/cloud-cluster=lkc-1111aaa"),
	// 	ID: to.Ptr("dlz-f3a90de"),
	// 	Kind: to.Ptr("RoleBinding"),
	// 	Metadata: &armconfluent.MetadataEntity{
	// 		CreatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 		DeletedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 		ResourceName: to.Ptr("crn://confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/role-binding=rb-12345"),
	// 		Self: to.Ptr("https://api.confluent.cloud/iam/v2/role-bindings/rb-12345"),
	// 		UpdatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 	},
	// 	Principal: to.Ptr("User:u-111aaa"),
	// 	RoleName: to.Ptr("CloudClusterAdmin"),
	// }
}

Output:

func (*AccessClient) DeleteRoleBinding added in v1.3.0 

func (client *AccessClient) DeleteRoleBinding(ctx context.Context, resourceGroupName string, organizationName string, roleBindingID string, options *AccessClientDeleteRoleBindingOptions) (AccessClientDeleteRoleBindingResponse, error)

DeleteRoleBinding - Organization role bindings If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • roleBindingID - Confluent Role binding id
  • options - AccessClientDeleteRoleBindingOptions contains the optional parameters for the AccessClient.DeleteRoleBinding method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Access_DeleteRoleBinding.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewAccessClient().DeleteRoleBinding(ctx, "myResourceGroup", "myOrganization", "dlz-f3a90de", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*AccessClient) InviteUser added in v1.2.0 

func (client *AccessClient) InviteUser(ctx context.Context, resourceGroupName string, organizationName string, body AccessInviteUserAccountModel, options *AccessClientInviteUserOptions) (AccessClientInviteUserResponse, error)

InviteUser - Invite user to the organization If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - Resource group name
  • organizationName - Organization resource name
  • body - Invite user account model
  • options - AccessClientInviteUserOptions contains the optional parameters for the AccessClient.InviteUser method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Access_InviteUser.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccessClient().InviteUser(ctx, "myResourceGroup", "myOrganization", armconfluent.AccessInviteUserAccountModel{
		InvitedUserDetails: &armconfluent.AccessInvitedUserDetails{
			AuthType:     to.Ptr("AUTH_TYPE_SSO"),
			InvitedEmail: to.Ptr("user2@onmicrosoft.com"),
		},
	}, 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.InvitationRecord = armconfluent.InvitationRecord{
	// 	AcceptedAt: to.Ptr("2022-07-06T17:21:33Z"),
	// 	AuthType: to.Ptr("AUTH_TYPE_SSO"),
	// 	Email: to.Ptr("johndoe@confluent.io"),
	// 	ExpiresAt: to.Ptr("2022-07-07T17:22:39Z"),
	// 	ID: to.Ptr("dlz-f3a90de"),
	// 	Kind: to.Ptr("Invitation"),
	// 	Metadata: &armconfluent.MetadataEntity{
	// 		CreatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 		DeletedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 		ResourceName: to.Ptr("crn://confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/invitation=i-12345"),
	// 		Self: to.Ptr("https://api.confluent.cloud/iam/v2/invitations/i-12345"),
	// 		UpdatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 	},
	// 	Status: to.Ptr("INVITE_STATUS_SENT"),
	// }
}

Output:

func (*AccessClient) ListClusters added in v1.2.0 

func (client *AccessClient) ListClusters(ctx context.Context, resourceGroupName string, organizationName string, body ListAccessRequestModel, options *AccessClientListClustersOptions) (AccessClientListClustersResponse, error)

ListClusters - Cluster details If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • body - List Access Request Model
  • options - AccessClientListClustersOptions contains the optional parameters for the AccessClient.ListClusters method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Access_ClusterList.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccessClient().ListClusters(ctx, "myResourceGroup", "myOrganization", armconfluent.ListAccessRequestModel{
		SearchFilters: map[string]*string{
			"pageSize":  to.Ptr("10"),
			"pageToken": to.Ptr("asc4fts4ft"),
		},
	}, 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.AccessListClusterSuccessResponse = armconfluent.AccessListClusterSuccessResponse{
	// 	Data: []*armconfluent.ClusterRecord{
	// 		{
	// 			ID: to.Ptr("dlz-f3a90de"),
	// 			Kind: to.Ptr("Cluster"),
	// 			Metadata: &armconfluent.MetadataEntity{
	// 				CreatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 				DeletedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 				ResourceName: to.Ptr("crn://confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/environment=env-abc123/cloud-cluster=lkc-12345"),
	// 				Self: to.Ptr("https://api.confluent.cloud/cmk/v2/clusters/lkc-12345"),
	// 				UpdatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 			},
	// 			Spec: &armconfluent.ClusterSpecEntity{
	// 				APIEndpoint: to.Ptr("https://pkac-00000.us-west-2.aws.confluent.cloud"),
	// 				Availability: to.Ptr("SINGLE_ZONE"),
	// 				Byok: &armconfluent.ClusterByokEntity{
	// 					ID: to.Ptr("cck-00000"),
	// 					Related: to.Ptr("https://api.confluent.cloud/byok/v1/keys/cck-00000"),
	// 					ResourceName: to.Ptr("https://api.confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/key=cck-00000"),
	// 				},
	// 				Cloud: to.Ptr("GCP"),
	// 				Config: &armconfluent.ClusterConfigEntity{
	// 					Kind: to.Ptr("Basic"),
	// 				},
	// 				DisplayName: to.Ptr("ProdKafkaCluster"),
	// 				Environment: &armconfluent.ClusterEnvironmentEntity{
	// 					Environment: to.Ptr("string"),
	// 					ID: to.Ptr("env-00000"),
	// 					Related: to.Ptr("https://api.confluent.cloud/v2/environments/env-00000"),
	// 					ResourceName: to.Ptr("https://api.confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/environment=env-00000"),
	// 				},
	// 				HTTPEndpoint: to.Ptr("https://lkc-00000-00000.us-central1.gcp.glb.confluent.cloud"),
	// 				KafkaBootstrapEndpoint: to.Ptr("lkc-00000-00000.us-central1.gcp.glb.confluent.cloud:9092"),
	// 				Network: &armconfluent.ClusterNetworkEntity{
	// 					Environment: to.Ptr("string"),
	// 					ID: to.Ptr("n-00000"),
	// 					Related: to.Ptr("https://api.confluent.cloud/networking/v1/networks/n-00000"),
	// 					ResourceName: to.Ptr("https://api.confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/environment=env-abc123/network=n-00000"),
	// 				},
	// 				Region: to.Ptr("us-east4"),
	// 			},
	// 			Status: &armconfluent.ClusterStatusEntity{
	// 				Cku: to.Ptr[int32](2),
	// 				Phase: to.Ptr("PROVISIONED"),
	// 			},
	// 	}},
	// 	Kind: to.Ptr("ClusterList"),
	// 	Metadata: &armconfluent.ListMetadata{
	// 		First: to.Ptr("https://api.confluent.cloud/cmk/v2/clusters"),
	// 		Last: to.Ptr("https://api.confluent.cloud/cmk/v2/clusters?page_token=bcAOehAY8F16YD84Z1wT"),
	// 		Next: to.Ptr("https://api.confluent.cloud/cmk/v2/clusters?page_token=UvmDWOB1iwfAIBPj6EYb"),
	// 		Prev: to.Ptr("https://api.confluent.cloud/cmk/v2/clusters?page_token=YIXRY97wWYmwzrax4dld"),
	// 		TotalSize: to.Ptr[int32](123),
	// 	},
	// }
}

Output:

func (*AccessClient) ListEnvironments added in v1.2.0 

func (client *AccessClient) ListEnvironments(ctx context.Context, resourceGroupName string, organizationName string, body ListAccessRequestModel, options *AccessClientListEnvironmentsOptions) (AccessClientListEnvironmentsResponse, error)

ListEnvironments - Environment list of an organization If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • body - List Access Request Model
  • options - AccessClientListEnvironmentsOptions contains the optional parameters for the AccessClient.ListEnvironments method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Access_EnvironmentList.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccessClient().ListEnvironments(ctx, "myResourceGroup", "myOrganization", armconfluent.ListAccessRequestModel{
		SearchFilters: map[string]*string{
			"pageSize":  to.Ptr("10"),
			"pageToken": to.Ptr("asc4fts4ft"),
		},
	}, 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.AccessListEnvironmentsSuccessResponse = armconfluent.AccessListEnvironmentsSuccessResponse{
	// 	Data: []*armconfluent.EnvironmentRecord{
	// 		{
	// 			DisplayName: to.Ptr("prod-finance01"),
	// 			ID: to.Ptr("dlz-f3a90de"),
	// 			Kind: to.Ptr("Environment"),
	// 			Metadata: &armconfluent.MetadataEntity{
	// 				CreatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 				DeletedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 				ResourceName: to.Ptr("crn://confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/environment=e-12345"),
	// 				Self: to.Ptr("https://api.confluent.cloud/org/v2/environments/e-12345"),
	// 				UpdatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 			},
	// 	}},
	// 	Kind: to.Ptr("EnvironmentList"),
	// 	Metadata: &armconfluent.ListMetadata{
	// 		First: to.Ptr("https://api.confluent.cloud/org/v2/environments"),
	// 		Last: to.Ptr("https://api.confluent.cloud/org/v2/environments?page_token=bcAOehAY8F16YD84Z1wT"),
	// 		Next: to.Ptr("https://api.confluent.cloud/org/v2/environments?page_token=UvmDWOB1iwfAIBPj6EYb"),
	// 		Prev: to.Ptr("https://api.confluent.cloud/org/v2/environments?page_token=YIXRY97wWYmwzrax4dld"),
	// 		TotalSize: to.Ptr[int32](123),
	// 	},
	// }
}

Output:

func (*AccessClient) ListInvitations added in v1.2.0 

func (client *AccessClient) ListInvitations(ctx context.Context, resourceGroupName string, organizationName string, body ListAccessRequestModel, options *AccessClientListInvitationsOptions) (AccessClientListInvitationsResponse, error)

ListInvitations - Organization accounts invitation details If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - Resource group name
  • organizationName - Organization resource name
  • body - List Access Request Model
  • options - AccessClientListInvitationsOptions contains the optional parameters for the AccessClient.ListInvitations method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Access_InvitationsList.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccessClient().ListInvitations(ctx, "myResourceGroup", "myOrganization", armconfluent.ListAccessRequestModel{
		SearchFilters: map[string]*string{
			"pageSize":  to.Ptr("10"),
			"pageToken": to.Ptr("asc4fts4ft"),
			"status":    to.Ptr("INVITE_STATUS_SENT"),
		},
	}, 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.AccessListInvitationsSuccessResponse = armconfluent.AccessListInvitationsSuccessResponse{
	// 	Data: []*armconfluent.InvitationRecord{
	// 		{
	// 			AcceptedAt: to.Ptr("2022-07-06T17:21:33Z"),
	// 			AuthType: to.Ptr("AUTH_TYPE_SSO"),
	// 			Email: to.Ptr("johndoe@confluent.io"),
	// 			ExpiresAt: to.Ptr("2022-07-07T17:22:39Z"),
	// 			ID: to.Ptr("dlz-f3a90de"),
	// 			Kind: to.Ptr("Invitation"),
	// 			Metadata: &armconfluent.MetadataEntity{
	// 				CreatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 				DeletedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 				ResourceName: to.Ptr("crn://confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/invitation=i-12345"),
	// 				Self: to.Ptr("https://api.confluent.cloud/iam/v2/invitations/i-12345"),
	// 				UpdatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 			},
	// 			Status: to.Ptr("INVITE_STATUS_SENT"),
	// 	}},
	// 	Kind: to.Ptr("InvitationList"),
	// 	Metadata: &armconfluent.ListMetadata{
	// 		First: to.Ptr("https://api.confluent.cloud/iam/v2/invitations"),
	// 		Last: to.Ptr("https://api.confluent.cloud/iam/v2/invitations?page_token=bcAOehAY8F16YD84Z1wT"),
	// 		Next: to.Ptr("https://api.confluent.cloud/iam/v2/invitations?page_token=UvmDWOB1iwfAIBPj6EYb"),
	// 		Prev: to.Ptr("https://api.confluent.cloud/iam/v2/invitations?page_token=YIXRY97wWYmwzrax4dld"),
	// 		TotalSize: to.Ptr[int32](123),
	// 	},
	// }
}

Output:

func (*AccessClient) ListRoleBindingNameList added in v1.3.0 

func (client *AccessClient) ListRoleBindingNameList(ctx context.Context, resourceGroupName string, organizationName string, body ListAccessRequestModel, options *AccessClientListRoleBindingNameListOptions) (AccessClientListRoleBindingNameListResponse, error)

ListRoleBindingNameList - Organization role bindings If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • body - List Access Request Model
  • options - AccessClientListRoleBindingNameListOptions contains the optional parameters for the AccessClient.ListRoleBindingNameList method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Access_RoleBindingNameList.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccessClient().ListRoleBindingNameList(ctx, "myResourceGroup", "myOrganization", armconfluent.ListAccessRequestModel{
		SearchFilters: map[string]*string{
			"crn_pattern": to.Ptr("crn://confluent.cloud/organization=1aa7de07-298e-479c-8f2f-16ac91fd8e76"),
			"namespace":   to.Ptr("public,dataplane,networking,identity,datagovernance,connect,streamcatalog,pipelines,ksql"),
		},
	}, 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.AccessRoleBindingNameListSuccessResponse = armconfluent.AccessRoleBindingNameListSuccessResponse{
	// 	Data: []*string{
	// 		to.Ptr("MetricsViewer"),
	// 		to.Ptr("OrganizationAdmin"),
	// 		to.Ptr("Operator"),
	// 		to.Ptr("NetworkAdmin"),
	// 		to.Ptr("ResourceKeyAdmin"),
	// 		to.Ptr("AccountAdmin")},
	// 		Kind: to.Ptr("RoleDisplayNameList"),
	// 		Metadata: &armconfluent.ListMetadata{
	// 			First: to.Ptr("https://api.confluent.cloud/iam/v2/role-bindings"),
	// 			Last: to.Ptr("https://api.confluent.cloud/iam/v2/role-bindings?page_token=bcAOehAY8F16YD84Z1wT"),
	// 			Next: to.Ptr("https://api.confluent.cloud/iam/v2/role-bindings?page_token=UvmDWOB1iwfAIBPj6EYb"),
	// 			Prev: to.Ptr("https://api.confluent.cloud/iam/v2/role-bindings?page_token=YIXRY97wWYmwzrax4dld"),
	// 			TotalSize: to.Ptr[int32](123),
	// 		},
	// 	}
}

Output:

func (*AccessClient) ListRoleBindings added in v1.2.0 

func (client *AccessClient) ListRoleBindings(ctx context.Context, resourceGroupName string, organizationName string, body ListAccessRequestModel, options *AccessClientListRoleBindingsOptions) (AccessClientListRoleBindingsResponse, error)

ListRoleBindings - Organization role bindings If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • body - List Access Request Model
  • options - AccessClientListRoleBindingsOptions contains the optional parameters for the AccessClient.ListRoleBindings method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Access_RoleBindingList.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccessClient().ListRoleBindings(ctx, "myResourceGroup", "myOrganization", armconfluent.ListAccessRequestModel{
		SearchFilters: map[string]*string{
			"pageSize":  to.Ptr("10"),
			"pageToken": to.Ptr("asc4fts4ft"),
		},
	}, 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.AccessListRoleBindingsSuccessResponse = armconfluent.AccessListRoleBindingsSuccessResponse{
	// 	Data: []*armconfluent.RoleBindingRecord{
	// 		{
	// 			CrnPattern: to.Ptr("crn://confluent.cloud/organization=1111aaaa-11aa-11aa-11aa-111111aaaaaa/environment=env-aaa1111/cloud-cluster=lkc-1111aaa"),
	// 			ID: to.Ptr("dlz-f3a90de"),
	// 			Kind: to.Ptr("RoleBinding"),
	// 			Metadata: &armconfluent.MetadataEntity{
	// 				CreatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 				DeletedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 				ResourceName: to.Ptr("crn://confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/role-binding=rb-12345"),
	// 				Self: to.Ptr("https://api.confluent.cloud/iam/v2/role-bindings/rb-12345"),
	// 				UpdatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 			},
	// 			Principal: to.Ptr("User:u-111aaa"),
	// 			RoleName: to.Ptr("CloudClusterAdmin"),
	// 	}},
	// 	Kind: to.Ptr("RoleBindingList"),
	// 	Metadata: &armconfluent.ListMetadata{
	// 		First: to.Ptr("https://api.confluent.cloud/iam/v2/role-bindings"),
	// 		Last: to.Ptr("https://api.confluent.cloud/iam/v2/role-bindings?page_token=bcAOehAY8F16YD84Z1wT"),
	// 		Next: to.Ptr("https://api.confluent.cloud/iam/v2/role-bindings?page_token=UvmDWOB1iwfAIBPj6EYb"),
	// 		Prev: to.Ptr("https://api.confluent.cloud/iam/v2/role-bindings?page_token=YIXRY97wWYmwzrax4dld"),
	// 		TotalSize: to.Ptr[int32](123),
	// 	},
	// }
}

Output:

func (*AccessClient) ListServiceAccounts added in v1.2.0 

func (client *AccessClient) ListServiceAccounts(ctx context.Context, resourceGroupName string, organizationName string, body ListAccessRequestModel, options *AccessClientListServiceAccountsOptions) (AccessClientListServiceAccountsResponse, error)

ListServiceAccounts - Organization service accounts details If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - Resource group name
  • organizationName - Organization resource name
  • body - List Access Request Model
  • options - AccessClientListServiceAccountsOptions contains the optional parameters for the AccessClient.ListServiceAccounts method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Access_ServiceAccountsList.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccessClient().ListServiceAccounts(ctx, "myResourceGroup", "myOrganization", armconfluent.ListAccessRequestModel{
		SearchFilters: map[string]*string{
			"pageSize":  to.Ptr("10"),
			"pageToken": to.Ptr("asc4fts4ft"),
		},
	}, 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.AccessListServiceAccountsSuccessResponse = armconfluent.AccessListServiceAccountsSuccessResponse{
	// 	Data: []*armconfluent.ServiceAccountRecord{
	// 		{
	// 			Description: to.Ptr("Doc's repair bot for the DeLorean"),
	// 			DisplayName: to.Ptr("DeLorean_auto_repair"),
	// 			ID: to.Ptr("dlz-f3a90de"),
	// 			Kind: to.Ptr("ServiceAccount"),
	// 			Metadata: &armconfluent.MetadataEntity{
	// 				CreatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 				DeletedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 				ResourceName: to.Ptr("crn://confluent.cloud/service-account=sa-12345"),
	// 				Self: to.Ptr("https://api.confluent.cloud/iam/v2/service-accounts/sa-12345"),
	// 				UpdatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 			},
	// 	}},
	// 	Kind: to.Ptr("ServiceAccountList"),
	// 	Metadata: &armconfluent.ListMetadata{
	// 		First: to.Ptr("https://api.confluent.cloud/iam/v2/service-accounts"),
	// 		Last: to.Ptr("https://api.confluent.cloud/iam/v2/service-accounts?page_token=bcAOehAY8F16YD84Z1wT"),
	// 		Next: to.Ptr("https://api.confluent.cloud/iam/v2/service-accounts?page_token=UvmDWOB1iwfAIBPj6EYb"),
	// 		Prev: to.Ptr("https://api.confluent.cloud/iam/v2/service-accounts?page_token=YIXRY97wWYmwzrax4dld"),
	// 		TotalSize: to.Ptr[int32](123),
	// 	},
	// }
}

Output:

func (*AccessClient) ListUsers added in v1.2.0 

func (client *AccessClient) ListUsers(ctx context.Context, resourceGroupName string, organizationName string, body ListAccessRequestModel, options *AccessClientListUsersOptions) (AccessClientListUsersResponse, error)

ListUsers - Organization users details If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - Resource group name
  • organizationName - Organization resource name
  • body - List Access Request Model
  • options - AccessClientListUsersOptions contains the optional parameters for the AccessClient.ListUsers method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Access_UsersList.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAccessClient().ListUsers(ctx, "myResourceGroup", "myOrganization", armconfluent.ListAccessRequestModel{
		SearchFilters: map[string]*string{
			"pageSize":  to.Ptr("10"),
			"pageToken": to.Ptr("asc4fts4ft"),
		},
	}, 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.AccessListUsersSuccessResponse = armconfluent.AccessListUsersSuccessResponse{
	// 	Data: []*armconfluent.UserRecord{
	// 		{
	// 			AuthType: to.Ptr("AUTH_TYPE_SSO"),
	// 			Email: to.Ptr("marty.mcfly@example.com"),
	// 			FullName: to.Ptr("Marty McFly"),
	// 			ID: to.Ptr("dlz-f3a90de"),
	// 			Kind: to.Ptr("User"),
	// 			Metadata: &armconfluent.MetadataEntity{
	// 				CreatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 				DeletedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 				ResourceName: to.Ptr("crn://confluent.cloud/user=u-12345"),
	// 				Self: to.Ptr("https://api.confluent.cloud/iam/v2/users/u-12345"),
	// 				UpdatedAt: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 			},
	// 	}},
	// 	Kind: to.Ptr("UserList"),
	// 	Metadata: &armconfluent.ListMetadata{
	// 		First: to.Ptr("https://api.confluent.cloud/iam/v2/users"),
	// 		Last: to.Ptr("https://api.confluent.cloud/iam/v2/users?page_token=bcAOehAY8F16YD84Z1wT"),
	// 		Next: to.Ptr("https://api.confluent.cloud/iam/v2/users?page_token=UvmDWOB1iwfAIBPj6EYb"),
	// 		Prev: to.Ptr("https://api.confluent.cloud/iam/v2/users?page_token=YIXRY97wWYmwzrax4dld"),
	// 		TotalSize: to.Ptr[int32](123),
	// 	},
	// }
}

Output:

type AccessClientCreateRoleBindingOptions added in v1.3.0 

type AccessClientCreateRoleBindingOptions struct {
}

AccessClientCreateRoleBindingOptions contains the optional parameters for the AccessClient.CreateRoleBinding method.

type AccessClientCreateRoleBindingResponse added in v1.3.0 

type AccessClientCreateRoleBindingResponse struct {
	// Details on principal, role name and crn pattern of a role binding
	RoleBindingRecord
}

AccessClientCreateRoleBindingResponse contains the response from method AccessClient.CreateRoleBinding.

type AccessClientDeleteRoleBindingOptions added in v1.3.0 

type AccessClientDeleteRoleBindingOptions struct {
}

AccessClientDeleteRoleBindingOptions contains the optional parameters for the AccessClient.DeleteRoleBinding method.

type AccessClientDeleteRoleBindingResponse added in v1.3.0 

type AccessClientDeleteRoleBindingResponse struct {
}

AccessClientDeleteRoleBindingResponse contains the response from method AccessClient.DeleteRoleBinding.

type AccessClientInviteUserOptions added in v1.2.0 

type AccessClientInviteUserOptions struct {
}

AccessClientInviteUserOptions contains the optional parameters for the AccessClient.InviteUser method.

type AccessClientInviteUserResponse added in v1.2.0 

type AccessClientInviteUserResponse struct {
	// Record of the invitation
	InvitationRecord
}

AccessClientInviteUserResponse contains the response from method AccessClient.InviteUser.

type AccessClientListClustersOptions added in v1.2.0 

type AccessClientListClustersOptions struct {
}

AccessClientListClustersOptions contains the optional parameters for the AccessClient.ListClusters method.

type AccessClientListClustersResponse added in v1.2.0 

type AccessClientListClustersResponse struct {
	// Details of the clusters returned on successful response
	AccessListClusterSuccessResponse
}

AccessClientListClustersResponse contains the response from method AccessClient.ListClusters.

type AccessClientListEnvironmentsOptions added in v1.2.0 

type AccessClientListEnvironmentsOptions struct {
}

AccessClientListEnvironmentsOptions contains the optional parameters for the AccessClient.ListEnvironments method.

type AccessClientListEnvironmentsResponse added in v1.2.0 

type AccessClientListEnvironmentsResponse struct {
	// Details of the environments returned on successful response
	AccessListEnvironmentsSuccessResponse
}

AccessClientListEnvironmentsResponse contains the response from method AccessClient.ListEnvironments.

type AccessClientListInvitationsOptions added in v1.2.0 

type AccessClientListInvitationsOptions struct {
}

AccessClientListInvitationsOptions contains the optional parameters for the AccessClient.ListInvitations method.

type AccessClientListInvitationsResponse added in v1.2.0 

type AccessClientListInvitationsResponse struct {
	// List invitations success response
	AccessListInvitationsSuccessResponse
}

AccessClientListInvitationsResponse contains the response from method AccessClient.ListInvitations.

type AccessClientListRoleBindingNameListOptions added in v1.3.0 

type AccessClientListRoleBindingNameListOptions struct {
}

AccessClientListRoleBindingNameListOptions contains the optional parameters for the AccessClient.ListRoleBindingNameList method.

type AccessClientListRoleBindingNameListResponse added in v1.3.0 

type AccessClientListRoleBindingNameListResponse struct {
	// Details of the role binding names returned on successful response
	AccessRoleBindingNameListSuccessResponse
}

AccessClientListRoleBindingNameListResponse contains the response from method AccessClient.ListRoleBindingNameList.

type AccessClientListRoleBindingsOptions added in v1.2.0 

type AccessClientListRoleBindingsOptions struct {
}

AccessClientListRoleBindingsOptions contains the optional parameters for the AccessClient.ListRoleBindings method.

type AccessClientListRoleBindingsResponse added in v1.2.0 

type AccessClientListRoleBindingsResponse struct {
	// Details of the role bindings returned on successful response
	AccessListRoleBindingsSuccessResponse
}

AccessClientListRoleBindingsResponse contains the response from method AccessClient.ListRoleBindings.

type AccessClientListServiceAccountsOptions added in v1.2.0 

type AccessClientListServiceAccountsOptions struct {
}

AccessClientListServiceAccountsOptions contains the optional parameters for the AccessClient.ListServiceAccounts method.

type AccessClientListServiceAccountsResponse added in v1.2.0 

type AccessClientListServiceAccountsResponse struct {
	// List service accounts success response
	AccessListServiceAccountsSuccessResponse
}

AccessClientListServiceAccountsResponse contains the response from method AccessClient.ListServiceAccounts.

type AccessClientListUsersOptions added in v1.2.0 

type AccessClientListUsersOptions struct {
}

AccessClientListUsersOptions contains the optional parameters for the AccessClient.ListUsers method.

type AccessClientListUsersResponse added in v1.2.0 

type AccessClientListUsersResponse struct {
	// List users success response
	AccessListUsersSuccessResponse
}

AccessClientListUsersResponse contains the response from method AccessClient.ListUsers.

type AccessCreateRoleBindingRequestModel added in v1.3.0 

type AccessCreateRoleBindingRequestModel struct {
	// A CRN that specifies the scope and resource patterns necessary for the role to bind
	CrnPattern *string

	// The principal User or Group to bind the role to
	Principal *string

	// The name of the role to bind to the principal
	RoleName *string
}

AccessCreateRoleBindingRequestModel - Create role binding request model

func (AccessCreateRoleBindingRequestModel) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type AccessCreateRoleBindingRequestModel.

func (*AccessCreateRoleBindingRequestModel) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessCreateRoleBindingRequestModel.

type AccessInviteUserAccountModel added in v1.2.0 

type AccessInviteUserAccountModel struct {
	// Email of the logged in user
	Email *string

	// Details of the user who is being invited
	InvitedUserDetails *AccessInvitedUserDetails

	// Id of the organization
	OrganizationID *string

	// Upn of the logged in user
	Upn *string
}

AccessInviteUserAccountModel - Invite User Account model

func (AccessInviteUserAccountModel) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type AccessInviteUserAccountModel.

func (*AccessInviteUserAccountModel) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessInviteUserAccountModel.

type AccessInvitedUserDetails added in v1.2.0 

type AccessInvitedUserDetails struct {
	// Auth type of the user
	AuthType *string

	// UPN/Email of the user who is being invited
	InvitedEmail *string
}

AccessInvitedUserDetails - Details of the user being invited

func (AccessInvitedUserDetails) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type AccessInvitedUserDetails.

func (*AccessInvitedUserDetails) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessInvitedUserDetails.

type AccessListClusterSuccessResponse added in v1.2.0 

type AccessListClusterSuccessResponse struct {
	// List of clusters
	Data []*ClusterRecord

	// Type of response
	Kind *string

	// Metadata of the list
	Metadata *ListMetadata
}

AccessListClusterSuccessResponse - Details of the clusters returned on successful response

func (AccessListClusterSuccessResponse) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type AccessListClusterSuccessResponse.

func (*AccessListClusterSuccessResponse) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessListClusterSuccessResponse.

type AccessListEnvironmentsSuccessResponse added in v1.2.0 

type AccessListEnvironmentsSuccessResponse struct {
	// Environment list data
	Data []*EnvironmentRecord

	// Type of response
	Kind *string

	// Metadata of the environment list
	Metadata *ListMetadata
}

AccessListEnvironmentsSuccessResponse - Details of the environments returned on successful response

func (AccessListEnvironmentsSuccessResponse) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type AccessListEnvironmentsSuccessResponse.

func (*AccessListEnvironmentsSuccessResponse) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessListEnvironmentsSuccessResponse.

type AccessListInvitationsSuccessResponse added in v1.2.0 

type AccessListInvitationsSuccessResponse struct {
	// Data of the invitations list
	Data []*InvitationRecord

	// Type of response
	Kind *string

	// Metadata of the list
	Metadata *ListMetadata
}

AccessListInvitationsSuccessResponse - List invitations success response

func (AccessListInvitationsSuccessResponse) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type AccessListInvitationsSuccessResponse.

func (*AccessListInvitationsSuccessResponse) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessListInvitationsSuccessResponse.

type AccessListRoleBindingsSuccessResponse added in v1.2.0 

type AccessListRoleBindingsSuccessResponse struct {
	// List of role binding
	Data []*RoleBindingRecord

	// Type of response
	Kind *string

	// Metadata of the list
	Metadata *ListMetadata
}

AccessListRoleBindingsSuccessResponse - Details of the role bindings returned on successful response

func (AccessListRoleBindingsSuccessResponse) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type AccessListRoleBindingsSuccessResponse.

func (*AccessListRoleBindingsSuccessResponse) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessListRoleBindingsSuccessResponse.

type AccessListServiceAccountsSuccessResponse added in v1.2.0 

type AccessListServiceAccountsSuccessResponse struct {
	// Data of the service accounts list
	Data []*ServiceAccountRecord

	// Type of response
	Kind *string

	// Metadata of the list
	Metadata *ListMetadata
}

AccessListServiceAccountsSuccessResponse - List service accounts success response

func (AccessListServiceAccountsSuccessResponse) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type AccessListServiceAccountsSuccessResponse.

func (*AccessListServiceAccountsSuccessResponse) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessListServiceAccountsSuccessResponse.

type AccessListUsersSuccessResponse added in v1.2.0 

type AccessListUsersSuccessResponse struct {
	// Data of the users list
	Data []*UserRecord

	// Type of response
	Kind *string

	// Metadata of the list
	Metadata *ListMetadata
}

AccessListUsersSuccessResponse - List users success response

func (AccessListUsersSuccessResponse) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type AccessListUsersSuccessResponse.

func (*AccessListUsersSuccessResponse) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessListUsersSuccessResponse.

type AccessRoleBindingNameListSuccessResponse added in v1.3.0 

type AccessRoleBindingNameListSuccessResponse struct {
	// List of role binding names
	Data []*string

	// Type of response
	Kind *string

	// Metadata of the list
	Metadata *ListMetadata
}

AccessRoleBindingNameListSuccessResponse - Details of the role binding names returned on successful response

func (AccessRoleBindingNameListSuccessResponse) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type AccessRoleBindingNameListSuccessResponse.

func (*AccessRoleBindingNameListSuccessResponse) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessRoleBindingNameListSuccessResponse.

type AgreementProperties added in v0.2.0 

type AgreementProperties struct {
	// If any version of the terms have been accepted, otherwise false.
	Accepted *bool

	// Link to HTML with Microsoft and Publisher terms.
	LicenseTextLink *string

	// Plan identifier string.
	Plan *string

	// Link to the privacy policy of the publisher.
	PrivacyPolicyLink *string

	// Product identifier string.
	Product *string

	// Publisher identifier string.
	Publisher *string

	// Date and time in UTC of when the terms were accepted. This is empty if Accepted is false.
	RetrieveDatetime *time.Time

	// Terms signature.
	Signature *string
}

AgreementProperties - Terms properties for Marketplace and Confluent.

func (AgreementProperties) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type AgreementProperties.

func (*AgreementProperties) UnmarshalJSON added in v0.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AgreementProperties.

type AgreementResource added in v0.2.0 

type AgreementResource struct {
	// Represents the properties of the resource.
	Properties *AgreementProperties

	// READ-ONLY; The ARM id of the resource.
	ID *string

	// READ-ONLY; The name of the agreement.
	Name *string

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource
	SystemData *SystemData

	// READ-ONLY; The type of the agreement.
	Type *string
}

AgreementResource - Agreement Terms definition

func (AgreementResource) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type AgreementResource.

func (*AgreementResource) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AgreementResource.

type AgreementResourceListResponse added in v0.2.0 

type AgreementResourceListResponse struct {
	// Link to the next set of results, if any.
	NextLink *string

	// Results of a list operation.
	Value []*AgreementResource
}

AgreementResourceListResponse - Response of a list operation.

func (AgreementResourceListResponse) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type AgreementResourceListResponse.

func (*AgreementResourceListResponse) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AgreementResourceListResponse.

type ClientFactory added in v1.1.0 

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

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

func NewClientFactory added in v1.1.0 

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

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

  • subscriptionID - Microsoft Azure subscription id
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewAccessClient added in v1.2.0 

func (c *ClientFactory) NewAccessClient() *AccessClient

NewAccessClient creates a new instance of AccessClient.

func (*ClientFactory) NewMarketplaceAgreementsClient added in v1.1.0 

func (c *ClientFactory) NewMarketplaceAgreementsClient() *MarketplaceAgreementsClient

NewMarketplaceAgreementsClient creates a new instance of MarketplaceAgreementsClient.

func (*ClientFactory) NewOrganizationClient added in v1.1.0 

func (c *ClientFactory) NewOrganizationClient() *OrganizationClient

NewOrganizationClient creates a new instance of OrganizationClient.

func (*ClientFactory) NewOrganizationOperationsClient added in v1.1.0 

func (c *ClientFactory) NewOrganizationOperationsClient() *OrganizationOperationsClient

NewOrganizationOperationsClient creates a new instance of OrganizationOperationsClient.

func (*ClientFactory) NewValidationsClient added in v1.1.0 

func (c *ClientFactory) NewValidationsClient() *ValidationsClient

NewValidationsClient creates a new instance of ValidationsClient.

type ClusterByokEntity added in v1.2.0 

type ClusterByokEntity struct {
	// ID of the referred resource
	ID *string

	// API URL for accessing or modifying the referred object
	Related *string

	// CRN reference to the referred resource
	ResourceName *string
}

ClusterByokEntity - The network associated with this object

func (ClusterByokEntity) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ClusterByokEntity.

func (*ClusterByokEntity) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterByokEntity.

type ClusterConfigEntity added in v1.2.0 

type ClusterConfigEntity struct {
	// The lifecycle phase of the cluster
	Kind *string
}

ClusterConfigEntity - The configuration of the Kafka cluster

func (ClusterConfigEntity) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ClusterConfigEntity.

func (*ClusterConfigEntity) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterConfigEntity.

type ClusterEnvironmentEntity added in v1.2.0 

type ClusterEnvironmentEntity struct {
	// Environment of the referred resource
	Environment *string

	// ID of the referred resource
	ID *string

	// API URL for accessing or modifying the referred object
	Related *string

	// CRN reference to the referred resource
	ResourceName *string
}

ClusterEnvironmentEntity - The environment to which cluster belongs

func (ClusterEnvironmentEntity) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ClusterEnvironmentEntity.

func (*ClusterEnvironmentEntity) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterEnvironmentEntity.

type ClusterNetworkEntity added in v1.2.0 

type ClusterNetworkEntity struct {
	// Environment of the referred resource
	Environment *string

	// ID of the referred resource
	ID *string

	// API URL for accessing or modifying the referred object
	Related *string

	// CRN reference to the referred resource
	ResourceName *string
}

ClusterNetworkEntity - The network associated with this object

func (ClusterNetworkEntity) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ClusterNetworkEntity.

func (*ClusterNetworkEntity) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterNetworkEntity.

type ClusterProperties added in v1.3.0 

type ClusterProperties struct {
	// Metadata of the record
	Metadata *SCMetadataEntity

	// Specification of the cluster
	Spec *SCClusterSpecEntity

	// Specification of the cluster status
	Status *ClusterStatusEntity
}

ClusterProperties - Cluster Properties

func (ClusterProperties) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type ClusterProperties.

func (*ClusterProperties) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterProperties.

type ClusterRecord added in v1.2.0 

type ClusterRecord struct {
	// Display name of the cluster
	DisplayName *string

	// Id of the cluster
	ID *string

	// Type of cluster
	Kind *string

	// Metadata of the record
	Metadata *MetadataEntity

	// Specification of the cluster
	Spec *ClusterSpecEntity

	// Specification of the cluster
	Status *ClusterStatusEntity
}

ClusterRecord - Details of cluster record

func (ClusterRecord) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ClusterRecord.

func (*ClusterRecord) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterRecord.

type ClusterSpecEntity added in v1.2.0 

type ClusterSpecEntity struct {
	// The Kafka API cluster endpoint
	APIEndpoint *string

	// The availability zone configuration of the cluster
	Availability *string

	// Specification of the cluster
	Byok *ClusterByokEntity

	// The cloud service provider
	Cloud *string

	// Specification of the cluster
	Config *ClusterConfigEntity

	// The name of the cluster
	DisplayName *string

	// Specification of the cluster
	Environment *ClusterEnvironmentEntity

	// The cluster HTTP request URL.
	HTTPEndpoint *string

	// The bootstrap endpoint used by Kafka clients to connect to the cluster
	KafkaBootstrapEndpoint *string

	// Specification of the cluster
	Network *ClusterNetworkEntity

	// The cloud service provider region
	Region *string

	// type of zone availability
	Zone *string
}

ClusterSpecEntity - Spec of the cluster record

func (ClusterSpecEntity) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ClusterSpecEntity.

func (*ClusterSpecEntity) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterSpecEntity.

type ClusterStatusEntity added in v1.2.0 

type ClusterStatusEntity struct {
	// The number of Confluent Kafka Units
	Cku *int32

	// The lifecycle phase of the cluster
	Phase *string
}

ClusterStatusEntity - Status of the cluster record

func (ClusterStatusEntity) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ClusterStatusEntity.

func (*ClusterStatusEntity) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterStatusEntity.

type CreateAPIKeyModel added in v1.3.0 

type CreateAPIKeyModel struct {
	// Description of the API Key
	Description *string

	// Name of the API Key
	Name *string
}

CreateAPIKeyModel - Create API Key model

func (CreateAPIKeyModel) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateAPIKeyModel.

func (*CreateAPIKeyModel) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CreateAPIKeyModel.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

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

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type EnvironmentProperties added in v1.3.0 

type EnvironmentProperties struct {
	// Metadata of the record
	Metadata *SCMetadataEntity
}

EnvironmentProperties - Environment resource property

func (EnvironmentProperties) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type EnvironmentProperties.

func (*EnvironmentProperties) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type EnvironmentProperties.

type EnvironmentRecord added in v1.2.0 

type EnvironmentRecord struct {
	// Display name of the user
	DisplayName *string

	// Id of the environment
	ID *string

	// Type of environment
	Kind *string

	// Metadata of the record
	Metadata *MetadataEntity
}

EnvironmentRecord - Details about environment name, metadata and environment id of an environment

func (EnvironmentRecord) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type EnvironmentRecord.

func (*EnvironmentRecord) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type EnvironmentRecord.

type ErrorResponseBody 

type ErrorResponseBody struct {
	// READ-ONLY; Error code
	Code *string

	// READ-ONLY; Error detail
	Details []*ErrorResponseBody

	// READ-ONLY; Error message
	Message *string

	// READ-ONLY; Error target
	Target *string
}

ErrorResponseBody - Response body of Error

func (ErrorResponseBody) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ErrorResponseBody.

func (*ErrorResponseBody) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponseBody.

type GetEnvironmentsResponse added in v1.3.0 

type GetEnvironmentsResponse struct {
	// URL to get the next set of environment records if there are any.
	NextLink *string

	// List of environments in a confluent organization
	Value []*SCEnvironmentRecord
}

GetEnvironmentsResponse - Result of GET request to list Confluent operations.

func (GetEnvironmentsResponse) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type GetEnvironmentsResponse.

func (*GetEnvironmentsResponse) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type GetEnvironmentsResponse.

type InvitationRecord added in v1.2.0 

type InvitationRecord struct {
	// Accepted date time of the invitation
	AcceptedAt *string

	// Auth type of the user
	AuthType *string

	// Email of the user
	Email *string

	// Expiration date time of the invitation
	ExpiresAt *string

	// Id of the invitation
	ID *string

	// Type of account
	Kind *string

	// Metadata of the record
	Metadata *MetadataEntity

	// Status of the invitation
	Status *string
}

InvitationRecord - Record of the invitation

func (InvitationRecord) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type InvitationRecord.

func (*InvitationRecord) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type InvitationRecord.

type LinkOrganization added in v1.2.0 

type LinkOrganization struct {
	// REQUIRED; User auth token
	Token *string
}

LinkOrganization - Link an existing Confluent organization

func (LinkOrganization) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type LinkOrganization.

func (*LinkOrganization) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LinkOrganization.

type ListAccessRequestModel added in v1.2.0 

type ListAccessRequestModel struct {
	// Search filters for the request
	SearchFilters map[string]*string
}

ListAccessRequestModel - List Access Request Model

func (ListAccessRequestModel) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ListAccessRequestModel.

func (*ListAccessRequestModel) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ListAccessRequestModel.

type ListClustersSuccessResponse added in v1.3.0 

type ListClustersSuccessResponse struct {
	// URL to get the next set of cluster records if there are any.
	NextLink *string

	// List of clusters in an environment of a confluent organization
	Value []*SCClusterRecord
}

ListClustersSuccessResponse - Result of GET request to list clusters in the environment of a confluent organization

func (ListClustersSuccessResponse) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type ListClustersSuccessResponse.

func (*ListClustersSuccessResponse) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ListClustersSuccessResponse.

type ListMetadata added in v1.2.0 

type ListMetadata struct {
	// First page of the list
	First *string

	// Last page of the list
	Last *string

	// Next page of the list
	Next *string

	// Previous page of the list
	Prev *string

	// Total size of the list
	TotalSize *int32
}

ListMetadata - Metadata of the list

func (ListMetadata) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ListMetadata.

func (*ListMetadata) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ListMetadata.

type ListRegionsSuccessResponse added in v1.3.0 

type ListRegionsSuccessResponse struct {
	// List of regions supported by confluent
	Data []*RegionRecord
}

ListRegionsSuccessResponse - Result of POST request to list regions supported by confluent

func (ListRegionsSuccessResponse) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type ListRegionsSuccessResponse.

func (*ListRegionsSuccessResponse) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ListRegionsSuccessResponse.

type ListSchemaRegistryClustersResponse added in v1.3.0 

type ListSchemaRegistryClustersResponse struct {
	// URL to get the next set of schema registry cluster records if there are any.
	NextLink *string

	// List of schema registry clusters in an environment of a confluent organization
	Value []*SchemaRegistryClusterRecord
}

ListSchemaRegistryClustersResponse - Result of GET request to list schema registry clusters in the environment of a confluent organization

func (ListSchemaRegistryClustersResponse) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type ListSchemaRegistryClustersResponse.

func (*ListSchemaRegistryClustersResponse) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ListSchemaRegistryClustersResponse.

type MarketplaceAgreementsClient 

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

MarketplaceAgreementsClient contains the methods for the MarketplaceAgreements group. Don't use this type directly, use NewMarketplaceAgreementsClient() instead.

func NewMarketplaceAgreementsClient 

func NewMarketplaceAgreementsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*MarketplaceAgreementsClient, error)

NewMarketplaceAgreementsClient creates a new instance of MarketplaceAgreementsClient with the specified values.

  • subscriptionID - Microsoft Azure subscription id
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*MarketplaceAgreementsClient) Create 

func (client *MarketplaceAgreementsClient) Create(ctx context.Context, options *MarketplaceAgreementsClientCreateOptions) (MarketplaceAgreementsClientCreateResponse, error)

Create - Create Confluent Marketplace agreement in the subscription. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • options - MarketplaceAgreementsClientCreateOptions contains the optional parameters for the MarketplaceAgreementsClient.Create method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/MarketplaceAgreements_Create.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewMarketplaceAgreementsClient().Create(ctx, &armconfluent.MarketplaceAgreementsClientCreateOptions{Body: 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.AgreementResource = armconfluent.AgreementResource{
	// 	Name: to.Ptr("default"),
	// 	Type: to.Ptr("Microsoft.Confluent/agreements"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/providers/Microsoft.Confluent/agreements/default"),
	// 	Properties: &armconfluent.AgreementProperties{
	// 		Accepted: to.Ptr(true),
	// 		LicenseTextLink: to.Ptr("test.licenseLink1"),
	// 		Plan: to.Ptr("planid1"),
	// 		PrivacyPolicyLink: to.Ptr("test.privacyPolicyLink1"),
	// 		Product: to.Ptr("offid1"),
	// 		Publisher: to.Ptr("pubid1"),
	// 		RetrieveDatetime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-05T17:33:07.121Z"); return t}()),
	// 		Signature: to.Ptr("YKWOQOKH2BCKZ46O7SCKHANWEENRFRU5WB4LXDFUYWCBWTS4AG4SGQXCOZYIR5ZJCZTXRMZKYZMO2BJSL5YKPLAR4LBFRUNS6CRYE7A"),
	// 	},
	// 	SystemData: &armconfluent.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
	// 		CreatedBy: to.Ptr("string"),
	// 		CreatedByType: to.Ptr(armconfluent.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("string"),
	// 		LastModifiedByType: to.Ptr(armconfluent.CreatedByTypeUser),
	// 	},
	// }
}

Output:

func (*MarketplaceAgreementsClient) NewListPager added in v0.4.0 

func (client *MarketplaceAgreementsClient) NewListPager(options *MarketplaceAgreementsClientListOptions) *runtime.Pager[MarketplaceAgreementsClientListResponse]

NewListPager - List Confluent marketplace agreements in the subscription.

Generated from API version 2024-02-13

  • options - MarketplaceAgreementsClientListOptions contains the optional parameters for the MarketplaceAgreementsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/MarketplaceAgreements_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewMarketplaceAgreementsClient().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.AgreementResourceListResponse = armconfluent.AgreementResourceListResponse{
		// 	Value: []*armconfluent.AgreementResource{
		// 		{
		// 			Name: to.Ptr("planid1"),
		// 			Type: to.Ptr("Microsoft.Confluent/agreements"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/providers/Microsoft.Confluent/agreements/default"),
		// 			Properties: &armconfluent.AgreementProperties{
		// 				Accepted: to.Ptr(true),
		// 				LicenseTextLink: to.Ptr("test.licenseLink1"),
		// 				Plan: to.Ptr("planid1"),
		// 				PrivacyPolicyLink: to.Ptr("test.privacyPolicyLink1"),
		// 				Product: to.Ptr("offid1"),
		// 				Publisher: to.Ptr("pubid1"),
		// 				RetrieveDatetime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-15T11:33:07.121Z"); return t}()),
		// 				Signature: to.Ptr("ASDFSDAFWEFASDGWERLWER"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("planid2"),
		// 			Type: to.Ptr("Microsoft.MarketplaceOrdering/offertypes"),
		// 			ID: to.Ptr("id2"),
		// 			Properties: &armconfluent.AgreementProperties{
		// 				Accepted: to.Ptr(true),
		// 				LicenseTextLink: to.Ptr("test.licenseLin2k"),
		// 				Plan: to.Ptr("planid2"),
		// 				PrivacyPolicyLink: to.Ptr("test.privacyPolicyLink2"),
		// 				Product: to.Ptr("offid2"),
		// 				Publisher: to.Ptr("pubid2"),
		// 				RetrieveDatetime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-08-14T11:33:07.121Z"); return t}()),
		// 				Signature: to.Ptr("ASDFSDAFWEFASDGWERLWER"),
		// 			},
		// 	}},
		// }
	}
}

Output:

type MarketplaceAgreementsClientCreateOptions added in v0.2.0 

type MarketplaceAgreementsClientCreateOptions struct {
	// Confluent Marketplace Agreement resource
	Body *AgreementResource
}

MarketplaceAgreementsClientCreateOptions contains the optional parameters for the MarketplaceAgreementsClient.Create method.

type MarketplaceAgreementsClientCreateResponse added in v0.2.0 

type MarketplaceAgreementsClientCreateResponse struct {
	// Agreement Terms definition
	AgreementResource
}

MarketplaceAgreementsClientCreateResponse contains the response from method MarketplaceAgreementsClient.Create.

type MarketplaceAgreementsClientListOptions added in v0.2.0 

type MarketplaceAgreementsClientListOptions struct {
}

MarketplaceAgreementsClientListOptions contains the optional parameters for the MarketplaceAgreementsClient.NewListPager method.

type MarketplaceAgreementsClientListResponse added in v0.2.0 

type MarketplaceAgreementsClientListResponse struct {
	// Response of a list operation.
	AgreementResourceListResponse
}

MarketplaceAgreementsClientListResponse contains the response from method MarketplaceAgreementsClient.NewListPager.

type MetadataEntity added in v1.2.0 

type MetadataEntity struct {
	// Created Date Time
	CreatedAt *string

	// Deleted Date time
	DeletedAt *string

	// Resource name of the record
	ResourceName *string

	// Self lookup url
	Self *string

	// Updated Date time
	UpdatedAt *string
}

MetadataEntity - Metadata of the data record

func (MetadataEntity) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type MetadataEntity.

func (*MetadataEntity) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type MetadataEntity.

type OfferDetail 

type OfferDetail struct {
	// REQUIRED; Offer Id
	ID *string

	// REQUIRED; Offer Plan Id
	PlanID *string

	// REQUIRED; Offer Plan Name
	PlanName *string

	// REQUIRED; Publisher Id
	PublisherID *string

	// REQUIRED; Offer Plan Term unit
	TermUnit *string

	// Private Offer Id
	PrivateOfferID *string

	// Array of Private Offer Ids
	PrivateOfferIDs []*string

	// SaaS Offer Status
	Status *SaaSOfferStatus

	// Offer Plan Term Id
	TermID *string
}

OfferDetail - Confluent Offer detail

func (OfferDetail) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type OfferDetail.

func (*OfferDetail) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OfferDetail.

type OperationDisplay 

type OperationDisplay struct {
	// Description of the operation, e.g., 'Write confluent'.
	Description *string

	// Operation type, e.g., read, write, delete, etc.
	Operation *string

	// Service provider: Microsoft.Confluent
	Provider *string

	// Type on which the operation is performed, e.g., 'clusters'.
	Resource *string
}

OperationDisplay - The object that represents the operation.

func (OperationDisplay) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult 

type OperationListResult struct {
	// URL to get the next set of operation list results if there are any.
	NextLink *string

	// List of Confluent operations supported by the Microsoft.Confluent provider.
	Value []*OperationResult
}

OperationListResult - Result of GET request to list Confluent operations.

func (OperationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationResult 

type OperationResult struct {
	// The object that represents the operation.
	Display *OperationDisplay

	// Indicates whether the operation is a data action
	IsDataAction *bool

	// Operation name: {provider}/{resource}/{operation}
	Name *string
}

OperationResult - An Confluent REST API operation.

func (OperationResult) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type OperationResult.

func (*OperationResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationResult.

type OrganizationClient 

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

OrganizationClient contains the methods for the Organization group. Don't use this type directly, use NewOrganizationClient() instead.

func NewOrganizationClient 

func NewOrganizationClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*OrganizationClient, error)

NewOrganizationClient creates a new instance of OrganizationClient with the specified values.

  • subscriptionID - Microsoft Azure subscription id
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OrganizationClient) BeginCreate 

func (client *OrganizationClient) BeginCreate(ctx context.Context, resourceGroupName string, organizationName string, options *OrganizationClientBeginCreateOptions) (*runtime.Poller[OrganizationClientCreateResponse], error)

BeginCreate - Create Organization resource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - Resource group name
  • organizationName - Organization resource name
  • options - OrganizationClientBeginCreateOptions contains the optional parameters for the OrganizationClient.BeginCreate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_Create.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewOrganizationClient().BeginCreate(ctx, "myResourceGroup", "myOrganization", &armconfluent.OrganizationClientBeginCreateOptions{Body: &armconfluent.OrganizationResource{
		Location: to.Ptr("West US"),
		Properties: &armconfluent.OrganizationResourceProperties{
			LinkOrganization: &armconfluent.LinkOrganization{
				Token: to.Ptr("string"),
			},
			OfferDetail: &armconfluent.OfferDetail{
				ID:             to.Ptr("string"),
				PlanID:         to.Ptr("string"),
				PlanName:       to.Ptr("string"),
				PrivateOfferID: to.Ptr("string"),
				PrivateOfferIDs: []*string{
					to.Ptr("string")},
				PublisherID: to.Ptr("string"),
				TermUnit:    to.Ptr("string"),
			},
			UserDetail: &armconfluent.UserDetail{
				AADEmail:          to.Ptr("contoso@microsoft.com"),
				EmailAddress:      to.Ptr("contoso@microsoft.com"),
				FirstName:         to.Ptr("string"),
				LastName:          to.Ptr("string"),
				UserPrincipalName: to.Ptr("contoso@microsoft.com"),
			},
		},
		Tags: map[string]*string{
			"Environment": to.Ptr("Dev"),
		},
	},
	})
	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.OrganizationResource = armconfluent.OrganizationResource{
	// 	Name: to.Ptr("myOrganization"),
	// 	Type: to.Ptr("Microsoft.Confluent/organizations"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Confluent/organizations/myOrganization"),
	// 	Location: to.Ptr("West US"),
	// 	Properties: &armconfluent.OrganizationResourceProperties{
	// 		CreatedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
	// 		OfferDetail: &armconfluent.OfferDetail{
	// 			ID: to.Ptr("string"),
	// 			PlanID: to.Ptr("string"),
	// 			PlanName: to.Ptr("string"),
	// 			PrivateOfferID: to.Ptr("string"),
	// 			PrivateOfferIDs: []*string{
	// 				to.Ptr("string")},
	// 				PublisherID: to.Ptr("string"),
	// 				Status: to.Ptr(armconfluent.SaaSOfferStatusStarted),
	// 				TermUnit: to.Ptr("string"),
	// 			},
	// 			OrganizationID: to.Ptr("string"),
	// 			ProvisioningState: to.Ptr(armconfluent.ProvisionStateSucceeded),
	// 			SsoURL: to.Ptr("string"),
	// 			UserDetail: &armconfluent.UserDetail{
	// 				AADEmail: to.Ptr("contoso@microsoft.com"),
	// 				EmailAddress: to.Ptr("contoso@microsoft.com"),
	// 				FirstName: to.Ptr("string"),
	// 				LastName: to.Ptr("string"),
	// 				UserPrincipalName: to.Ptr("contoso@microsoft.com"),
	// 			},
	// 		},
	// 		SystemData: &armconfluent.SystemData{
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
	// 			CreatedBy: to.Ptr("string"),
	// 			CreatedByType: to.Ptr(armconfluent.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("string"),
	// 			LastModifiedByType: to.Ptr(armconfluent.CreatedByTypeUser),
	// 		},
	// 		Tags: map[string]*string{
	// 			"Environment": to.Ptr("Dev"),
	// 		},
	// 	}
}

Output:

func (*OrganizationClient) BeginDelete 

func (client *OrganizationClient) BeginDelete(ctx context.Context, resourceGroupName string, organizationName string, options *OrganizationClientBeginDeleteOptions) (*runtime.Poller[OrganizationClientDeleteResponse], error)

BeginDelete - Delete Organization resource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - Resource group name
  • organizationName - Organization resource name
  • options - OrganizationClientBeginDeleteOptions contains the optional parameters for the OrganizationClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

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

Output:

func (*OrganizationClient) CreateAPIKey added in v1.3.0 

func (client *OrganizationClient) CreateAPIKey(ctx context.Context, resourceGroupName string, organizationName string, environmentID string, clusterID string, body CreateAPIKeyModel, options *OrganizationClientCreateAPIKeyOptions) (OrganizationClientCreateAPIKeyResponse, error)

CreateAPIKey - Creates API key for a schema registry Cluster ID or Kafka Cluster ID under a environment If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • environmentID - Confluent environment id
  • clusterID - Confluent kafka or schema registry cluster id
  • body - Request payload for get creating API Key for schema registry Cluster ID or Kafka Cluster ID under a environment
  • options - OrganizationClientCreateAPIKeyOptions contains the optional parameters for the OrganizationClient.CreateAPIKey method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_CreateClusterAPIKey.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOrganizationClient().CreateAPIKey(ctx, "myResourceGroup", "myOrganization", "env-12132", "clusterId-123", armconfluent.CreateAPIKeyModel{
		Name:        to.Ptr("CI kafka access key"),
		Description: to.Ptr("This API key provides kafka access to cluster x"),
	}, 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.APIKeyRecord = armconfluent.APIKeyRecord{
	// 	ID: to.Ptr("JDCXTFUVFVQGF56J"),
	// 	Kind: to.Ptr("ApiKey"),
	// 	Properties: &armconfluent.APIKeyProperties{
	// 		Metadata: &armconfluent.SCMetadataEntity{
	// 			CreatedTimestamp: to.Ptr("2023-11-15T16:15:44.489498Z"),
	// 			ResourceName: to.Ptr("crn://api.stag.cpdev.cloud/organization=37d1220b-93a6-43e3-a114-dd8a20a94a31/service-account=sa-wwn7mm/api-key=JDCXTFUVFVQGF56J"),
	// 			Self: to.Ptr("https://api.stag.cpdev.cloud/iam/v2/api-keys/JDCXTFUVFVQGF56J"),
	// 			UpdatedTimestamp: to.Ptr("2023-11-15T16:15:44.489498Z"),
	// 		},
	// 		Spec: &armconfluent.APIKeySpecEntity{
	// 			Name: to.Ptr("CI kafka access key"),
	// 			Description: to.Ptr("This API key provides kafka access to cluster x"),
	// 			Owner: &armconfluent.APIKeyOwnerEntity{
	// 				ID: to.Ptr("sa-wwn7mm"),
	// 				Kind: to.Ptr("ServiceAccount"),
	// 				Related: to.Ptr("https://api.stag.cpdev.cloud/iam/v2/service-accounts/sa-wwn7mm"),
	// 				ResourceName: to.Ptr("crn://api.stag.cpdev.cloud/organization=37d1220b-93a6-43e3-a114-dd8a20a94a31/service-account=sa-wwn7mm"),
	// 			},
	// 			Resource: &armconfluent.APIKeyResourceEntity{
	// 				ID: to.Ptr("lsrc-stgc1yrzz3"),
	// 				Kind: to.Ptr("SchemaRegistry"),
	// 				Related: to.Ptr("https://api.stag.cpdev.cloud/srcm/v2/schema-registries/lsrc-stgc1yrzz3"),
	// 				ResourceName: to.Ptr("crn://api.stag.cpdev.cloud/organization=37d1220b-93a6-43e3-a114-dd8a20a94a31/schema-registry=lsrc-stgc1yrzz3"),
	// 			},
	// 			Secret: to.Ptr(""),
	// 		},
	// 	},
	// }
}

Output:

func (*OrganizationClient) DeleteClusterAPIKey added in v1.3.0 

func (client *OrganizationClient) DeleteClusterAPIKey(ctx context.Context, resourceGroupName string, organizationName string, apiKeyID string, options *OrganizationClientDeleteClusterAPIKeyOptions) (OrganizationClientDeleteClusterAPIKeyResponse, error)

DeleteClusterAPIKey - Deletes API key of a kafka or schema registry cluster If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • apiKeyID - Confluent API Key id
  • options - OrganizationClientDeleteClusterAPIKeyOptions contains the optional parameters for the OrganizationClient.DeleteClusterAPIKey method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_DeleteClusterAPIKey.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewOrganizationClient().DeleteClusterAPIKey(ctx, "myResourceGroup", "myOrganization", "ZFZ6SZZZWGYBEIFB", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*OrganizationClient) Get 

func (client *OrganizationClient) Get(ctx context.Context, resourceGroupName string, organizationName string, options *OrganizationClientGetOptions) (OrganizationClientGetResponse, error)

Get - Get the properties of a specific Organization resource. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - Resource group name
  • organizationName - Organization resource name
  • options - OrganizationClientGetOptions contains the optional parameters for the OrganizationClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOrganizationClient().Get(ctx, "myResourceGroup", "myOrganization", 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.OrganizationResource = armconfluent.OrganizationResource{
	// 	Name: to.Ptr("myOrganization"),
	// 	Type: to.Ptr("Microsoft.Confluent/organizations"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Confluent/organizations/myOrganization"),
	// 	Location: to.Ptr("West US"),
	// 	Properties: &armconfluent.OrganizationResourceProperties{
	// 		CreatedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
	// 		OfferDetail: &armconfluent.OfferDetail{
	// 			ID: to.Ptr("string"),
	// 			PlanID: to.Ptr("string"),
	// 			PlanName: to.Ptr("string"),
	// 			PrivateOfferID: to.Ptr("string"),
	// 			PrivateOfferIDs: []*string{
	// 				to.Ptr("string")},
	// 				PublisherID: to.Ptr("string"),
	// 				Status: to.Ptr(armconfluent.SaaSOfferStatusStarted),
	// 				TermUnit: to.Ptr("string"),
	// 			},
	// 			OrganizationID: to.Ptr("string"),
	// 			ProvisioningState: to.Ptr(armconfluent.ProvisionStateSucceeded),
	// 			SsoURL: to.Ptr("string"),
	// 			UserDetail: &armconfluent.UserDetail{
	// 				AADEmail: to.Ptr("contoso@microsoft.com"),
	// 				EmailAddress: to.Ptr("contoso@microsoft.com"),
	// 				FirstName: to.Ptr("string"),
	// 				LastName: to.Ptr("string"),
	// 				UserPrincipalName: to.Ptr("contoso@microsoft.com"),
	// 			},
	// 		},
	// 		SystemData: &armconfluent.SystemData{
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
	// 			CreatedBy: to.Ptr("string"),
	// 			CreatedByType: to.Ptr(armconfluent.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("string"),
	// 			LastModifiedByType: to.Ptr(armconfluent.CreatedByTypeUser),
	// 		},
	// 		Tags: map[string]*string{
	// 			"Environment": to.Ptr("Dev"),
	// 		},
	// 	}
}

Output:

func (*OrganizationClient) GetClusterAPIKey added in v1.3.0 

func (client *OrganizationClient) GetClusterAPIKey(ctx context.Context, resourceGroupName string, organizationName string, apiKeyID string, options *OrganizationClientGetClusterAPIKeyOptions) (OrganizationClientGetClusterAPIKeyResponse, error)

GetClusterAPIKey - Get API key details of a kafka or schema registry cluster If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • apiKeyID - Confluent API Key id
  • options - OrganizationClientGetClusterAPIKeyOptions contains the optional parameters for the OrganizationClient.GetClusterAPIKey method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_GetClusterAPIKey.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOrganizationClient().GetClusterAPIKey(ctx, "myResourceGroup", "myOrganization", "apiKeyId-123", 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.APIKeyRecord = armconfluent.APIKeyRecord{
	// 	ID: to.Ptr("apiKeyId-123"),
	// 	Kind: to.Ptr("ApiKey"),
	// 	Properties: &armconfluent.APIKeyProperties{
	// 		Metadata: &armconfluent.SCMetadataEntity{
	// 			CreatedTimestamp: to.Ptr("2023-11-15T16:15:44.489498Z"),
	// 			ResourceName: to.Ptr("crn://api.stag.cpdev.cloud/organization=37d1220b-93a6-43e3-a114-dd8a20a94a31/service-account=sa-wwn7mm/api-key=apiKeyId-123"),
	// 			Self: to.Ptr("https://api.stag.cpdev.cloud/iam/v2/api-keys/apiKeyId-123"),
	// 			UpdatedTimestamp: to.Ptr("2023-11-15T16:15:44.489498Z"),
	// 		},
	// 		Spec: &armconfluent.APIKeySpecEntity{
	// 			Name: to.Ptr("CI kafka access key"),
	// 			Description: to.Ptr("This API key provides kafka access to cluster x"),
	// 			Owner: &armconfluent.APIKeyOwnerEntity{
	// 				ID: to.Ptr("sa-wwn7mm"),
	// 				Kind: to.Ptr("ServiceAccount"),
	// 				Related: to.Ptr("https://api.stag.cpdev.cloud/iam/v2/service-accounts/sa-wwn7mm"),
	// 				ResourceName: to.Ptr("crn://api.stag.cpdev.cloud/organization=37d1220b-93a6-43e3-a114-dd8a20a94a31/service-account=sa-wwn7mm"),
	// 			},
	// 			Resource: &armconfluent.APIKeyResourceEntity{
	// 				Environment: to.Ptr("env-0000"),
	// 				ID: to.Ptr("lsrc-stgc1yrzz3"),
	// 				Kind: to.Ptr("SchemaRegistry"),
	// 				Related: to.Ptr("https://api.stag.cpdev.cloud/srcm/v2/schema-registries/lsrc-stgc1yrzz3"),
	// 				ResourceName: to.Ptr("crn://api.stag.cpdev.cloud/organization=37d1220b-93a6-43e3-a114-dd8a20a94a31/schema-registry=lsrc-stgc1yrzz3"),
	// 			},
	// 		},
	// 	},
	// }
}

Output:

func (*OrganizationClient) GetClusterByID added in v1.3.0 

func (client *OrganizationClient) GetClusterByID(ctx context.Context, resourceGroupName string, organizationName string, environmentID string, clusterID string, options *OrganizationClientGetClusterByIDOptions) (OrganizationClientGetClusterByIDResponse, error)

GetClusterByID - Get cluster by Id If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • environmentID - Confluent environment id
  • clusterID - Confluent kafka or schema registry cluster id
  • options - OrganizationClientGetClusterByIDOptions contains the optional parameters for the OrganizationClient.GetClusterByID method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_GetClusterById.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOrganizationClient().GetClusterByID(ctx, "myResourceGroup", "myOrganization", "env-12132", "dlz-f3a90de", 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.SCClusterRecord = armconfluent.SCClusterRecord{
	// 	ID: to.Ptr("dlz-f3a90de"),
	// 	Kind: to.Ptr("Cluster"),
	// 	Properties: &armconfluent.ClusterProperties{
	// 		Metadata: &armconfluent.SCMetadataEntity{
	// 			CreatedTimestamp: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 			DeletedTimestamp: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 			ResourceName: to.Ptr("crn://confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/environment=env-abc123/cloud-cluster=lkc-12345"),
	// 			Self: to.Ptr("https://api.confluent.cloud/cmk/v2/clusters/lkc-12345"),
	// 			UpdatedTimestamp: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 		},
	// 		Spec: &armconfluent.SCClusterSpecEntity{
	// 			Name: to.Ptr("ProdKafkaCluster"),
	// 			APIEndpoint: to.Ptr("https://pkac-00000.us-west-2.aws.confluent.cloud"),
	// 			Availability: to.Ptr("SINGLE_ZONE"),
	// 			Byok: &armconfluent.SCClusterByokEntity{
	// 				ID: to.Ptr("cck-00000"),
	// 				Related: to.Ptr("https://api.confluent.cloud/byok/v1/keys/cck-00000"),
	// 				ResourceName: to.Ptr("https://api.confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/key=cck-00000"),
	// 			},
	// 			Cloud: to.Ptr("GCP"),
	// 			Config: &armconfluent.ClusterConfigEntity{
	// 				Kind: to.Ptr("Basic"),
	// 			},
	// 			Environment: &armconfluent.SCClusterNetworkEnvironmentEntity{
	// 				Environment: to.Ptr("string"),
	// 				ID: to.Ptr("env-00000"),
	// 				Related: to.Ptr("https://api.confluent.cloud/v2/environments/env-00000"),
	// 				ResourceName: to.Ptr("https://api.confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/environment=env-00000"),
	// 			},
	// 			HTTPEndpoint: to.Ptr("https://lkc-00000-00000.us-central1.gcp.glb.confluent.cloud"),
	// 			KafkaBootstrapEndpoint: to.Ptr("lkc-00000-00000.us-central1.gcp.glb.confluent.cloud:9092"),
	// 			Network: &armconfluent.SCClusterNetworkEnvironmentEntity{
	// 				Environment: to.Ptr("string"),
	// 				ID: to.Ptr("n-00000"),
	// 				Related: to.Ptr("https://api.confluent.cloud/networking/v1/networks/n-00000"),
	// 				ResourceName: to.Ptr("https://api.confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/environment=env-abc123/network=n-00000"),
	// 			},
	// 			Region: to.Ptr("us-east4"),
	// 		},
	// 		Status: &armconfluent.ClusterStatusEntity{
	// 			Cku: to.Ptr[int32](2),
	// 			Phase: to.Ptr("PROVISIONED"),
	// 		},
	// 	},
	// }
}

Output:

func (*OrganizationClient) GetEnvironmentByID added in v1.3.0 

func (client *OrganizationClient) GetEnvironmentByID(ctx context.Context, resourceGroupName string, organizationName string, environmentID string, options *OrganizationClientGetEnvironmentByIDOptions) (OrganizationClientGetEnvironmentByIDResponse, error)

GetEnvironmentByID - Get Environment details by environment Id If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • environmentID - Confluent environment id
  • options - OrganizationClientGetEnvironmentByIDOptions contains the optional parameters for the OrganizationClient.GetEnvironmentByID method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_GetEnvironmentById.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOrganizationClient().GetEnvironmentByID(ctx, "myResourceGroup", "myOrganization", "dlz-f3a90de", 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.SCEnvironmentRecord = armconfluent.SCEnvironmentRecord{
	// 	Name: to.Ptr("prod-finance01"),
	// 	ID: to.Ptr("dlz-f3a90de"),
	// 	Kind: to.Ptr("Environment"),
	// 	Properties: &armconfluent.EnvironmentProperties{
	// 		Metadata: &armconfluent.SCMetadataEntity{
	// 			CreatedTimestamp: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 			DeletedTimestamp: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 			ResourceName: to.Ptr("crn://confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/environment=e-12345"),
	// 			Self: to.Ptr("https://api.confluent.cloud/org/v2/environments/e-12345"),
	// 			UpdatedTimestamp: to.Ptr("2006-01-02T15:04:05-07:00"),
	// 		},
	// 	},
	// }
}

Output:

func (*OrganizationClient) GetSchemaRegistryClusterByID added in v1.3.0 

func (client *OrganizationClient) GetSchemaRegistryClusterByID(ctx context.Context, resourceGroupName string, organizationName string, environmentID string, clusterID string, options *OrganizationClientGetSchemaRegistryClusterByIDOptions) (OrganizationClientGetSchemaRegistryClusterByIDResponse, error)

GetSchemaRegistryClusterByID - Get schema registry cluster by Id If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • environmentID - Confluent environment id
  • clusterID - Confluent kafka or schema registry cluster id
  • options - OrganizationClientGetSchemaRegistryClusterByIDOptions contains the optional parameters for the OrganizationClient.GetSchemaRegistryClusterByID method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_GetSchemaRegistryClusterById.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOrganizationClient().GetSchemaRegistryClusterByID(ctx, "myResourceGroup", "myOrganization", "env-stgcczjp2j3", "lsrc-stgczkq22z", 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.SchemaRegistryClusterRecord = armconfluent.SchemaRegistryClusterRecord{
	// 	ID: to.Ptr("lsrc-stgczkq22z"),
	// 	Kind: to.Ptr("Cluster"),
	// 	Properties: &armconfluent.SchemaRegistryClusterProperties{
	// 		Metadata: &armconfluent.SCMetadataEntity{
	// 			CreatedTimestamp: to.Ptr("2023-11-08T07:37:14.309386Z"),
	// 			DeletedTimestamp: to.Ptr("2023-11-08T07:37:14.309386Z"),
	// 			ResourceName: to.Ptr("crn://confluent.cloud/organization=37d1220b-93a6-43e3-a114-dd8a20a94a31/environment=env-stgccnk2mgd/schema-registry=lsrc-stgczkq22z"),
	// 			Self: to.Ptr("https://api.stag.cpdev.cloud/srcm/v2/clusters/lsrc-stgczkq22z"),
	// 			UpdatedTimestamp: to.Ptr("2023-11-08T07:37:14.309386Z"),
	// 		},
	// 		Spec: &armconfluent.SchemaRegistryClusterSpecEntity{
	// 			Name: to.Ptr("Stream Governance Package"),
	// 			Cloud: to.Ptr("GCP"),
	// 			Environment: &armconfluent.SchemaRegistryClusterEnvironmentRegionEntity{
	// 				ID: to.Ptr("env-stgccnk2mgd"),
	// 				Related: to.Ptr("https://api.stag.cpdev.cloud/org/v2/environments/env-stgccnk2mgd"),
	// 				ResourceName: to.Ptr("crn://confluent.cloud/organization=37d1220b-93a6-43e3-a114-dd8a20a94a31/environment=env-stgccnk2mgd"),
	// 			},
	// 			HTTPEndpoint: to.Ptr("https://psrc-57wzyg.centralus.azure.stag.cpdev.cloud"),
	// 			Package: to.Ptr("ADVANCED"),
	// 			Region: &armconfluent.SchemaRegistryClusterEnvironmentRegionEntity{
	// 				ID: to.Ptr("sgreg-7"),
	// 				Related: to.Ptr("https://api.stag.cpdev.cloud/srcm/v2/regions/sgreg-7"),
	// 				ResourceName: to.Ptr("crn://confluent.cloud/schema-registry-region=sgreg-7"),
	// 			},
	// 		},
	// 		Status: &armconfluent.SchemaRegistryClusterStatusEntity{
	// 			Phase: to.Ptr("PROVISIONED"),
	// 		},
	// 	},
	// }
}

Output:

func (*OrganizationClient) ListRegions added in v1.3.0 

func (client *OrganizationClient) ListRegions(ctx context.Context, resourceGroupName string, organizationName string, body ListAccessRequestModel, options *OrganizationClientListRegionsOptions) (OrganizationClientListRegionsResponse, error)

ListRegions - cloud provider regions available for creating Schema Registry clusters. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • body - List Access Request Model
  • options - OrganizationClientListRegionsOptions contains the optional parameters for the OrganizationClient.ListRegions method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_ListRegions.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOrganizationClient().ListRegions(ctx, "myResourceGroup", "myOrganization", armconfluent.ListAccessRequestModel{
		SearchFilters: map[string]*string{
			"cloud":    to.Ptr("azure"),
			"packages": to.Ptr("ADVANCED,ESSENTIALS"),
			"region":   to.Ptr("eastus"),
		},
	}, 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.ListRegionsSuccessResponse = armconfluent.ListRegionsSuccessResponse{
	// 	Data: []*armconfluent.RegionRecord{
	// 		{
	// 			ID: to.Ptr("sgreg-7"),
	// 			Kind: to.Ptr("Region"),
	// 			Properties: &armconfluent.RegionProperties{
	// 				Metadata: &armconfluent.SCMetadataEntity{
	// 					CreatedTimestamp: to.Ptr("2023-04-06T10:24:09.840788Z"),
	// 					ResourceName: to.Ptr("crn://confluent.cloud/schema-registry-region=sgreg-7"),
	// 					Self: to.Ptr("https://api.stag.cpdev.cloud/srcm/v2/regions/sgreg-7"),
	// 					UpdatedTimestamp: to.Ptr("2023-04-06T10:24:09.840788Z"),
	// 				},
	// 				Spec: &armconfluent.RegionSpecEntity{
	// 					Name: to.Ptr("Iowa (centralus)"),
	// 					Cloud: to.Ptr("AZURE"),
	// 					Packages: []*string{
	// 						to.Ptr("ADVANCED")},
	// 						RegionName: to.Ptr("centralus"),
	// 					},
	// 				},
	// 		}},
	// 	}
}

Output:

func (*OrganizationClient) NewListByResourceGroupPager added in v0.4.0 

func (client *OrganizationClient) NewListByResourceGroupPager(resourceGroupName string, options *OrganizationClientListByResourceGroupOptions) *runtime.Pager[OrganizationClientListByResourceGroupResponse]

NewListByResourceGroupPager - List all Organizations under the specified resource group.

Generated from API version 2024-02-13

  • resourceGroupName - Resource group name
  • options - OrganizationClientListByResourceGroupOptions contains the optional parameters for the OrganizationClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_ListByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOrganizationClient().NewListByResourceGroupPager("myResourceGroup", 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.OrganizationResourceListResult = armconfluent.OrganizationResourceListResult{
		// 	Value: []*armconfluent.OrganizationResource{
		// 		{
		// 			Name: to.Ptr("myOrganizations"),
		// 			Type: to.Ptr("Microsoft.Confluent/organizations"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Confluent/organizations/myOrganizations"),
		// 			Location: to.Ptr("West US"),
		// 			Properties: &armconfluent.OrganizationResourceProperties{
		// 				CreatedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
		// 				OfferDetail: &armconfluent.OfferDetail{
		// 					ID: to.Ptr("string"),
		// 					PlanID: to.Ptr("string"),
		// 					PlanName: to.Ptr("string"),
		// 					PrivateOfferID: to.Ptr("string"),
		// 					PrivateOfferIDs: []*string{
		// 						to.Ptr("string")},
		// 						PublisherID: to.Ptr("string"),
		// 						Status: to.Ptr(armconfluent.SaaSOfferStatusStarted),
		// 						TermUnit: to.Ptr("string"),
		// 					},
		// 					OrganizationID: to.Ptr("string"),
		// 					ProvisioningState: to.Ptr(armconfluent.ProvisionStateSucceeded),
		// 					SsoURL: to.Ptr("string"),
		// 					UserDetail: &armconfluent.UserDetail{
		// 						AADEmail: to.Ptr("contoso@microsoft.com"),
		// 						EmailAddress: to.Ptr("contoso@microsoft.com"),
		// 						FirstName: to.Ptr("string"),
		// 						LastName: to.Ptr("string"),
		// 						UserPrincipalName: to.Ptr("contoso@microsoft.com"),
		// 					},
		// 				},
		// 				Tags: map[string]*string{
		// 					"Environment": to.Ptr("Dev"),
		// 				},
		// 		}},
		// 	}
	}
}

Output:

func (*OrganizationClient) NewListBySubscriptionPager added in v0.4.0 

func (client *OrganizationClient) NewListBySubscriptionPager(options *OrganizationClientListBySubscriptionOptions) *runtime.Pager[OrganizationClientListBySubscriptionResponse]

NewListBySubscriptionPager - List all organizations under the specified subscription.

Generated from API version 2024-02-13

  • options - OrganizationClientListBySubscriptionOptions contains the optional parameters for the OrganizationClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_ListBySubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOrganizationClient().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.OrganizationResourceListResult = armconfluent.OrganizationResourceListResult{
		// 	Value: []*armconfluent.OrganizationResource{
		// 		{
		// 			Name: to.Ptr("myOrganizations"),
		// 			Type: to.Ptr("Microsoft.Confluent/organizations"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Confluent/organizations/myOrganizations"),
		// 			Location: to.Ptr("West US"),
		// 			Properties: &armconfluent.OrganizationResourceProperties{
		// 				CreatedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
		// 				OfferDetail: &armconfluent.OfferDetail{
		// 					ID: to.Ptr("string"),
		// 					PlanID: to.Ptr("string"),
		// 					PlanName: to.Ptr("string"),
		// 					PrivateOfferID: to.Ptr("string"),
		// 					PrivateOfferIDs: []*string{
		// 						to.Ptr("string")},
		// 						PublisherID: to.Ptr("string"),
		// 						Status: to.Ptr(armconfluent.SaaSOfferStatusStarted),
		// 						TermUnit: to.Ptr("string"),
		// 					},
		// 					OrganizationID: to.Ptr("string"),
		// 					ProvisioningState: to.Ptr(armconfluent.ProvisionStateSucceeded),
		// 					SsoURL: to.Ptr("string"),
		// 					UserDetail: &armconfluent.UserDetail{
		// 						AADEmail: to.Ptr("contoso@microsoft.com"),
		// 						EmailAddress: to.Ptr("contoso@microsoft.com"),
		// 						FirstName: to.Ptr("string"),
		// 						LastName: to.Ptr("string"),
		// 						UserPrincipalName: to.Ptr("contoso@microsoft.com"),
		// 					},
		// 				},
		// 				Tags: map[string]*string{
		// 					"Environment": to.Ptr("Dev"),
		// 				},
		// 		}},
		// 	}
	}
}

Output:

func (*OrganizationClient) NewListClustersPager added in v1.3.0 

func (client *OrganizationClient) NewListClustersPager(resourceGroupName string, organizationName string, environmentID string, options *OrganizationClientListClustersOptions) *runtime.Pager[OrganizationClientListClustersResponse]

NewListClustersPager - Lists of all the clusters in a environment

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • environmentID - Confluent environment id
  • options - OrganizationClientListClustersOptions contains the optional parameters for the OrganizationClient.NewListClustersPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_ClusterList.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOrganizationClient().NewListClustersPager("myResourceGroup", "myOrganization", "env-12132", &armconfluent.OrganizationClientListClustersOptions{PageSize: to.Ptr[int32](10),
		PageToken: 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.ListClustersSuccessResponse = armconfluent.ListClustersSuccessResponse{
		// 	Value: []*armconfluent.SCClusterRecord{
		// 		{
		// 			ID: to.Ptr("dlz-f3a90de"),
		// 			Kind: to.Ptr("Cluster"),
		// 			Properties: &armconfluent.ClusterProperties{
		// 				Metadata: &armconfluent.SCMetadataEntity{
		// 					CreatedTimestamp: to.Ptr("2006-01-02T15:04:05-07:00"),
		// 					DeletedTimestamp: to.Ptr("2006-01-02T15:04:05-07:00"),
		// 					ResourceName: to.Ptr("crn://confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/environment=env-abc123/cloud-cluster=lkc-12345"),
		// 					Self: to.Ptr("https://api.confluent.cloud/cmk/v2/clusters/lkc-12345"),
		// 					UpdatedTimestamp: to.Ptr("2006-01-02T15:04:05-07:00"),
		// 				},
		// 				Spec: &armconfluent.SCClusterSpecEntity{
		// 					Name: to.Ptr("ProdKafkaCluster"),
		// 					APIEndpoint: to.Ptr("https://pkac-00000.us-west-2.aws.confluent.cloud"),
		// 					Availability: to.Ptr("SINGLE_ZONE"),
		// 					Byok: &armconfluent.SCClusterByokEntity{
		// 						ID: to.Ptr("cck-00000"),
		// 						Related: to.Ptr("https://api.confluent.cloud/byok/v1/keys/cck-00000"),
		// 						ResourceName: to.Ptr("https://api.confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/key=cck-00000"),
		// 					},
		// 					Cloud: to.Ptr("GCP"),
		// 					Config: &armconfluent.ClusterConfigEntity{
		// 						Kind: to.Ptr("Basic"),
		// 					},
		// 					Environment: &armconfluent.SCClusterNetworkEnvironmentEntity{
		// 						Environment: to.Ptr("string"),
		// 						ID: to.Ptr("env-00000"),
		// 						Related: to.Ptr("https://api.confluent.cloud/v2/environments/env-00000"),
		// 						ResourceName: to.Ptr("https://api.confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/environment=env-00000"),
		// 					},
		// 					HTTPEndpoint: to.Ptr("https://lkc-00000-00000.us-central1.gcp.glb.confluent.cloud"),
		// 					KafkaBootstrapEndpoint: to.Ptr("lkc-00000-00000.us-central1.gcp.glb.confluent.cloud:9092"),
		// 					Network: &armconfluent.SCClusterNetworkEnvironmentEntity{
		// 						Environment: to.Ptr("string"),
		// 						ID: to.Ptr("n-00000"),
		// 						Related: to.Ptr("https://api.confluent.cloud/networking/v1/networks/n-00000"),
		// 						ResourceName: to.Ptr("https://api.confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/environment=env-abc123/network=n-00000"),
		// 					},
		// 					Region: to.Ptr("us-east4"),
		// 				},
		// 				Status: &armconfluent.ClusterStatusEntity{
		// 					Cku: to.Ptr[int32](2),
		// 					Phase: to.Ptr("PROVISIONED"),
		// 				},
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*OrganizationClient) NewListEnvironmentsPager added in v1.3.0 

func (client *OrganizationClient) NewListEnvironmentsPager(resourceGroupName string, organizationName string, options *OrganizationClientListEnvironmentsOptions) *runtime.Pager[OrganizationClientListEnvironmentsResponse]

NewListEnvironmentsPager - Lists of all the environments in a organization

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • options - OrganizationClientListEnvironmentsOptions contains the optional parameters for the OrganizationClient.NewListEnvironmentsPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_EnvironmentList.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOrganizationClient().NewListEnvironmentsPager("myResourceGroup", "myOrganization", &armconfluent.OrganizationClientListEnvironmentsOptions{PageSize: to.Ptr[int32](10),
		PageToken: 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.GetEnvironmentsResponse = armconfluent.GetEnvironmentsResponse{
		// 	Value: []*armconfluent.SCEnvironmentRecord{
		// 		{
		// 			Name: to.Ptr("prod-finance01"),
		// 			ID: to.Ptr("dlz-f3a90de"),
		// 			Kind: to.Ptr("Environment"),
		// 			Properties: &armconfluent.EnvironmentProperties{
		// 				Metadata: &armconfluent.SCMetadataEntity{
		// 					CreatedTimestamp: to.Ptr("2006-01-02T15:04:05-07:00"),
		// 					DeletedTimestamp: to.Ptr("2006-01-02T15:04:05-07:00"),
		// 					ResourceName: to.Ptr("crn://confluent.cloud/organization=9bb441c4-edef-46ac-8a41-c49e44a3fd9a/environment=e-12345"),
		// 					Self: to.Ptr("https://api.confluent.cloud/org/v2/environments/e-12345"),
		// 					UpdatedTimestamp: to.Ptr("2006-01-02T15:04:05-07:00"),
		// 				},
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*OrganizationClient) NewListSchemaRegistryClustersPager added in v1.3.0 

func (client *OrganizationClient) NewListSchemaRegistryClustersPager(resourceGroupName string, organizationName string, environmentID string, options *OrganizationClientListSchemaRegistryClustersOptions) *runtime.Pager[OrganizationClientListSchemaRegistryClustersResponse]

NewListSchemaRegistryClustersPager - Get schema registry clusters

Generated from API version 2024-02-13

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • organizationName - Organization resource name
  • environmentID - Confluent environment id
  • options - OrganizationClientListSchemaRegistryClustersOptions contains the optional parameters for the OrganizationClient.NewListSchemaRegistryClustersPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_ListSchemaRegistryClusters.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOrganizationClient().NewListSchemaRegistryClustersPager("myResourceGroup", "myOrganization", "env-stgcczjp2j3", &armconfluent.OrganizationClientListSchemaRegistryClustersOptions{PageSize: nil,
		PageToken: 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.ListSchemaRegistryClustersResponse = armconfluent.ListSchemaRegistryClustersResponse{
		// 	Value: []*armconfluent.SchemaRegistryClusterRecord{
		// 		{
		// 			ID: to.Ptr("lsrc-stgczkq22z"),
		// 			Kind: to.Ptr("Cluster"),
		// 			Properties: &armconfluent.SchemaRegistryClusterProperties{
		// 				Metadata: &armconfluent.SCMetadataEntity{
		// 					CreatedTimestamp: to.Ptr("2023-11-08T07:37:14.309386Z"),
		// 					ResourceName: to.Ptr("crn://confluent.cloud/organization=37d1220b-93a6-43e3-a114-dd8a20a94a31/environment=env-stgccnk2mgd/schema-registry=lsrc-stgczkq22z"),
		// 					Self: to.Ptr("https://api.stag.cpdev.cloud/srcm/v2/clusters/lsrc-stgczkq22z"),
		// 					UpdatedTimestamp: to.Ptr("2023-11-08T07:37:14.309386Z"),
		// 				},
		// 				Spec: &armconfluent.SchemaRegistryClusterSpecEntity{
		// 					Name: to.Ptr("Stream Governance Package"),
		// 					Cloud: to.Ptr("GCP"),
		// 					Environment: &armconfluent.SchemaRegistryClusterEnvironmentRegionEntity{
		// 						ID: to.Ptr("env-stgccnk2mgd"),
		// 						Related: to.Ptr("https://api.stag.cpdev.cloud/org/v2/environments/env-stgccnk2mgd"),
		// 						ResourceName: to.Ptr("crn://confluent.cloud/organization=37d1220b-93a6-43e3-a114-dd8a20a94a31/environment=env-stgccnk2mgd"),
		// 					},
		// 					HTTPEndpoint: to.Ptr("https://psrc-57wzyg.centralus.azure.stag.cpdev.cloud"),
		// 					Package: to.Ptr("ADVANCED"),
		// 					Region: &armconfluent.SchemaRegistryClusterEnvironmentRegionEntity{
		// 						ID: to.Ptr("sgreg-7"),
		// 						Related: to.Ptr("https://api.stag.cpdev.cloud/srcm/v2/regions/sgreg-7"),
		// 						ResourceName: to.Ptr("crn://confluent.cloud/schema-registry-region=sgreg-7"),
		// 					},
		// 				},
		// 				Status: &armconfluent.SchemaRegistryClusterStatusEntity{
		// 					Phase: to.Ptr("PROVISIONED"),
		// 				},
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*OrganizationClient) Update 

func (client *OrganizationClient) Update(ctx context.Context, resourceGroupName string, organizationName string, options *OrganizationClientUpdateOptions) (OrganizationClientUpdateResponse, error)

Update - Update Organization resource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - Resource group name
  • organizationName - Organization resource name
  • options - OrganizationClientUpdateOptions contains the optional parameters for the OrganizationClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Organization_Update.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOrganizationClient().Update(ctx, "myResourceGroup", "myOrganization", &armconfluent.OrganizationClientUpdateOptions{Body: &armconfluent.OrganizationResourceUpdate{
		Tags: map[string]*string{
			"client": to.Ptr("dev-client"),
			"env":    to.Ptr("dev"),
		},
	},
	})
	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.OrganizationResource = armconfluent.OrganizationResource{
	// 	Name: to.Ptr("myOrganization"),
	// 	Type: to.Ptr("Microsoft.Confluent/organizations"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Confluent/organizations/myOrganization"),
	// 	Location: to.Ptr("West US"),
	// 	Properties: &armconfluent.OrganizationResourceProperties{
	// 		CreatedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
	// 		OfferDetail: &armconfluent.OfferDetail{
	// 			ID: to.Ptr("string"),
	// 			PlanID: to.Ptr("string"),
	// 			PlanName: to.Ptr("string"),
	// 			PublisherID: to.Ptr("string"),
	// 			Status: to.Ptr(armconfluent.SaaSOfferStatusStarted),
	// 			TermUnit: to.Ptr("string"),
	// 		},
	// 		OrganizationID: to.Ptr("string"),
	// 		ProvisioningState: to.Ptr(armconfluent.ProvisionStateSucceeded),
	// 		SsoURL: to.Ptr("string"),
	// 		UserDetail: &armconfluent.UserDetail{
	// 			AADEmail: to.Ptr("contoso@microsoft.com"),
	// 			EmailAddress: to.Ptr("contoso@microsoft.com"),
	// 			FirstName: to.Ptr("string"),
	// 			LastName: to.Ptr("string"),
	// 			UserPrincipalName: to.Ptr("contoso@microsoft.com"),
	// 		},
	// 	},
	// 	SystemData: &armconfluent.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
	// 		CreatedBy: to.Ptr("string"),
	// 		CreatedByType: to.Ptr(armconfluent.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("string"),
	// 		LastModifiedByType: to.Ptr(armconfluent.CreatedByTypeUser),
	// 	},
	// 	Tags: map[string]*string{
	// 		"Environment": to.Ptr("Dev"),
	// 	},
	// }
}

Output:

type OrganizationClientBeginCreateOptions added in v0.2.0 

type OrganizationClientBeginCreateOptions struct {
	// Organization resource model
	Body *OrganizationResource

	// Resumes the LRO from the provided token.
	ResumeToken string
}

OrganizationClientBeginCreateOptions contains the optional parameters for the OrganizationClient.BeginCreate method.

type OrganizationClientBeginDeleteOptions added in v0.2.0 

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

OrganizationClientBeginDeleteOptions contains the optional parameters for the OrganizationClient.BeginDelete method.

type OrganizationClientCreateAPIKeyOptions added in v1.3.0 

type OrganizationClientCreateAPIKeyOptions struct {
}

OrganizationClientCreateAPIKeyOptions contains the optional parameters for the OrganizationClient.CreateAPIKey method.

type OrganizationClientCreateAPIKeyResponse added in v1.3.0 

type OrganizationClientCreateAPIKeyResponse struct {
	// Details API key
	APIKeyRecord
}

OrganizationClientCreateAPIKeyResponse contains the response from method OrganizationClient.CreateAPIKey.

type OrganizationClientCreateResponse added in v0.2.0 

type OrganizationClientCreateResponse struct {
	// Organization resource.
	OrganizationResource
}

OrganizationClientCreateResponse contains the response from method OrganizationClient.BeginCreate.

type OrganizationClientDeleteClusterAPIKeyOptions added in v1.3.0 

type OrganizationClientDeleteClusterAPIKeyOptions struct {
}

OrganizationClientDeleteClusterAPIKeyOptions contains the optional parameters for the OrganizationClient.DeleteClusterAPIKey method.

type OrganizationClientDeleteClusterAPIKeyResponse added in v1.3.0 

type OrganizationClientDeleteClusterAPIKeyResponse struct {
}

OrganizationClientDeleteClusterAPIKeyResponse contains the response from method OrganizationClient.DeleteClusterAPIKey.

type OrganizationClientDeleteResponse added in v0.2.0 

type OrganizationClientDeleteResponse struct {
}

OrganizationClientDeleteResponse contains the response from method OrganizationClient.BeginDelete.

type OrganizationClientGetClusterAPIKeyOptions added in v1.3.0 

type OrganizationClientGetClusterAPIKeyOptions struct {
}

OrganizationClientGetClusterAPIKeyOptions contains the optional parameters for the OrganizationClient.GetClusterAPIKey method.

type OrganizationClientGetClusterAPIKeyResponse added in v1.3.0 

type OrganizationClientGetClusterAPIKeyResponse struct {
	// Details API key
	APIKeyRecord
}

OrganizationClientGetClusterAPIKeyResponse contains the response from method OrganizationClient.GetClusterAPIKey.

type OrganizationClientGetClusterByIDOptions added in v1.3.0 

type OrganizationClientGetClusterByIDOptions struct {
}

OrganizationClientGetClusterByIDOptions contains the optional parameters for the OrganizationClient.GetClusterByID method.

type OrganizationClientGetClusterByIDResponse added in v1.3.0 

type OrganizationClientGetClusterByIDResponse struct {
	// Details of cluster record
	SCClusterRecord
}

OrganizationClientGetClusterByIDResponse contains the response from method OrganizationClient.GetClusterByID.

type OrganizationClientGetEnvironmentByIDOptions added in v1.3.0 

type OrganizationClientGetEnvironmentByIDOptions struct {
}

OrganizationClientGetEnvironmentByIDOptions contains the optional parameters for the OrganizationClient.GetEnvironmentByID method.

type OrganizationClientGetEnvironmentByIDResponse added in v1.3.0 

type OrganizationClientGetEnvironmentByIDResponse struct {
	// Details about environment name, metadata and environment id of an environment
	SCEnvironmentRecord
}

OrganizationClientGetEnvironmentByIDResponse contains the response from method OrganizationClient.GetEnvironmentByID.

type OrganizationClientGetOptions added in v0.2.0 

type OrganizationClientGetOptions struct {
}

OrganizationClientGetOptions contains the optional parameters for the OrganizationClient.Get method.

type OrganizationClientGetResponse added in v0.2.0 

type OrganizationClientGetResponse struct {
	// Organization resource.
	OrganizationResource
}

OrganizationClientGetResponse contains the response from method OrganizationClient.Get.

type OrganizationClientGetSchemaRegistryClusterByIDOptions added in v1.3.0 

type OrganizationClientGetSchemaRegistryClusterByIDOptions struct {
}

OrganizationClientGetSchemaRegistryClusterByIDOptions contains the optional parameters for the OrganizationClient.GetSchemaRegistryClusterByID method.

type OrganizationClientGetSchemaRegistryClusterByIDResponse added in v1.3.0 

type OrganizationClientGetSchemaRegistryClusterByIDResponse struct {
	// Details of schema registry cluster record
	SchemaRegistryClusterRecord
}

OrganizationClientGetSchemaRegistryClusterByIDResponse contains the response from method OrganizationClient.GetSchemaRegistryClusterByID.

type OrganizationClientListByResourceGroupOptions added in v0.2.0 

type OrganizationClientListByResourceGroupOptions struct {
}

OrganizationClientListByResourceGroupOptions contains the optional parameters for the OrganizationClient.NewListByResourceGroupPager method.

type OrganizationClientListByResourceGroupResponse added in v0.2.0 

type OrganizationClientListByResourceGroupResponse struct {
	// The response of a list operation.
	OrganizationResourceListResult
}

OrganizationClientListByResourceGroupResponse contains the response from method OrganizationClient.NewListByResourceGroupPager.

type OrganizationClientListBySubscriptionOptions added in v0.2.0 

type OrganizationClientListBySubscriptionOptions struct {
}

OrganizationClientListBySubscriptionOptions contains the optional parameters for the OrganizationClient.NewListBySubscriptionPager method.

type OrganizationClientListBySubscriptionResponse added in v0.2.0 

type OrganizationClientListBySubscriptionResponse struct {
	// The response of a list operation.
	OrganizationResourceListResult
}

OrganizationClientListBySubscriptionResponse contains the response from method OrganizationClient.NewListBySubscriptionPager.

type OrganizationClientListClustersOptions added in v1.3.0 

type OrganizationClientListClustersOptions struct {
	// Pagination size
	PageSize *int32

	// An opaque pagination token to fetch the next set of records
	PageToken *string
}

OrganizationClientListClustersOptions contains the optional parameters for the OrganizationClient.NewListClustersPager method.

type OrganizationClientListClustersResponse added in v1.3.0 

type OrganizationClientListClustersResponse struct {
	// Result of GET request to list clusters in the environment of a confluent organization
	ListClustersSuccessResponse
}

OrganizationClientListClustersResponse contains the response from method OrganizationClient.NewListClustersPager.

type OrganizationClientListEnvironmentsOptions added in v1.3.0 

type OrganizationClientListEnvironmentsOptions struct {
	// Pagination size
	PageSize *int32

	// An opaque pagination token to fetch the next set of records
	PageToken *string
}

OrganizationClientListEnvironmentsOptions contains the optional parameters for the OrganizationClient.NewListEnvironmentsPager method.

type OrganizationClientListEnvironmentsResponse added in v1.3.0 

type OrganizationClientListEnvironmentsResponse struct {
	// Result of GET request to list Confluent operations.
	GetEnvironmentsResponse
}

OrganizationClientListEnvironmentsResponse contains the response from method OrganizationClient.NewListEnvironmentsPager.

type OrganizationClientListRegionsOptions added in v1.3.0 

type OrganizationClientListRegionsOptions struct {
}

OrganizationClientListRegionsOptions contains the optional parameters for the OrganizationClient.ListRegions method.

type OrganizationClientListRegionsResponse added in v1.3.0 

type OrganizationClientListRegionsResponse struct {
	// Result of POST request to list regions supported by confluent
	ListRegionsSuccessResponse
}

OrganizationClientListRegionsResponse contains the response from method OrganizationClient.ListRegions.

type OrganizationClientListSchemaRegistryClustersOptions added in v1.3.0 

type OrganizationClientListSchemaRegistryClustersOptions struct {
	// Pagination size
	PageSize *int32

	// An opaque pagination token to fetch the next set of records
	PageToken *string
}

OrganizationClientListSchemaRegistryClustersOptions contains the optional parameters for the OrganizationClient.NewListSchemaRegistryClustersPager method.

type OrganizationClientListSchemaRegistryClustersResponse added in v1.3.0 

type OrganizationClientListSchemaRegistryClustersResponse struct {
	// Result of GET request to list schema registry clusters in the environment of a confluent organization
	ListSchemaRegistryClustersResponse
}

OrganizationClientListSchemaRegistryClustersResponse contains the response from method OrganizationClient.NewListSchemaRegistryClustersPager.

type OrganizationClientUpdateOptions added in v0.2.0 

type OrganizationClientUpdateOptions struct {
	// Updated Organization resource
	Body *OrganizationResourceUpdate
}

OrganizationClientUpdateOptions contains the optional parameters for the OrganizationClient.Update method.

type OrganizationClientUpdateResponse added in v0.2.0 

type OrganizationClientUpdateResponse struct {
	// Organization resource.
	OrganizationResource
}

OrganizationClientUpdateResponse contains the response from method OrganizationClient.Update.

type OrganizationOperationsClient 

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

OrganizationOperationsClient contains the methods for the OrganizationOperations group. Don't use this type directly, use NewOrganizationOperationsClient() instead.

func NewOrganizationOperationsClient 

func NewOrganizationOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OrganizationOperationsClient, error)

NewOrganizationOperationsClient creates a new instance of OrganizationOperationsClient with the specified values.

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

func (*OrganizationOperationsClient) NewListPager added in v0.4.0 

func (client *OrganizationOperationsClient) NewListPager(options *OrganizationOperationsClientListOptions) *runtime.Pager[OrganizationOperationsClientListResponse]

NewListPager - List all operations provided by Microsoft.Confluent.

Generated from API version 2024-02-13

  • options - OrganizationOperationsClientListOptions contains the optional parameters for the OrganizationOperationsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/OrganizationOperations_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOrganizationOperationsClient().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.OperationListResult = armconfluent.OperationListResult{
		// 	Value: []*armconfluent.OperationResult{
		// 		{
		// 			Name: to.Ptr("Microsoft.Confluent/organizations/Read"),
		// 			Display: &armconfluent.OperationDisplay{
		// 				Description: to.Ptr("Read organization"),
		// 				Operation: to.Ptr("Get/List organization resources"),
		// 				Provider: to.Ptr("Microsoft.Confluent"),
		// 				Resource: to.Ptr("organizations"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.Confluent/organizations/Write"),
		// 			Display: &armconfluent.OperationDisplay{
		// 				Description: to.Ptr("Write organization"),
		// 				Operation: to.Ptr("Create/Update organization resources"),
		// 				Provider: to.Ptr("Microsoft.Confluent"),
		// 				Resource: to.Ptr("organizations"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.Confluent/organizations/Delete"),
		// 			Display: &armconfluent.OperationDisplay{
		// 				Description: to.Ptr("Delete organization"),
		// 				Operation: to.Ptr("Delete organization resources"),
		// 				Provider: to.Ptr("Microsoft.Confluent"),
		// 				Resource: to.Ptr("organizations"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 	}},
		// }
	}
}

Output:

type OrganizationOperationsClientListOptions added in v0.2.0 

type OrganizationOperationsClientListOptions struct {
}

OrganizationOperationsClientListOptions contains the optional parameters for the OrganizationOperationsClient.NewListPager method.

type OrganizationOperationsClientListResponse added in v0.2.0 

type OrganizationOperationsClientListResponse struct {
	// Result of GET request to list Confluent operations.
	OperationListResult
}

OrganizationOperationsClientListResponse contains the response from method OrganizationOperationsClient.NewListPager.

type OrganizationResource 

type OrganizationResource struct {
	// REQUIRED; Organization resource properties
	Properties *OrganizationResourceProperties

	// Location of Organization resource
	Location *string

	// Organization resource tags
	Tags map[string]*string

	// READ-ONLY; The ARM id of the resource.
	ID *string

	// READ-ONLY; The name of the resource.
	Name *string

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource
	SystemData *SystemData

	// READ-ONLY; The type of the resource.
	Type *string
}

OrganizationResource - Organization resource.

func (OrganizationResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OrganizationResource.

func (*OrganizationResource) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OrganizationResource.

type OrganizationResourceListResult 

type OrganizationResourceListResult struct {
	// Link to the next set of results, if any.
	NextLink *string

	// Result of a list operation.
	Value []*OrganizationResource
}

OrganizationResourceListResult - The response of a list operation.

func (OrganizationResourceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OrganizationResourceListResult.

func (*OrganizationResourceListResult) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OrganizationResourceListResult.

type OrganizationResourceProperties 

type OrganizationResourceProperties struct {
	// REQUIRED; Confluent offer detail
	OfferDetail *OfferDetail

	// REQUIRED; Subscriber detail
	UserDetail *UserDetail

	// Link an existing Confluent organization
	LinkOrganization *LinkOrganization

	// READ-ONLY; The creation time of the resource.
	CreatedTime *time.Time

	// READ-ONLY; Id of the Confluent organization.
	OrganizationID *string

	// READ-ONLY; Provision states for confluent RP
	ProvisioningState *ProvisionState

	// READ-ONLY; SSO url for the Confluent organization.
	SsoURL *string
}

OrganizationResourceProperties - Organization resource property

func (OrganizationResourceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OrganizationResourceProperties.

func (*OrganizationResourceProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OrganizationResourceProperties.

type OrganizationResourceUpdate 

type OrganizationResourceUpdate struct {
	// ARM resource tags
	Tags map[string]*string
}

OrganizationResourceUpdate - Organization Resource update

func (OrganizationResourceUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OrganizationResourceUpdate.

func (*OrganizationResourceUpdate) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OrganizationResourceUpdate.

type ProvisionState 

type ProvisionState string

ProvisionState - Provision states for confluent RP 

const (
	ProvisionStateAccepted     ProvisionState = "Accepted"
	ProvisionStateCanceled     ProvisionState = "Canceled"
	ProvisionStateCreating     ProvisionState = "Creating"
	ProvisionStateDeleted      ProvisionState = "Deleted"
	ProvisionStateDeleting     ProvisionState = "Deleting"
	ProvisionStateFailed       ProvisionState = "Failed"
	ProvisionStateNotSpecified ProvisionState = "NotSpecified"
	ProvisionStateSucceeded    ProvisionState = "Succeeded"
	ProvisionStateUpdating     ProvisionState = "Updating"
)

func PossibleProvisionStateValues 

func PossibleProvisionStateValues() []ProvisionState

PossibleProvisionStateValues returns the possible values for the ProvisionState const type.

type RegionProperties added in v1.3.0 

type RegionProperties struct {
	// Metadata of the record
	Metadata *SCMetadataEntity

	// Specification of the region
	Spec *RegionSpecEntity
}

RegionProperties - Region Properties

func (RegionProperties) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type RegionProperties.

func (*RegionProperties) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type RegionProperties.

type RegionRecord added in v1.3.0 

type RegionRecord struct {
	// Id of the cluster
	ID *string

	// Kind of the cluster
	Kind *string

	// Region Properties
	Properties *RegionProperties
}

RegionRecord - Details of region record

func (RegionRecord) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type RegionRecord.

func (*RegionRecord) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type RegionRecord.

type RegionSpecEntity added in v1.3.0 

type RegionSpecEntity struct {
	// Cloud provider name
	Cloud *string

	// Display Name of the region
	Name     *string
	Packages []*string

	// Region name
	RegionName *string
}

RegionSpecEntity - Region spec details

func (RegionSpecEntity) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type RegionSpecEntity.

func (*RegionSpecEntity) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type RegionSpecEntity.

type ResourceProviderDefaultErrorResponse 

type ResourceProviderDefaultErrorResponse struct {
	// READ-ONLY; Response body of Error
	Error *ErrorResponseBody
}

ResourceProviderDefaultErrorResponse - Default error response for resource provider

func (ResourceProviderDefaultErrorResponse) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type ResourceProviderDefaultErrorResponse.

func (*ResourceProviderDefaultErrorResponse) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceProviderDefaultErrorResponse.

type RoleBindingRecord added in v1.2.0 

type RoleBindingRecord struct {
	// A CRN that specifies the scope and resource patterns necessary for the role to bind
	CrnPattern *string

	// Id of the role binding
	ID *string

	// The type of the resource.
	Kind *string

	// Metadata of the record
	Metadata *MetadataEntity

	// The principal User or Group to bind the role to
	Principal *string

	// The name of the role to bind to the principal
	RoleName *string
}

RoleBindingRecord - Details on principal, role name and crn pattern of a role binding

func (RoleBindingRecord) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type RoleBindingRecord.

func (*RoleBindingRecord) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type RoleBindingRecord.

type SCClusterByokEntity added in v1.3.0 

type SCClusterByokEntity struct {
	// ID of the referred resource
	ID *string

	// API URL for accessing or modifying the referred object
	Related *string

	// CRN reference to the referred resource
	ResourceName *string
}

SCClusterByokEntity - The network associated with this object

func (SCClusterByokEntity) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SCClusterByokEntity.

func (*SCClusterByokEntity) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SCClusterByokEntity.

type SCClusterNetworkEnvironmentEntity added in v1.3.0 

type SCClusterNetworkEnvironmentEntity struct {
	// Environment of the referred resource
	Environment *string

	// ID of the referred resource
	ID *string

	// API URL for accessing or modifying the referred object
	Related *string

	// CRN reference to the referred resource
	ResourceName *string
}

SCClusterNetworkEnvironmentEntity - The environment or the network to which cluster belongs

func (SCClusterNetworkEnvironmentEntity) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SCClusterNetworkEnvironmentEntity.

func (*SCClusterNetworkEnvironmentEntity) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SCClusterNetworkEnvironmentEntity.

type SCClusterRecord added in v1.3.0 

type SCClusterRecord struct {
	// Id of the cluster
	ID *string

	// Type of cluster
	Kind *string

	// Display name of the cluster
	Name *string

	// Cluster Properties
	Properties *ClusterProperties
}

SCClusterRecord - Details of cluster record

func (SCClusterRecord) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SCClusterRecord.

func (*SCClusterRecord) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SCClusterRecord.

type SCClusterSpecEntity added in v1.3.0 

type SCClusterSpecEntity struct {
	// The Kafka API cluster endpoint
	APIEndpoint *string

	// The availability zone configuration of the cluster
	Availability *string

	// Specification of the cluster byok
	Byok *SCClusterByokEntity

	// The cloud service provider
	Cloud *string

	// Specification of the cluster configuration
	Config *ClusterConfigEntity

	// Specification of the cluster environment
	Environment *SCClusterNetworkEnvironmentEntity

	// The cluster HTTP request URL.
	HTTPEndpoint *string

	// The bootstrap endpoint used by Kafka clients to connect to the cluster
	KafkaBootstrapEndpoint *string

	// The name of the cluster
	Name *string

	// Specification of the cluster network
	Network *SCClusterNetworkEnvironmentEntity

	// The cloud service provider region
	Region *string

	// type of zone availability
	Zone *string
}

SCClusterSpecEntity - Spec of the cluster record

func (SCClusterSpecEntity) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SCClusterSpecEntity.

func (*SCClusterSpecEntity) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SCClusterSpecEntity.

type SCConfluentListMetadata added in v1.3.0 

type SCConfluentListMetadata struct {
	// First page of the list
	First *string

	// Last page of the list
	Last *string

	// Next page of the list
	Next *string

	// Previous page of the list
	Prev *string

	// Total size of the list
	TotalSize *int32
}

SCConfluentListMetadata - Metadata of the list

func (SCConfluentListMetadata) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SCConfluentListMetadata.

func (*SCConfluentListMetadata) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SCConfluentListMetadata.

type SCEnvironmentRecord added in v1.3.0 

type SCEnvironmentRecord struct {
	// Id of the environment
	ID *string

	// Type of environment
	Kind *string

	// Display name of the environment
	Name *string

	// Environment properties
	Properties *EnvironmentProperties
}

SCEnvironmentRecord - Details about environment name, metadata and environment id of an environment

func (SCEnvironmentRecord) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SCEnvironmentRecord.

func (*SCEnvironmentRecord) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SCEnvironmentRecord.

type SCMetadataEntity added in v1.3.0 

type SCMetadataEntity struct {
	// Created Date Time
	CreatedTimestamp *string

	// Deleted Date time
	DeletedTimestamp *string

	// Resource name of the record
	ResourceName *string

	// Self lookup url
	Self *string

	// Updated Date time
	UpdatedTimestamp *string
}

SCMetadataEntity - Metadata of the data record

func (SCMetadataEntity) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SCMetadataEntity.

func (*SCMetadataEntity) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SCMetadataEntity.

type SaaSOfferStatus 

type SaaSOfferStatus string

SaaSOfferStatus - SaaS Offer Status for confluent RP 

const (
	SaaSOfferStatusFailed                  SaaSOfferStatus = "Failed"
	SaaSOfferStatusInProgress              SaaSOfferStatus = "InProgress"
	SaaSOfferStatusPendingFulfillmentStart SaaSOfferStatus = "PendingFulfillmentStart"
	SaaSOfferStatusReinstated              SaaSOfferStatus = "Reinstated"
	SaaSOfferStatusStarted                 SaaSOfferStatus = "Started"
	SaaSOfferStatusSubscribed              SaaSOfferStatus = "Subscribed"
	SaaSOfferStatusSucceeded               SaaSOfferStatus = "Succeeded"
	SaaSOfferStatusSuspended               SaaSOfferStatus = "Suspended"
	SaaSOfferStatusUnsubscribed            SaaSOfferStatus = "Unsubscribed"
	SaaSOfferStatusUpdating                SaaSOfferStatus = "Updating"
)

func PossibleSaaSOfferStatusValues 

func PossibleSaaSOfferStatusValues() []SaaSOfferStatus

PossibleSaaSOfferStatusValues returns the possible values for the SaaSOfferStatus const type.

type SchemaRegistryClusterEnvironmentRegionEntity added in v1.3.0 

type SchemaRegistryClusterEnvironmentRegionEntity struct {
	// ID of the referred resource
	ID *string

	// API URL for accessing or modifying the referred object
	Related *string

	// CRN reference to the referred resource
	ResourceName *string
}

SchemaRegistryClusterEnvironmentRegionEntity - The environment associated with this object

func (SchemaRegistryClusterEnvironmentRegionEntity) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SchemaRegistryClusterEnvironmentRegionEntity.

func (*SchemaRegistryClusterEnvironmentRegionEntity) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SchemaRegistryClusterEnvironmentRegionEntity.

type SchemaRegistryClusterProperties added in v1.3.0 

type SchemaRegistryClusterProperties struct {
	// Metadata of the record
	Metadata *SCMetadataEntity

	// Specification of the schema registry cluster
	Spec *SchemaRegistryClusterSpecEntity

	// Specification of the cluster status
	Status *SchemaRegistryClusterStatusEntity
}

SchemaRegistryClusterProperties - Schema Registry Cluster Properties

func (SchemaRegistryClusterProperties) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SchemaRegistryClusterProperties.

func (*SchemaRegistryClusterProperties) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SchemaRegistryClusterProperties.

type SchemaRegistryClusterRecord added in v1.3.0 

type SchemaRegistryClusterRecord struct {
	// Id of the cluster
	ID *string

	// Kind of the cluster
	Kind *string

	// Schema Registry Cluster Properties
	Properties *SchemaRegistryClusterProperties
}

SchemaRegistryClusterRecord - Details of schema registry cluster record

func (SchemaRegistryClusterRecord) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SchemaRegistryClusterRecord.

func (*SchemaRegistryClusterRecord) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SchemaRegistryClusterRecord.

type SchemaRegistryClusterSpecEntity added in v1.3.0 

type SchemaRegistryClusterSpecEntity struct {
	// The cloud service provider
	Cloud *string

	// Environment details of the schema registry cluster
	Environment *SchemaRegistryClusterEnvironmentRegionEntity

	// Http endpoint of the cluster
	HTTPEndpoint *string

	// Name of the schema registry cluster
	Name *string

	// Type of the cluster package Advanced, essentials
	Package *string

	// Region details of the schema registry cluster
	Region *SchemaRegistryClusterEnvironmentRegionEntity
}

SchemaRegistryClusterSpecEntity - Details of schema registry cluster spec

func (SchemaRegistryClusterSpecEntity) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SchemaRegistryClusterSpecEntity.

func (*SchemaRegistryClusterSpecEntity) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SchemaRegistryClusterSpecEntity.

type SchemaRegistryClusterStatusEntity added in v1.3.0 

type SchemaRegistryClusterStatusEntity struct {
	// The lifecycle phase of the cluster
	Phase *string
}

SchemaRegistryClusterStatusEntity - Status of the schema registry cluster record

func (SchemaRegistryClusterStatusEntity) MarshalJSON added in v1.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SchemaRegistryClusterStatusEntity.

func (*SchemaRegistryClusterStatusEntity) UnmarshalJSON added in v1.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SchemaRegistryClusterStatusEntity.

type ServiceAccountRecord added in v1.2.0 

type ServiceAccountRecord struct {
	// Description of the service account
	Description *string

	// Name of the service account
	DisplayName *string

	// Id of the service account
	ID *string

	// Type of account
	Kind *string

	// Metadata of the record
	Metadata *MetadataEntity
}

ServiceAccountRecord - Record of the service account

func (ServiceAccountRecord) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type ServiceAccountRecord.

func (*ServiceAccountRecord) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceAccountRecord.

type SystemData 

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

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

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

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

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

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

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

func (SystemData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type UserDetail 

type UserDetail struct {
	// REQUIRED; Email address
	EmailAddress *string

	// AAD email address
	AADEmail *string

	// First name
	FirstName *string

	// Last name
	LastName *string

	// User principal name
	UserPrincipalName *string
}

UserDetail - Subscriber detail

func (UserDetail) MarshalJSON added in v1.1.0 

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

MarshalJSON implements the json.Marshaller interface for type UserDetail.

func (*UserDetail) UnmarshalJSON added in v1.1.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UserDetail.

type UserRecord added in v1.2.0 

type UserRecord struct {
	// Auth type of the user
	AuthType *string

	// Email of the user
	Email *string

	// Name of the user
	FullName *string

	// Id of the user
	ID *string

	// Type of account
	Kind *string

	// Metadata of the record
	Metadata *MetadataEntity
}

UserRecord - Record of the user

func (UserRecord) MarshalJSON added in v1.2.0 

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

MarshalJSON implements the json.Marshaller interface for type UserRecord.

func (*UserRecord) UnmarshalJSON added in v1.2.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UserRecord.

type ValidationResponse added in v1.2.0 

type ValidationResponse struct {
	// Info from the response
	Info map[string]*string
}

ValidationResponse - Validation response from the provider

func (ValidationResponse) MarshalJSON added in v1.2.0 

func (v ValidationResponse) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ValidationResponse.

func (*ValidationResponse) UnmarshalJSON added in v1.2.0 

func (v *ValidationResponse) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ValidationResponse.

type ValidationsClient 

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

ValidationsClient contains the methods for the Validations group. Don't use this type directly, use NewValidationsClient() instead.

func NewValidationsClient 

func NewValidationsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ValidationsClient, error)

NewValidationsClient creates a new instance of ValidationsClient with the specified values.

  • subscriptionID - Microsoft Azure subscription id
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ValidationsClient) ValidateOrganization 

func (client *ValidationsClient) ValidateOrganization(ctx context.Context, resourceGroupName string, organizationName string, body OrganizationResource, options *ValidationsClientValidateOrganizationOptions) (ValidationsClientValidateOrganizationResponse, error)

ValidateOrganization - Organization Validate proxy resource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - Resource group name
  • organizationName - Organization resource name
  • body - Organization resource model
  • options - ValidationsClientValidateOrganizationOptions contains the optional parameters for the ValidationsClient.ValidateOrganization method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Validations_ValidateOrganizations.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewValidationsClient().ValidateOrganization(ctx, "myResourceGroup", "myOrganization", armconfluent.OrganizationResource{
		Location: to.Ptr("West US"),
		Properties: &armconfluent.OrganizationResourceProperties{
			OfferDetail: &armconfluent.OfferDetail{
				ID:             to.Ptr("string"),
				PlanID:         to.Ptr("string"),
				PlanName:       to.Ptr("string"),
				PrivateOfferID: to.Ptr("string"),
				PrivateOfferIDs: []*string{
					to.Ptr("string")},
				PublisherID: to.Ptr("string"),
				TermUnit:    to.Ptr("string"),
			},
			UserDetail: &armconfluent.UserDetail{
				AADEmail:          to.Ptr("abc@microsoft.com"),
				EmailAddress:      to.Ptr("abc@microsoft.com"),
				FirstName:         to.Ptr("string"),
				LastName:          to.Ptr("string"),
				UserPrincipalName: to.Ptr("abc@microsoft.com"),
			},
		},
		Tags: map[string]*string{
			"Environment": to.Ptr("Dev"),
		},
	}, 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.OrganizationResource = armconfluent.OrganizationResource{
	// 	Name: to.Ptr("myOrganization"),
	// 	Type: to.Ptr("Microsoft.Confluent/organizations"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Confluent/organizations/myOrganization"),
	// 	Location: to.Ptr("West US"),
	// 	Properties: &armconfluent.OrganizationResourceProperties{
	// 		CreatedTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-05-09T14:28:47.284Z"); return t}()),
	// 		OfferDetail: &armconfluent.OfferDetail{
	// 			ID: to.Ptr("string"),
	// 			PlanID: to.Ptr("string"),
	// 			PlanName: to.Ptr("string"),
	// 			PrivateOfferID: to.Ptr("string"),
	// 			PrivateOfferIDs: []*string{
	// 				to.Ptr("string")},
	// 				PublisherID: to.Ptr("string"),
	// 				Status: to.Ptr(armconfluent.SaaSOfferStatusStarted),
	// 				TermUnit: to.Ptr("string"),
	// 			},
	// 			OrganizationID: to.Ptr("string"),
	// 			ProvisioningState: to.Ptr(armconfluent.ProvisionStateSucceeded),
	// 			SsoURL: to.Ptr("string"),
	// 			UserDetail: &armconfluent.UserDetail{
	// 				AADEmail: to.Ptr("abc@microsoft.com"),
	// 				EmailAddress: to.Ptr("abc@microsoft.com"),
	// 				FirstName: to.Ptr("string"),
	// 				LastName: to.Ptr("string"),
	// 				UserPrincipalName: to.Ptr("abc@microsoft.com"),
	// 			},
	// 		},
	// 		Tags: map[string]*string{
	// 			"Environment": to.Ptr("Dev"),
	// 		},
	// 	}
}

Output:

func (*ValidationsClient) ValidateOrganizationV2 added in v1.2.0 

func (client *ValidationsClient) ValidateOrganizationV2(ctx context.Context, resourceGroupName string, organizationName string, body OrganizationResource, options *ValidationsClientValidateOrganizationV2Options) (ValidationsClientValidateOrganizationV2Response, error)

ValidateOrganizationV2 - Organization Validate proxy resource If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-02-13

  • resourceGroupName - Resource group name
  • organizationName - Organization resource name
  • body - Organization resource model
  • options - ValidationsClientValidateOrganizationV2Options contains the optional parameters for the ValidationsClient.ValidateOrganizationV2 method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/cf5ad1932d00c7d15497705ad6b71171d3d68b1e/specification/confluent/resource-manager/Microsoft.Confluent/stable/2024-02-13/examples/Validations_ValidateOrganizationsV2.json 

package main

import (
	"context"
	"log"

	"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/confluent/armconfluent"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armconfluent.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewValidationsClient().ValidateOrganizationV2(ctx, "myResourceGroup", "myOrganization", armconfluent.OrganizationResource{
		Location: to.Ptr("West US"),
		Properties: &armconfluent.OrganizationResourceProperties{
			OfferDetail: &armconfluent.OfferDetail{
				ID:             to.Ptr("string"),
				PlanID:         to.Ptr("string"),
				PlanName:       to.Ptr("string"),
				PrivateOfferID: to.Ptr("string"),
				PrivateOfferIDs: []*string{
					to.Ptr("string")},
				PublisherID: to.Ptr("string"),
				TermUnit:    to.Ptr("string"),
			},
			UserDetail: &armconfluent.UserDetail{
				AADEmail:          to.Ptr("abc@microsoft.com"),
				EmailAddress:      to.Ptr("abc@microsoft.com"),
				FirstName:         to.Ptr("string"),
				LastName:          to.Ptr("string"),
				UserPrincipalName: to.Ptr("abc@microsoft.com"),
			},
		},
		Tags: map[string]*string{
			"Environment": to.Ptr("Dev"),
		},
	}, 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.ValidationResponse = armconfluent.ValidationResponse{
	// 	Info: map[string]*string{
	// 		"displayMessage": to.Ptr("This is display message"),
	// 	},
	// }
}

Output:

type ValidationsClientValidateOrganizationOptions added in v0.2.0 

type ValidationsClientValidateOrganizationOptions struct {
}

ValidationsClientValidateOrganizationOptions contains the optional parameters for the ValidationsClient.ValidateOrganization method.

type ValidationsClientValidateOrganizationResponse added in v0.2.0 

type ValidationsClientValidateOrganizationResponse struct {
	// Organization resource.
	OrganizationResource
}

ValidationsClientValidateOrganizationResponse contains the response from method ValidationsClient.ValidateOrganization.

type ValidationsClientValidateOrganizationV2Options added in v1.2.0 

type ValidationsClientValidateOrganizationV2Options struct {
}

ValidationsClientValidateOrganizationV2Options contains the optional parameters for the ValidationsClient.ValidateOrganizationV2 method.

type ValidationsClientValidateOrganizationV2Response added in v1.2.0 

type ValidationsClientValidateOrganizationV2Response struct {
	// Validation response from the provider
	ValidationResponse
}

ValidationsClientValidateOrganizationV2Response contains the response from method ValidationsClient.ValidateOrganizationV2.

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.