armtrustedsigning

package module
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Jun 11, 2026 License: MIT Imports: 14 Imported by: 1

README

Azure Trustedsigning Module for Go

The armtrustedsigning module provides operations for working with Azure Trustedsigning.

Source code

Getting started

Prerequisites

  • an Azure subscription
  • Supported version of Go (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 Trustedsigning module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/trustedsigning/armtrustedsigning

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Trustedsigning. 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 Trustedsigning 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 := armtrustedsigning.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 := armtrustedsigning.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.NewCertificateProfilesClient()

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 Trustedsigning 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 AccountSKU 

type AccountSKU struct {
	// REQUIRED; Name of the SKU.
	Name *SKUName
}

AccountSKU - SKU of the trusted signing account.

func (AccountSKU) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccountSKU.

func (*AccountSKU) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountSKU.

type AccountSKUPatch 

type AccountSKUPatch struct {
	// Name of the SKU.
	Name *SKUName
}

AccountSKUPatch - SKU of the trusted signing account.

func (AccountSKUPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AccountSKUPatch.

func (*AccountSKUPatch) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccountSKUPatch.

type ActionType 

type ActionType string

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

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

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type Certificate 

type Certificate struct {
	// Certificate created date.
	CreatedDate *string

	// Enhanced key usage of the certificate.
	EnhancedKeyUsage *string

	// Certificate expiry date.
	ExpiryDate *string

	// Revocations history of a certificate.
	Revocation *Revocation

	// Serial number of the certificate.
	SerialNumber *string

	// Status of the certificate.
	Status *CertificateStatus

	// Subject name of the certificate.
	SubjectName *string

	// Thumbprint of the certificate.
	Thumbprint *string
}

Certificate - Properties of the certificate.

func (Certificate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Certificate.

func (*Certificate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Certificate.

type CertificateProfile 

type CertificateProfile struct {
	// The resource-specific properties for this resource.
	Properties *CertificateProfileProperties

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

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

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

CertificateProfile - Certificate profile resource.

func (CertificateProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CertificateProfile.

func (*CertificateProfile) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CertificateProfile.

type CertificateProfileListResult 

type CertificateProfileListResult struct {
	// REQUIRED; The CertificateProfile items on this page
	Value []*CertificateProfile

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

CertificateProfileListResult - The response of a CertificateProfile list operation.

func (CertificateProfileListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CertificateProfileListResult.

func (*CertificateProfileListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CertificateProfileListResult.

type CertificateProfileProperties 

type CertificateProfileProperties struct {
	// REQUIRED; Identity validation id used for the certificate subject name.
	IdentityValidationID *string

	// REQUIRED; Profile type of the certificate.
	ProfileType *ProfileType

	// Whether to include L in the certificate subject name. Applicable only for private trust, private trust ci profile types
	IncludeCity *bool

	// Whether to include C in the certificate subject name. Applicable only for private trust, private trust ci profile types
	IncludeCountry *bool

	// Whether to include PC in the certificate subject name.
	IncludePostalCode *bool

	// Whether to include S in the certificate subject name. Applicable only for private trust, private trust ci profile types
	IncludeState *bool

	// Whether to include STREET in the certificate subject name.
	IncludeStreetAddress *bool

	// READ-ONLY; List of renewed certificates.
	Certificates []*Certificate

	// READ-ONLY; Status of the current operation on certificate profile.
	ProvisioningState *ProvisioningState

	// READ-ONLY; Status of the certificate profile.
	Status *CertificateProfileStatus
}

CertificateProfileProperties - Properties of the certificate profile.

func (CertificateProfileProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CertificateProfileProperties.

func (*CertificateProfileProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CertificateProfileProperties.

type CertificateProfileStatus 

type CertificateProfileStatus string

CertificateProfileStatus - Status of the certificate profiles. 

const (
	// CertificateProfileStatusActive - The certificate profile is active.
	CertificateProfileStatusActive CertificateProfileStatus = "Active"
	// CertificateProfileStatusDisabled - The certificate profile is disabled.
	CertificateProfileStatusDisabled CertificateProfileStatus = "Disabled"
	// CertificateProfileStatusSuspended - The certificate profile is suspended.
	CertificateProfileStatusSuspended CertificateProfileStatus = "Suspended"
)

func PossibleCertificateProfileStatusValues 

func PossibleCertificateProfileStatusValues() []CertificateProfileStatus

PossibleCertificateProfileStatusValues returns the possible values for the CertificateProfileStatus const type.

type CertificateProfilesClient 

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

CertificateProfilesClient contains the methods for the CertificateProfiles group. Don't use this type directly, use NewCertificateProfilesClient() instead.

Generated from API version 2025-10-13

func NewCertificateProfilesClient 

func NewCertificateProfilesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*CertificateProfilesClient, error)

NewCertificateProfilesClient creates a new instance of CertificateProfilesClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*CertificateProfilesClient) BeginCreate 

func (client *CertificateProfilesClient) BeginCreate(ctx context.Context, resourceGroupName string, accountName string, profileName string, resource CertificateProfile, options *CertificateProfilesClientBeginCreateOptions) (*runtime.Poller[CertificateProfilesClientCreateResponse], error)

BeginCreate - Create a certificate profile. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - Trusted Signing account name.
  • profileName - Certificate profile name.
  • resource - Parameters to create the certificate profile
  • options - CertificateProfilesClientBeginCreateOptions contains the optional parameters for the CertificateProfilesClient.BeginCreate method.
Example

Generated from example definition: 2025-10-13/CertificateProfiles_Create.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armtrustedsigning.NewClientFactory("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewCertificateProfilesClient().BeginCreate(ctx, "MyResourceGroup", "MyAccount", "profileA", armtrustedsigning.CertificateProfile{
		Properties: &armtrustedsigning.CertificateProfileProperties{
			ProfileType:          to.Ptr(armtrustedsigning.ProfileTypePublicTrust),
			IdentityValidationID: to.Ptr("00000000-1234-5678-3333-444444444444"),
			IncludePostalCode:    to.Ptr(true),
			IncludeStreetAddress: to.Ptr(false),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll 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 = armtrustedsigning.CertificateProfilesClientCreateResponse{
	// 	CertificateProfile: armtrustedsigning.CertificateProfile{
	// 		Name: to.Ptr("profileA"),
	// 		Type: to.Ptr("Microsoft.CodeSigning/codeSigningAccounts/certificateProfiles"),
	// 		ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.CodeSigning/codeSigningAccounts/MyAccount/certificateProfiles/profileA"),
	// 		Properties: &armtrustedsigning.CertificateProfileProperties{
	// 			Certificates: []*armtrustedsigning.Certificate{
	// 				{
	// 					CreatedDate: to.Ptr("3/14/2023 5:27:49 PM"),
	// 					ExpiryDate: to.Ptr("3/17/2023 5:27:49 PM"),
	// 					EnhancedKeyUsage: to.Ptr("1.3.6.1.4.1.311.yy.xxxxxxxx.xxxxxxxx.xxxxxxxxx.xxxxxxxx"),
	// 					SerialNumber: to.Ptr("xxxxxxxxxxxxxxxxxx"),
	// 					Status: to.Ptr(armtrustedsigning.CertificateStatusActive),
	// 					SubjectName: to.Ptr("CN=Contoso Inc, O=Contoso Inc, L=New York, S=New York, C=US"),
	// 					Thumbprint: to.Ptr("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
	// 				},
	// 			},
	// 			IdentityValidationID: to.Ptr("00000000-1234-5678-3333-444444444444"),
	// 			IncludeCity: to.Ptr(false),
	// 			IncludeCountry: to.Ptr(false),
	// 			IncludePostalCode: to.Ptr(true),
	// 			IncludeState: to.Ptr(false),
	// 			IncludeStreetAddress: to.Ptr(false),
	// 			ProfileType: to.Ptr(armtrustedsigning.ProfileTypePublicTrust),
	// 			ProvisioningState: to.Ptr(armtrustedsigning.ProvisioningStateSucceeded),
	// 			Status: to.Ptr(armtrustedsigning.CertificateProfileStatusActive),
	// 		},
	// 	},
	// }
}

func (*CertificateProfilesClient) BeginDelete 

func (client *CertificateProfilesClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, profileName string, options *CertificateProfilesClientBeginDeleteOptions) (*runtime.Poller[CertificateProfilesClientDeleteResponse], error)

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

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - Trusted Signing account name.
  • profileName - Certificate profile name.
  • options - CertificateProfilesClientBeginDeleteOptions contains the optional parameters for the CertificateProfilesClient.BeginDelete method.
Example

Generated from example definition: 2025-10-13/CertificateProfiles_Delete.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armtrustedsigning.NewClientFactory("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewCertificateProfilesClient().BeginDelete(ctx, "MyResourceGroup", "MyAccount", "profileA", 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 poll the result: %v", err)
	}
}

func (*CertificateProfilesClient) Get 

func (client *CertificateProfilesClient) Get(ctx context.Context, resourceGroupName string, accountName string, profileName string, options *CertificateProfilesClientGetOptions) (CertificateProfilesClientGetResponse, error)

Get - Get details of a certificate profile. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - Trusted Signing account name.
  • profileName - Certificate profile name.
  • options - CertificateProfilesClientGetOptions contains the optional parameters for the CertificateProfilesClient.Get method.
Example

Generated from example definition: 2025-10-13/CertificateProfiles_Get.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armtrustedsigning.NewClientFactory("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewCertificateProfilesClient().Get(ctx, "MyResourceGroup", "MyAccount", "profileA", 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 = armtrustedsigning.CertificateProfilesClientGetResponse{
	// 	CertificateProfile: armtrustedsigning.CertificateProfile{
	// 		Name: to.Ptr("profileA"),
	// 		Type: to.Ptr("Microsoft.CodeSigning/codeSigningAccounts/certificateProfiles"),
	// 		ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/MyResourceGroup/providers/Microsoft.CodeSigning/codeSigningAccounts/MyAccount/certificateProfiles/profileA"),
	// 		Properties: &armtrustedsigning.CertificateProfileProperties{
	// 			Certificates: []*armtrustedsigning.Certificate{
	// 				{
	// 					CreatedDate: to.Ptr("3/14/2023 5:27:49 PM"),
	// 					ExpiryDate: to.Ptr("3/17/2023 5:27:49 PM"),
	// 					EnhancedKeyUsage: to.Ptr("1.3.6.1.4.1.311.yy.xxxxxxxx.xxxxxxxx.xxxxxxxxx.xxxxxxxx"),
	// 					SerialNumber: to.Ptr("xxxxxxxxxxxxxxxxxx"),
	// 					Status: to.Ptr(armtrustedsigning.CertificateStatusActive),
	// 					SubjectName: to.Ptr("CN=Contoso Inc, O=Contoso Inc, L=New York, S=New York, C=US"),
	// 					Thumbprint: to.Ptr("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
	// 				},
	// 			},
	// 			IdentityValidationID: to.Ptr("123456"),
	// 			IncludeCity: to.Ptr(false),
	// 			IncludeCountry: to.Ptr(false),
	// 			IncludePostalCode: to.Ptr(true),
	// 			IncludeState: to.Ptr(false),
	// 			IncludeStreetAddress: to.Ptr(false),
	// 			ProfileType: to.Ptr(armtrustedsigning.ProfileTypePublicTrust),
	// 			ProvisioningState: to.Ptr(armtrustedsigning.ProvisioningStateSucceeded),
	// 			Status: to.Ptr(armtrustedsigning.CertificateProfileStatusActive),
	// 		},
	// 	},
	// }
}

func (*CertificateProfilesClient) NewListByCodeSigningAccountPager 

func (client *CertificateProfilesClient) NewListByCodeSigningAccountPager(resourceGroupName string, accountName string, options *CertificateProfilesClientListByCodeSigningAccountOptions) *runtime.Pager[CertificateProfilesClientListByCodeSigningAccountResponse]

NewListByCodeSigningAccountPager - List certificate profiles under a trusted signing account.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - Trusted Signing account name.
  • options - CertificateProfilesClientListByCodeSigningAccountOptions contains the optional parameters for the CertificateProfilesClient.NewListByCodeSigningAccountPager method.
Example

Generated from example definition: 2025-10-13/CertificateProfiles_ListByCodeSigningAccount.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armtrustedsigning.NewClientFactory("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewCertificateProfilesClient().NewListByCodeSigningAccountPager("MyResourceGroup", "MyAccount", 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 = armtrustedsigning.CertificateProfilesClientListByCodeSigningAccountResponse{
		// 	CertificateProfileListResult: armtrustedsigning.CertificateProfileListResult{
		// 		Value: []*armtrustedsigning.CertificateProfile{
		// 			{
		// 				Name: to.Ptr("profileA"),
		// 				Type: to.Ptr("Microsoft.CodeSigning/codeSigningAccounts/certificateProfiles"),
		// 				ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/MyResourceGroup/providers/Microsoft.CodeSigning/codeSigningAccounts/profileA"),
		// 				Properties: &armtrustedsigning.CertificateProfileProperties{
		// 					Certificates: []*armtrustedsigning.Certificate{
		// 						{
		// 							CreatedDate: to.Ptr("3/14/2023 5:27:49 PM"),
		// 							ExpiryDate: to.Ptr("3/17/2023 5:27:49 PM"),
		// 							EnhancedKeyUsage: to.Ptr("1.3.6.1.4.1.311.yy.xxxxxxxx.xxxxxxxx.xxxxxxxxx.xxxxxxxx"),
		// 							SerialNumber: to.Ptr("xxxxxxxxxxxxxxxxxx"),
		// 							Status: to.Ptr(armtrustedsigning.CertificateStatusActive),
		// 							SubjectName: to.Ptr("CN=Contoso Inc, O=Contoso Inc, L=New York, S=New York, C=US"),
		// 							Thumbprint: to.Ptr("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
		// 						},
		// 					},
		// 					IdentityValidationID: to.Ptr("123456"),
		// 					IncludeCity: to.Ptr(false),
		// 					IncludeCountry: to.Ptr(false),
		// 					IncludePostalCode: to.Ptr(true),
		// 					IncludeState: to.Ptr(false),
		// 					IncludeStreetAddress: to.Ptr(false),
		// 					ProfileType: to.Ptr(armtrustedsigning.ProfileTypePublicTrust),
		// 					ProvisioningState: to.Ptr(armtrustedsigning.ProvisioningStateSucceeded),
		// 					Status: to.Ptr(armtrustedsigning.CertificateProfileStatusActive),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

func (*CertificateProfilesClient) RevokeCertificate 

func (client *CertificateProfilesClient) RevokeCertificate(ctx context.Context, resourceGroupName string, accountName string, profileName string, body RevokeCertificate, options *CertificateProfilesClientRevokeCertificateOptions) (CertificateProfilesClientRevokeCertificateResponse, error)

RevokeCertificate - Revoke a certificate under a certificate profile. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - Trusted Signing account name.
  • profileName - Certificate profile name.
  • body - Parameters to revoke the certificate profile
  • options - CertificateProfilesClientRevokeCertificateOptions contains the optional parameters for the CertificateProfilesClient.RevokeCertificate method.
Example

Generated from example definition: 2025-10-13/CertificateProfiles_RevokeCertificate.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armtrustedsigning.NewClientFactory("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewCertificateProfilesClient().RevokeCertificate(ctx, "MyResourceGroup", "MyAccount", "profileA", armtrustedsigning.RevokeCertificate{
		EffectiveAt:  to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-11-12T23:40:25+00:00"); return t }()),
		Reason:       to.Ptr("KeyCompromised"),
		Remarks:      to.Ptr("test"),
		SerialNumber: to.Ptr("xxxxxxxxxxxxxxxxxx"),
		Thumbprint:   to.Ptr("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

type CertificateProfilesClientBeginCreateOptions 

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

CertificateProfilesClientBeginCreateOptions contains the optional parameters for the CertificateProfilesClient.BeginCreate method.

type CertificateProfilesClientBeginDeleteOptions 

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

CertificateProfilesClientBeginDeleteOptions contains the optional parameters for the CertificateProfilesClient.BeginDelete method.

type CertificateProfilesClientCreateResponse 

type CertificateProfilesClientCreateResponse struct {
	// Certificate profile resource.
	CertificateProfile
}

CertificateProfilesClientCreateResponse contains the response from method CertificateProfilesClient.BeginCreate.

type CertificateProfilesClientDeleteResponse 

type CertificateProfilesClientDeleteResponse struct {
}

CertificateProfilesClientDeleteResponse contains the response from method CertificateProfilesClient.BeginDelete.

type CertificateProfilesClientGetOptions 

type CertificateProfilesClientGetOptions struct {
}

CertificateProfilesClientGetOptions contains the optional parameters for the CertificateProfilesClient.Get method.

type CertificateProfilesClientGetResponse 

type CertificateProfilesClientGetResponse struct {
	// Certificate profile resource.
	CertificateProfile
}

CertificateProfilesClientGetResponse contains the response from method CertificateProfilesClient.Get.

type CertificateProfilesClientListByCodeSigningAccountOptions 

type CertificateProfilesClientListByCodeSigningAccountOptions struct {
}

CertificateProfilesClientListByCodeSigningAccountOptions contains the optional parameters for the CertificateProfilesClient.NewListByCodeSigningAccountPager method.

type CertificateProfilesClientListByCodeSigningAccountResponse 

type CertificateProfilesClientListByCodeSigningAccountResponse struct {
	// The response of a CertificateProfile list operation.
	CertificateProfileListResult
}

CertificateProfilesClientListByCodeSigningAccountResponse contains the response from method CertificateProfilesClient.NewListByCodeSigningAccountPager.

type CertificateProfilesClientRevokeCertificateOptions 

type CertificateProfilesClientRevokeCertificateOptions struct {
}

CertificateProfilesClientRevokeCertificateOptions contains the optional parameters for the CertificateProfilesClient.RevokeCertificate method.

type CertificateProfilesClientRevokeCertificateResponse 

type CertificateProfilesClientRevokeCertificateResponse struct {
}

CertificateProfilesClientRevokeCertificateResponse contains the response from method CertificateProfilesClient.RevokeCertificate.

type CertificateStatus 

type CertificateStatus string

CertificateStatus - Status of the certificate 

const (
	// CertificateStatusActive - The certificate is active.
	CertificateStatusActive CertificateStatus = "Active"
	// CertificateStatusExpired - The certificate is expired.
	CertificateStatusExpired CertificateStatus = "Expired"
	// CertificateStatusRevoked - The certificate is revoked.
	CertificateStatusRevoked CertificateStatus = "Revoked"
)

func PossibleCertificateStatusValues 

func PossibleCertificateStatusValues() []CertificateStatus

PossibleCertificateStatusValues returns the possible values for the CertificateStatus const type.

type CheckNameAvailability 

type CheckNameAvailability struct {
	// REQUIRED; Trusted signing account name.
	Name *string

	// REQUIRED; The type of the resource, "Microsoft.CodeSigning/codeSigningAccounts".
	Type *string
}

CheckNameAvailability - The parameters used to check the availability of the trusted signing account name.

func (CheckNameAvailability) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailability.

func (*CheckNameAvailability) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailability.

type CheckNameAvailabilityResult 

type CheckNameAvailabilityResult struct {
	// READ-ONLY; An error message explaining the Reason value in more detail.
	Message *string

	// READ-ONLY; A boolean value that indicates whether the name is available for you to use. If true, the name is available.
	// If false, the name has already been taken or is invalid and cannot be used.
	NameAvailable *bool

	// READ-ONLY; The reason that a trusted signing account name could not be used. The Reason element is only returned if nameAvailable
	// is false.
	Reason *NameUnavailabilityReason
}

CheckNameAvailabilityResult - The CheckNameAvailability operation response.

func (CheckNameAvailabilityResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CheckNameAvailabilityResult.

func (*CheckNameAvailabilityResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CheckNameAvailabilityResult.

type ClientFactory 

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

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

func NewClientFactory 

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

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

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

func (*ClientFactory) NewCertificateProfilesClient 

func (c *ClientFactory) NewCertificateProfilesClient() *CertificateProfilesClient

NewCertificateProfilesClient creates a new instance of CertificateProfilesClient.

func (*ClientFactory) NewCodeSigningAccountsClient 

func (c *ClientFactory) NewCodeSigningAccountsClient() *CodeSigningAccountsClient

NewCodeSigningAccountsClient creates a new instance of CodeSigningAccountsClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

type CodeSigningAccount 

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

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

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

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string

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

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

CodeSigningAccount - Trusted signing account resource.

func (CodeSigningAccount) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CodeSigningAccount.

func (*CodeSigningAccount) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CodeSigningAccount.

type CodeSigningAccountListResult 

type CodeSigningAccountListResult struct {
	// REQUIRED; The CodeSigningAccount items on this page
	Value []*CodeSigningAccount

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

CodeSigningAccountListResult - The response of a CodeSigningAccount list operation.

func (CodeSigningAccountListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CodeSigningAccountListResult.

func (*CodeSigningAccountListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CodeSigningAccountListResult.

type CodeSigningAccountPatch 

type CodeSigningAccountPatch struct {
	// Properties of the trusted signing account.
	Properties *CodeSigningAccountPatchProperties

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

CodeSigningAccountPatch - Parameters for creating or updating a trusted signing account.

func (CodeSigningAccountPatch) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CodeSigningAccountPatch.

func (*CodeSigningAccountPatch) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CodeSigningAccountPatch.

type CodeSigningAccountPatchProperties 

type CodeSigningAccountPatchProperties struct {
	// SKU of the trusted signing account.
	SKU *AccountSKUPatch
}

CodeSigningAccountPatchProperties - Properties of the trusted signing account.

func (CodeSigningAccountPatchProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CodeSigningAccountPatchProperties.

func (*CodeSigningAccountPatchProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CodeSigningAccountPatchProperties.

type CodeSigningAccountProperties 

type CodeSigningAccountProperties struct {
	// SKU of the trusted signing account.
	SKU *AccountSKU

	// READ-ONLY; The URI of the trusted signing account which is used during signing files.
	AccountURI *string

	// READ-ONLY; Status of the current operation on trusted signing account.
	ProvisioningState *ProvisioningState
}

CodeSigningAccountProperties - Properties of the trusted signing account.

func (CodeSigningAccountProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CodeSigningAccountProperties.

func (*CodeSigningAccountProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CodeSigningAccountProperties.

type CodeSigningAccountsClient 

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

CodeSigningAccountsClient contains the methods for the CodeSigningAccounts group. Don't use this type directly, use NewCodeSigningAccountsClient() instead.

Generated from API version 2025-10-13

func NewCodeSigningAccountsClient 

func NewCodeSigningAccountsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*CodeSigningAccountsClient, error)

NewCodeSigningAccountsClient creates a new instance of CodeSigningAccountsClient 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 - Contains optional client configuration. Pass nil to accept the default values.

func (*CodeSigningAccountsClient) BeginCreate 

func (client *CodeSigningAccountsClient) BeginCreate(ctx context.Context, resourceGroupName string, accountName string, resource CodeSigningAccount, options *CodeSigningAccountsClientBeginCreateOptions) (*runtime.Poller[CodeSigningAccountsClientCreateResponse], error)

BeginCreate - Create a trusted Signing Account. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - Trusted Signing account name.
  • resource - Parameters to create the trusted signing account
  • options - CodeSigningAccountsClientBeginCreateOptions contains the optional parameters for the CodeSigningAccountsClient.BeginCreate method.
Example

Generated from example definition: 2025-10-13/CodeSigningAccounts_Create.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armtrustedsigning.NewClientFactory("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewCodeSigningAccountsClient().BeginCreate(ctx, "MyResourceGroup", "MyAccount", armtrustedsigning.CodeSigningAccount{
		Location: to.Ptr("westus"),
		Properties: &armtrustedsigning.CodeSigningAccountProperties{
			SKU: &armtrustedsigning.AccountSKU{
				Name: to.Ptr(armtrustedsigning.SKUNameBasic),
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll 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 = armtrustedsigning.CodeSigningAccountsClientCreateResponse{
	// 	CodeSigningAccount: armtrustedsigning.CodeSigningAccount{
	// 		Name: to.Ptr("MyAccount"),
	// 		Type: to.Ptr("Microsoft.CodeSigning/codeSigningAccounts"),
	// 		ID: to.Ptr("/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/MyResourceGroup/providers/Microsoft.CodeSigning/codeSigningAccounts/MyAccount"),
	// 		Location: to.Ptr("westus"),
	// 		Properties: &armtrustedsigning.CodeSigningAccountProperties{
	// 			ProvisioningState: to.Ptr(armtrustedsigning.ProvisioningStateSucceeded),
	// 			SKU: &armtrustedsigning.AccountSKU{
	// 				Name: to.Ptr(armtrustedsigning.SKUNameBasic),
	// 			},
	// 		},
	// 	},
	// }
}

func (*CodeSigningAccountsClient) BeginDelete 

func (client *CodeSigningAccountsClient) BeginDelete(ctx context.Context, resourceGroupName string, accountName string, options *CodeSigningAccountsClientBeginDeleteOptions) (*runtime.Poller[CodeSigningAccountsClientDeleteResponse], error)

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

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - Trusted Signing account name.
  • options - CodeSigningAccountsClientBeginDeleteOptions contains the optional parameters for the CodeSigningAccountsClient.BeginDelete method.
Example

Generated from example definition: 2025-10-13/CodeSigningAccounts_Delete.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armtrustedsigning.NewClientFactory("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewCodeSigningAccountsClient().BeginDelete(ctx, "MyResourceGroup", "MyAccount", 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 poll the result: %v", err)
	}
}

func (*CodeSigningAccountsClient) BeginUpdate 

func (client *CodeSigningAccountsClient) BeginUpdate(ctx context.Context, resourceGroupName string, accountName string, properties CodeSigningAccountPatch, options *CodeSigningAccountsClientBeginUpdateOptions) (*runtime.Poller[CodeSigningAccountsClientUpdateResponse], error)

BeginUpdate - Update a trusted signing account. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - Trusted Signing account name.
  • properties - Parameters supplied to update the trusted signing account
  • options - CodeSigningAccountsClientBeginUpdateOptions contains the optional parameters for the CodeSigningAccountsClient.BeginUpdate method.
Example

Generated from example definition: 2025-10-13/CodeSigningAccounts_Update.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armtrustedsigning.NewClientFactory("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewCodeSigningAccountsClient().BeginUpdate(ctx, "MyResourceGroup", "MyAccount", armtrustedsigning.CodeSigningAccountPatch{
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll 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 = armtrustedsigning.CodeSigningAccountsClientUpdateResponse{
	// 	CodeSigningAccount: armtrustedsigning.CodeSigningAccount{
	// 		Name: to.Ptr("MyAccount"),
	// 		Type: to.Ptr("Microsoft.CodeSigning/codeSigningAccounts"),
	// 		ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/MyResourceGroup/providers/Microsoft.CodeSigning/codeSigningAccounts/MyAccount"),
	// 		Location: to.Ptr("westus"),
	// 		Properties: &armtrustedsigning.CodeSigningAccountProperties{
	// 			ProvisioningState: to.Ptr(armtrustedsigning.ProvisioningStateSucceeded),
	// 			SKU: &armtrustedsigning.AccountSKU{
	// 				Name: to.Ptr(armtrustedsigning.SKUNameBasic),
	// 			},
	// 		},
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 		},
	// 	},
	// }
}

func (*CodeSigningAccountsClient) CheckNameAvailability 

func (client *CodeSigningAccountsClient) CheckNameAvailability(ctx context.Context, body CheckNameAvailability, options *CodeSigningAccountsClientCheckNameAvailabilityOptions) (CodeSigningAccountsClientCheckNameAvailabilityResponse, error)

CheckNameAvailability - Checks that the trusted signing account name is valid and is not already in use. If the operation fails it returns an *azcore.ResponseError type.

  • body - The CheckAvailability request
  • options - CodeSigningAccountsClientCheckNameAvailabilityOptions contains the optional parameters for the CodeSigningAccountsClient.CheckNameAvailability method.
Example

Generated from example definition: 2025-10-13/CodeSigningAccounts_CheckNameAvailability.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armtrustedsigning.NewClientFactory("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewCodeSigningAccountsClient().CheckNameAvailability(ctx, armtrustedsigning.CheckNameAvailability{
		Type: to.Ptr("Microsoft.CodeSigning/codeSigningAccounts"),
		Name: to.Ptr("sample-account"),
	}, 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 = armtrustedsigning.CodeSigningAccountsClientCheckNameAvailabilityResponse{
	// 	CheckNameAvailabilityResult: armtrustedsigning.CheckNameAvailabilityResult{
	// 		NameAvailable: to.Ptr(true),
	// 	},
	// }
}

func (*CodeSigningAccountsClient) Get 

func (client *CodeSigningAccountsClient) Get(ctx context.Context, resourceGroupName string, accountName string, options *CodeSigningAccountsClientGetOptions) (CodeSigningAccountsClientGetResponse, error)

Get - Get a trusted Signing Account. If the operation fails it returns an *azcore.ResponseError type.

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • accountName - Trusted Signing account name.
  • options - CodeSigningAccountsClientGetOptions contains the optional parameters for the CodeSigningAccountsClient.Get method.
Example

Generated from example definition: 2025-10-13/CodeSigningAccounts_Get.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armtrustedsigning.NewClientFactory("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewCodeSigningAccountsClient().Get(ctx, "MyResourceGroup", "MyAccount", 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 = armtrustedsigning.CodeSigningAccountsClientGetResponse{
	// 	CodeSigningAccount: armtrustedsigning.CodeSigningAccount{
	// 		Name: to.Ptr("MyAccount"),
	// 		Type: to.Ptr("Microsoft.CodeSigning/codeSigningAccounts"),
	// 		ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/MyResourceGroup/providers/Microsoft.CodeSigning/codeSigningAccounts/MyAccount"),
	// 		Location: to.Ptr("westus"),
	// 		Properties: &armtrustedsigning.CodeSigningAccountProperties{
	// 			ProvisioningState: to.Ptr(armtrustedsigning.ProvisioningStateSucceeded),
	// 			SKU: &armtrustedsigning.AccountSKU{
	// 				Name: to.Ptr(armtrustedsigning.SKUNameBasic),
	// 			},
	// 		},
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 		},
	// 	},
	// }
}

func (*CodeSigningAccountsClient) NewListByResourceGroupPager 

func (client *CodeSigningAccountsClient) NewListByResourceGroupPager(resourceGroupName string, options *CodeSigningAccountsClientListByResourceGroupOptions) *runtime.Pager[CodeSigningAccountsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Lists trusted signing accounts within a resource group.

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

Generated from example definition: 2025-10-13/CodeSigningAccounts_ListByResourceGroup.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armtrustedsigning.NewClientFactory("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewCodeSigningAccountsClient().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 = armtrustedsigning.CodeSigningAccountsClientListByResourceGroupResponse{
		// 	CodeSigningAccountListResult: armtrustedsigning.CodeSigningAccountListResult{
		// 		Value: []*armtrustedsigning.CodeSigningAccount{
		// 			{
		// 				Name: to.Ptr("alpha"),
		// 				Type: to.Ptr("Microsoft.CodeSigning/codeSigningAccounts"),
		// 				ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/MyResourceGroup/providers/Microsoft.CodeSigning/codeSigningAccounts/MyAccount"),
		// 				Location: to.Ptr("westcentralus"),
		// 				Properties: &armtrustedsigning.CodeSigningAccountProperties{
		// 					ProvisioningState: to.Ptr(armtrustedsigning.ProvisioningStateSucceeded),
		// 					SKU: &armtrustedsigning.AccountSKU{
		// 						Name: to.Ptr(armtrustedsigning.SKUNameBasic),
		// 					},
		// 				},
		// 				Tags: map[string]*string{
		// 					"key1": to.Ptr("value1"),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

func (*CodeSigningAccountsClient) NewListBySubscriptionPager 

func (client *CodeSigningAccountsClient) NewListBySubscriptionPager(options *CodeSigningAccountsClientListBySubscriptionOptions) *runtime.Pager[CodeSigningAccountsClientListBySubscriptionResponse]

NewListBySubscriptionPager - Lists trusted signing accounts within a subscription.

  • options - CodeSigningAccountsClientListBySubscriptionOptions contains the optional parameters for the CodeSigningAccountsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: 2025-10-13/CodeSigningAccounts_ListBySubscription.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armtrustedsigning.NewClientFactory("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewCodeSigningAccountsClient().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 = armtrustedsigning.CodeSigningAccountsClientListBySubscriptionResponse{
		// 	CodeSigningAccountListResult: armtrustedsigning.CodeSigningAccountListResult{
		// 		Value: []*armtrustedsigning.CodeSigningAccount{
		// 			{
		// 				Name: to.Ptr("alpha"),
		// 				Type: to.Ptr("Microsoft.CodeSigning/codeSigningAccounts"),
		// 				ID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/MyResourceGroup/providers/Microsoft.CodeSigning/codeSigningAccounts/MyAccount"),
		// 				Location: to.Ptr("westus"),
		// 				Properties: &armtrustedsigning.CodeSigningAccountProperties{
		// 					ProvisioningState: to.Ptr(armtrustedsigning.ProvisioningStateSucceeded),
		// 					SKU: &armtrustedsigning.AccountSKU{
		// 						Name: to.Ptr(armtrustedsigning.SKUNameBasic),
		// 					},
		// 				},
		// 				Tags: map[string]*string{
		// 					"key1": to.Ptr("value1"),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

type CodeSigningAccountsClientBeginCreateOptions 

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

CodeSigningAccountsClientBeginCreateOptions contains the optional parameters for the CodeSigningAccountsClient.BeginCreate method.

type CodeSigningAccountsClientBeginDeleteOptions 

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

CodeSigningAccountsClientBeginDeleteOptions contains the optional parameters for the CodeSigningAccountsClient.BeginDelete method.

type CodeSigningAccountsClientBeginUpdateOptions 

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

CodeSigningAccountsClientBeginUpdateOptions contains the optional parameters for the CodeSigningAccountsClient.BeginUpdate method.

type CodeSigningAccountsClientCheckNameAvailabilityOptions 

type CodeSigningAccountsClientCheckNameAvailabilityOptions struct {
}

CodeSigningAccountsClientCheckNameAvailabilityOptions contains the optional parameters for the CodeSigningAccountsClient.CheckNameAvailability method.

type CodeSigningAccountsClientCheckNameAvailabilityResponse 

type CodeSigningAccountsClientCheckNameAvailabilityResponse struct {
	// The CheckNameAvailability operation response.
	CheckNameAvailabilityResult
}

CodeSigningAccountsClientCheckNameAvailabilityResponse contains the response from method CodeSigningAccountsClient.CheckNameAvailability.

type CodeSigningAccountsClientCreateResponse 

type CodeSigningAccountsClientCreateResponse struct {
	// Trusted signing account resource.
	CodeSigningAccount
}

CodeSigningAccountsClientCreateResponse contains the response from method CodeSigningAccountsClient.BeginCreate.

type CodeSigningAccountsClientDeleteResponse 

type CodeSigningAccountsClientDeleteResponse struct {
}

CodeSigningAccountsClientDeleteResponse contains the response from method CodeSigningAccountsClient.BeginDelete.

type CodeSigningAccountsClientGetOptions 

type CodeSigningAccountsClientGetOptions struct {
}

CodeSigningAccountsClientGetOptions contains the optional parameters for the CodeSigningAccountsClient.Get method.

type CodeSigningAccountsClientGetResponse 

type CodeSigningAccountsClientGetResponse struct {
	// Trusted signing account resource.
	CodeSigningAccount
}

CodeSigningAccountsClientGetResponse contains the response from method CodeSigningAccountsClient.Get.

type CodeSigningAccountsClientListByResourceGroupOptions 

type CodeSigningAccountsClientListByResourceGroupOptions struct {
}

CodeSigningAccountsClientListByResourceGroupOptions contains the optional parameters for the CodeSigningAccountsClient.NewListByResourceGroupPager method.

type CodeSigningAccountsClientListByResourceGroupResponse 

type CodeSigningAccountsClientListByResourceGroupResponse struct {
	// The response of a CodeSigningAccount list operation.
	CodeSigningAccountListResult
}

CodeSigningAccountsClientListByResourceGroupResponse contains the response from method CodeSigningAccountsClient.NewListByResourceGroupPager.

type CodeSigningAccountsClientListBySubscriptionOptions 

type CodeSigningAccountsClientListBySubscriptionOptions struct {
}

CodeSigningAccountsClientListBySubscriptionOptions contains the optional parameters for the CodeSigningAccountsClient.NewListBySubscriptionPager method.

type CodeSigningAccountsClientListBySubscriptionResponse 

type CodeSigningAccountsClientListBySubscriptionResponse struct {
	// The response of a CodeSigningAccount list operation.
	CodeSigningAccountListResult
}

CodeSigningAccountsClientListBySubscriptionResponse contains the response from method CodeSigningAccountsClient.NewListBySubscriptionPager.

type CodeSigningAccountsClientUpdateResponse 

type CodeSigningAccountsClientUpdateResponse struct {
	// Trusted signing account resource.
	CodeSigningAccount
}

CodeSigningAccountsClientUpdateResponse contains the response from method CodeSigningAccountsClient.BeginUpdate.

type CreatedByType 

type CreatedByType string

CreatedByType - The kind of entity that created the resource. 

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

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type NameUnavailabilityReason 

type NameUnavailabilityReason string

NameUnavailabilityReason - The reason that a trusted signing account name could not be used. The Reason element is only returned if nameAvailable is false. 

const (
	// NameUnavailabilityReasonAccountNameInvalid - Account name is invalid
	NameUnavailabilityReasonAccountNameInvalid NameUnavailabilityReason = "AccountNameInvalid"
	// NameUnavailabilityReasonAlreadyExists - Account name already exists
	NameUnavailabilityReasonAlreadyExists NameUnavailabilityReason = "AlreadyExists"
)

func PossibleNameUnavailabilityReasonValues 

func PossibleNameUnavailabilityReasonValues() []NameUnavailabilityReason

PossibleNameUnavailabilityReasonValues returns the possible values for the NameUnavailabilityReason const type.

type Operation 

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

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

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

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

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

Operation - REST API Operation

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

func (Operation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; The short, localized friendly description of the operation; suitable for tool tips and detailed views.
	Description *string

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

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

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

OperationDisplay - Localized display information for an operation.

func (OperationDisplay) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult 

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

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

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

func (OperationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationsClient 

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

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

Generated from API version 2025-10-13

func NewOperationsClient 

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

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

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - Contains optional client configuration. Pass nil to accept the default values.

func (*OperationsClient) NewListPager 

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

NewListPager - List the operations for the provider

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

Generated from example definition: 2025-10-13/Operations_List.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armtrustedsigning.NewClientFactory("<subscriptionID>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOperationsClient().NewListPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page = armtrustedsigning.OperationsClientListResponse{
		// 	OperationListResult: armtrustedsigning.OperationListResult{
		// 		Value: []*armtrustedsigning.Operation{
		// 			{
		// 				Name: to.Ptr("Microsoft.CodeSigning/codeSigningAccounts/write"),
		// 				Display: &armtrustedsigning.OperationDisplay{
		// 					Provider: to.Ptr("Microsoft.CodeSigning"),
		// 					Resource: to.Ptr("codeSigningAccounts"),
		// 					Operation: to.Ptr("Create CodeSigningAccount"),
		// 					Description: to.Ptr("Create any CodeSigningAccount"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.CodeSigning/codeSigningAccounts/read"),
		// 				Display: &armtrustedsigning.OperationDisplay{
		// 					Provider: to.Ptr("Microsoft.CodeSigning"),
		// 					Resource: to.Ptr("codeSigningAccounts"),
		// 					Operation: to.Ptr("Get CodeSigningAccount"),
		// 					Description: to.Ptr("Get any CodeSigningAccount"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("Microsoft.CodeSigning/codeSigningAccounts/delete"),
		// 				Display: &armtrustedsigning.OperationDisplay{
		// 					Provider: to.Ptr("Microsoft.CodeSigning"),
		// 					Resource: to.Ptr("codeSigningAccounts"),
		// 					Operation: to.Ptr("Delete CodeSigningAccount"),
		// 					Description: to.Ptr("Delete any CodeSigningAccount"),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

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

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type Origin 

type Origin string

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

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

func PossibleOriginValues 

func PossibleOriginValues() []Origin

PossibleOriginValues returns the possible values for the Origin const type.

type ProfileType 

type ProfileType string

ProfileType - Type of the certificate 

const (
	// ProfileTypePrivateTrust - Used for signing files which are distributed internally within organization or group boundary.
	ProfileTypePrivateTrust ProfileType = "PrivateTrust"
	// ProfileTypePrivateTrustCIPolicy - Used for signing CI policy files.
	ProfileTypePrivateTrustCIPolicy ProfileType = "PrivateTrustCIPolicy"
	// ProfileTypePublicTrust - Used for signing files which are distributed publicly.
	ProfileTypePublicTrust ProfileType = "PublicTrust"
	// ProfileTypePublicTrustTest - Used for signing files for testing purpose.
	ProfileTypePublicTrustTest ProfileType = "PublicTrustTest"
	// ProfileTypeVBSEnclave - Used for signing files which are run in secure vbs enclave.
	ProfileTypeVBSEnclave ProfileType = "VBSEnclave"
)

func PossibleProfileTypeValues 

func PossibleProfileTypeValues() []ProfileType

PossibleProfileTypeValues returns the possible values for the ProfileType const type.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - The status of the current operation. 

const (
	// ProvisioningStateAccepted - Resource creation started.
	ProvisioningStateAccepted ProvisioningState = "Accepted"
	// ProvisioningStateCanceled - Resource creation was canceled.
	ProvisioningStateCanceled ProvisioningState = "Canceled"
	// ProvisioningStateDeleting - Deletion in progress.
	ProvisioningStateDeleting ProvisioningState = "Deleting"
	// ProvisioningStateFailed - Resource creation failed.
	ProvisioningStateFailed ProvisioningState = "Failed"
	// ProvisioningStateSucceeded - Resource has been created.
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
	// ProvisioningStateUpdating - Updating in progress.
	ProvisioningStateUpdating ProvisioningState = "Updating"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type Revocation 

type Revocation struct {
	// The timestamp when the revocation is effective.
	EffectiveAt *time.Time

	// Reason for the revocation failure.
	FailureReason *string

	// Reason for revocation.
	Reason *string

	// Remarks for the revocation.
	Remarks *string

	// The timestamp when the revocation is requested.
	RequestedAt *time.Time

	// Status of the revocation.
	Status *RevocationStatus
}

Revocation details of the certificate.

func (Revocation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Revocation.

func (*Revocation) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Revocation.

type RevocationStatus 

type RevocationStatus string

RevocationStatus - Revocation status of the certificate. 

const (
	// RevocationStatusFailed - Certificate revocation failed.
	RevocationStatusFailed RevocationStatus = "Failed"
	// RevocationStatusInProgress - Certificate revocation is in progress.
	RevocationStatusInProgress RevocationStatus = "InProgress"
	// RevocationStatusSucceeded - Certificate revocation succeeded.
	RevocationStatusSucceeded RevocationStatus = "Succeeded"
)

func PossibleRevocationStatusValues 

func PossibleRevocationStatusValues() []RevocationStatus

PossibleRevocationStatusValues returns the possible values for the RevocationStatus const type.

type RevokeCertificate 

type RevokeCertificate struct {
	// REQUIRED; The timestamp when the revocation is effective.
	EffectiveAt *time.Time

	// REQUIRED; Reason for the revocation.
	Reason *string

	// REQUIRED; Serial number of the certificate.
	SerialNumber *string

	// REQUIRED; Thumbprint of the certificate.
	Thumbprint *string

	// Remarks for the revocation.
	Remarks *string
}

RevokeCertificate - Defines the certificate revocation properties.

func (RevokeCertificate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type RevokeCertificate.

func (*RevokeCertificate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type RevokeCertificate.

type SKUName 

type SKUName string

SKUName - Name of the sku. 

const (
	// SKUNameBasic - Basic sku.
	SKUNameBasic SKUName = "Basic"
	// SKUNamePremium - Premium sku.
	SKUNamePremium SKUName = "Premium"
)

func PossibleSKUNameValues 

func PossibleSKUNameValues() []SKUName

PossibleSKUNameValues returns the possible values for the SKUName const type.

type SystemData 

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

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

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

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

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

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

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

func (SystemData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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