armconfluent

package module
v1.2.0 Latest Latest
Warning

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

 Go to latest Published: Nov 23, 2023 License: MIT Imports: 14 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.NewOrganizationClient()

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

func (*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 2023-08-22

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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 2023-08-22

  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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 2023-08-22

  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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 2023-08-22

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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) 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 2023-08-22

  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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 2023-08-22

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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 2023-08-22

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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 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 {
	// List cluster success 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 {
	// List environments success 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 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 {
	// List cluster success 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 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 {
	// Data of the environments list
	Data []*ClusterRecord

	// Type of response
	Kind *string

	// Metadata of the list
	Metadata *ListMetadata
}

AccessListClusterSuccessResponse - List cluster success 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 {
	// Data of the environments list
	Data []*EnvironmentRecord

	// Type of response
	Kind *string

	// Metadata of the list
	Metadata *ListMetadata
}

AccessListEnvironmentsSuccessResponse - List environments success 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 {
	// Data of the environments list
	Data []*RoleBindingRecord

	// Type of response
	Kind *string

	// Metadata of the list
	Metadata *ListMetadata
}

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

func (*ClientFactory) 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 ClusterRecord added in v1.2.0 

type ClusterRecord 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

	// Specification of the cluster
	Spec *ClusterSpecEntity

	// Specification of the cluster
	Status *ClusterStatusEntity
}

ClusterRecord - Record of the environment

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

func (*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 2023-08-22

  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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 2023-08-22

  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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 - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*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 2023-08-22

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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 2023-08-22

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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) 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 2023-08-22

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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"),
	// 			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{
	// 			EmailAddress: to.Ptr("contoso@microsoft.com"),
	// 			FirstName: to.Ptr("string"),
	// 			LastName: to.Ptr("string"),
	// 		},
	// 	},
	// 	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) 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 2023-08-22

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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 2023-08-22

  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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) 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 2023-08-22

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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{
	// 			EmailAddress: to.Ptr("contoso@microsoft.com"),
	// 			FirstName: to.Ptr("string"),
	// 			LastName: to.Ptr("string"),
	// 		},
	// 	},
	// 	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 OrganizationClientCreateResponse added in v0.2.0 

type OrganizationClientCreateResponse struct {
	// Organization resource.
	OrganizationResource
}

OrganizationClientCreateResponse contains the response from method OrganizationClient.BeginCreate.

type OrganizationClientDeleteResponse added in v0.2.0 

type OrganizationClientDeleteResponse struct {
}

OrganizationClientDeleteResponse contains the response from method OrganizationClient.BeginDelete.

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 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 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 2023-08-22

  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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 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
	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 - Record of the environment

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

func (*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 2023-08-22

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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 2023-08-22

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • 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/db9788dde7a0c2c0d82e4fdf5f7b4de3843937e3/specification/confluent/resource-manager/Microsoft.Confluent/stable/2023-08-22/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.