From 2dcf2e33b15582e2d5c5a10c34ea43c5a1358870 Mon Sep 17 00:00:00 2001
From: Manjusha Sonawane <manjusha.sonawane@ibm.com>
Date: Wed, 7 May 2025 15:00:41 +0530
Subject: [PATCH 1/9] Added support for personal certificates to Create, Get,
 Delete and Update certificates to pkg/cmd module in verifyctl

---
 pkg/cmd/create/certificate.go  | 192 +++++++++++++++++++++++++++++++++
 pkg/cmd/create/create.go       |   6 ++
 pkg/cmd/delete/certificate.go  | 108 +++++++++++++++++++
 pkg/cmd/delete/delete.go       |   1 +
 pkg/cmd/get/certificate.go     | 179 ++++++++++++++++++++++++++++++
 pkg/cmd/get/get.go             |   1 +
 pkg/cmd/replace/certificate.go | 169 +++++++++++++++++++++++++++++
 pkg/cmd/replace/replace.go     |   5 +
 8 files changed, 661 insertions(+)
 create mode 100644 pkg/cmd/create/certificate.go
 create mode 100644 pkg/cmd/delete/certificate.go
 create mode 100644 pkg/cmd/get/certificate.go
 create mode 100644 pkg/cmd/replace/certificate.go

diff --git a/pkg/cmd/create/certificate.go b/pkg/cmd/create/certificate.go
new file mode 100644
index 0000000..b07f609
--- /dev/null
+++ b/pkg/cmd/create/certificate.go
@@ -0,0 +1,192 @@
+package create
+
+import (
+	"encoding/json"
+	"io"
+	"os"
+
+	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
+	contextx "github.com/ibm-verify/verify-sdk-go/pkg/core/context"
+	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
+	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
+	"github.com/ibm-verify/verifyctl/pkg/cmd/resource"
+	"github.com/ibm-verify/verifyctl/pkg/config"
+	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
+	"github.com/ibm-verify/verifyctl/pkg/util/templates"
+	"github.com/spf13/cobra"
+	"gopkg.in/yaml.v3"
+)
+
+const (
+	personalCertUsage         = `personalCert [options]`
+	personalCertMessagePrefix = "CreatepersonalCert"
+	personalCertEntitlements  = "Manage password policies"
+	personalCertResourceName  = "personalCert"
+)
+
+var (
+	personalCertShortDesc = cmdutil.TranslateShortDesc(
+		personalCertMessagePrefix,
+		"Create a personal certificate with specified options.",
+	)
+	personalCertLongDesc = templates.LongDesc(
+		cmdutil.TranslateLongDesc(
+			personalCertMessagePrefix,
+			`Create a personal certificate resource. Resources managed on Verify require specific entitlements.
+			 Ensure the application or API client used with the 'auth' command has the "Manage password policies" entitlement. 
+			 Generate an empty resource file with: verifyctl create personalCert --boilerplate
+			Check required entitlements with: verifyctl create personalCert --entitlements
+			Input files can be in YAML or JSON format.`,
+		),
+	)
+	personalCertExamples = templates.Examples(
+		cmdutil.TranslateExamples(
+			personalCertMessagePrefix,
+			`# Create an empty personal certificate resource.
+		verifyctl create personalCert --boilerplate
+		# Create a personal certificate using a YAML file.
+		verifyctl create personalCert -f=./personal_cert.yaml
+		# Create a personal certificate using a JSON file.
+	verifyctl create personalCert -f=./personal_cert.json`,
+		),
+	)
+)
+
+type personalCertOptions struct {
+	options
+	file string
+}
+
+func newPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
+	o := &personalCertOptions{
+		options: options{
+			config: config,
+		},
+	}
+
+	cmd := &cobra.Command{
+		Use:                   personalCertUsage,
+		Short:                 personalCertShortDesc,
+		Long:                  personalCertLongDesc,
+		Example:               personalCertExamples,
+		DisableFlagsInUseLine: true,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
+		},
+	}
+
+	cmd.SetOut(streams)
+	cmd.SetErr(streams)
+	cmd.SetIn(streams)
+
+	o.AddFlags(cmd)
+
+	return cmd
+}
+
+func (o *personalCertOptions) AddFlags(cmd *cobra.Command) {
+	o.addCommonFlags(cmd, personalCertResourceName)
+	cmd.Flags().StringVarP(&o.file, "file", "f", "", i18n.Translate("Path to the YAML file that contains the input data."))
+}
+
+func (o *personalCertOptions) Complete(cmd *cobra.Command, args []string) error {
+	return nil
+}
+
+func (o *personalCertOptions) Validate(cmd *cobra.Command, args []string) error {
+	if o.entitlements || o.boilerplate {
+		return nil
+	}
+
+	if len(o.file) == 0 {
+		return errorsx.G11NError(i18n.Translate("'file' option is required if no other options are used."))
+	}
+	return nil
+}
+
+func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		cmdutil.WriteString(cmd, entitlementsMessage+"  "+personalCertEntitlements)
+		return nil
+	}
+
+	if o.boilerplate {
+		resourceObj := &resource.ResourceObject{
+			Kind:       resource.ResourceTypePrefix + "PersonalCert",
+			APIVersion: "1.0",
+			Data:       &security.PersonalCert{},
+		}
+
+		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
+		return nil
+	}
+
+	_, err := o.config.SetAuthToContext(cmd.Context())
+	if err != nil {
+		return err
+	}
+
+	return o.createPersonalCert(cmd)
+}
+
+func (o *personalCertOptions) createPersonalCert(cmd *cobra.Command) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+
+	b, err := os.ReadFile(o.file)
+	if err != nil {
+		vc.Logger.Errorf("unable to read file; filename=%s, err=%v", o.file, err)
+		return err
+	}
+
+	return o.createPersonalCertWithData(cmd, b)
+}
+
+func (o *personalCertOptions) createPersonalCertWithData(cmd *cobra.Command, data []byte) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+
+	personalCert := &security.PersonalCert{}
+	if err := yaml.Unmarshal(data, &personalCert); err != nil {
+		vc.Logger.Errorf("unable to unmarshal the personalCert; err=%v", err)
+		return err
+	}
+
+	client := security.NewPersonalCertClient()
+	resourceURI, err := client.CreatePersonalCert(ctx, personalCert)
+	if err != nil {
+		return err
+	}
+
+	cmdutil.WriteString(cmd, "Resource created: "+resourceURI)
+	return nil
+}
+
+func (o *personalCertOptions) createPersonalCertFromDataMap(cmd *cobra.Command, data map[string]interface{}) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+
+	personalCert := &security.PersonalCert{}
+	b, err := json.Marshal(data)
+	if err != nil {
+		vc.Logger.Errorf("failed to marshal the data map into json; err=%v", err)
+		return err
+	}
+
+	if err := json.Unmarshal(b, personalCert); err != nil {
+		vc.Logger.Errorf("unable to unmarshal to an personalCert; err=%v", err)
+		return err
+	}
+
+	client := security.NewPersonalCertClient()
+	resourceURI, err := client.CreatePersonalCert(ctx, personalCert)
+	if err != nil {
+		vc.Logger.Errorf("unable to create the password policy; err=%v, personalCert=%+v", err, personalCert)
+		return err
+	}
+
+	cmdutil.WriteString(cmd, "Resource created: "+resourceURI)
+	return nil
+}
diff --git a/pkg/cmd/create/create.go b/pkg/cmd/create/create.go
index 4817891..1ed6d5e 100644
--- a/pkg/cmd/create/create.go
+++ b/pkg/cmd/create/create.go
@@ -94,6 +94,7 @@ func NewCommand(config *config.CLIConfig, streams io.ReadWriter, groupID string)
 	cmd.AddCommand(newAPIClientCommand(config, streams))
 	cmd.AddCommand(newApplicationCommand(config, streams))
 	cmd.AddCommand(newPasswordPolicyCommand(config, streams))
+	cmd.AddCommand(newPersonalCertCommand(config, streams))
 
 	return cmd
 }
@@ -164,6 +165,11 @@ func (o *options) Run(cmd *cobra.Command, args []string) error {
 	case resource.ResourceTypePrefix + "PasswordPolicy":
 		options := &passwordPolicyOptions{}
 		err = options.createPasswordPolicyFromDataMap(cmd, resourceObject.Data.(map[string]interface{}))
+
+	case resource.ResourceTypePrefix + "PersonalCert":
+		options := &personalCertOptions{}
+		err = options.createPersonalCertFromDataMap(cmd, resourceObject.Data.(map[string]interface{}))
+
 	}
 
 	return err
diff --git a/pkg/cmd/delete/certificate.go b/pkg/cmd/delete/certificate.go
new file mode 100644
index 0000000..e18521f
--- /dev/null
+++ b/pkg/cmd/delete/certificate.go
@@ -0,0 +1,108 @@
+package delete
+
+import (
+	"io"
+
+	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
+	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
+	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
+	"github.com/ibm-verify/verifyctl/pkg/config"
+	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
+	"github.com/ibm-verify/verifyctl/pkg/util/templates"
+	"github.com/spf13/cobra"
+)
+
+const (
+	personalCertUsage         = `personalCert [options]`
+	personalCertMessagePrefix = "DeletePersonalCert"
+	personalCertEntitlements  = "Manage Personal Certs"
+	personalCertResourceName  = "personalCert"
+)
+
+var (
+	personalCertLongDesc = templates.LongDesc(cmdutil.TranslateLongDesc(personalCertMessagePrefix, `
+		Delete a personal certificate in IBM Security Verify based on label.
+		Resources managed on Verify have specific entitlements, so ensure that the application or API client used with the 'auth' command is configured with the appropriate entitlements.
+		You can identify the entitlement required by running: verifyctl delete personalCert --entitlements`))
+
+	personalCertExamples = templates.Examples(cmdutil.TranslateExamples(personalCertMessagePrefix, `
+		# Delete a personal certificate by label
+		verifyctl delete personalCert --name=certificateLabel
+	`))
+)
+
+type personalCertOptions struct {
+	options
+	config *config.CLIConfig
+	label  string
+}
+
+func NewPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
+	o := &personalCertOptions{
+		config: config,
+	}
+	cmd := &cobra.Command{
+		Use:                   personalCertUsage,
+		Short:                 cmdutil.TranslateShortDesc(personalCertMessagePrefix, "Delete Verify personal certificate based on a label."),
+		Long:                  personalCertLongDesc,
+		Example:               personalCertExamples,
+		DisableFlagsInUseLine: true,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
+		},
+	}
+	cmd.SetOut(streams)
+	cmd.SetErr(streams)
+	cmd.SetIn(streams)
+	o.AddFlags(cmd)
+	return cmd
+}
+
+func (o *personalCertOptions) AddFlags(cmd *cobra.Command) {
+	o.addCommonFlags(cmd)
+	cmd.Flags().StringVar(&o.label, "personalCertLabel", o.label, i18n.Translate("Label of the personal certificate to delete. (Required)"))
+}
+
+func (o *personalCertOptions) Complete(cmd *cobra.Command, args []string) error {
+	return nil
+}
+
+func (o *personalCertOptions) Validate(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		return nil
+	}
+	calledAs := cmd.CalledAs()
+	if calledAs == "personalCert" && o.label == "" {
+		return errorsx.G11NError(i18n.Translate("The 'name' flag is required to delete a personal certificate"))
+	}
+	return nil
+}
+
+func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		cmdutil.WriteString(cmd, entitlementsMessage+" "+personalCertEntitlements)
+		return nil
+	}
+
+	_, err := o.config.SetAuthToContext(cmd.Context())
+	if err != nil {
+		return err
+	}
+
+	if cmd.CalledAs() == "personalCert" || len(o.label) > 0 {
+		return o.handleSinglePersonalCert(cmd, args)
+	}
+	return nil
+}
+
+func (o *personalCertOptions) handleSinglePersonalCert(cmd *cobra.Command, _ []string) error {
+	c := security.NewPersonalCertClient()
+	err := c.DeletePersonalCert(cmd.Context(), o.label)
+	if err != nil {
+		return err
+	}
+	cmdutil.WriteString(cmd, "Resource deleted: "+o.label)
+	return nil
+}
diff --git a/pkg/cmd/delete/delete.go b/pkg/cmd/delete/delete.go
index 4ff5f90..858d886 100644
--- a/pkg/cmd/delete/delete.go
+++ b/pkg/cmd/delete/delete.go
@@ -75,6 +75,7 @@ func NewCommand(config *config.CLIConfig, streams io.ReadWriter, groupID string)
 	cmd.AddCommand(NewAPIClientCommand(config, streams))
 	cmd.AddCommand(NewApplicationCommand(config, streams))
 	cmd.AddCommand(NewPasswordPolicyCommand(config, streams))
+	cmd.AddCommand(NewPersonalCertCommand(config, streams))
 
 	return cmd
 }
diff --git a/pkg/cmd/get/certificate.go b/pkg/cmd/get/certificate.go
new file mode 100644
index 0000000..9825058
--- /dev/null
+++ b/pkg/cmd/get/certificate.go
@@ -0,0 +1,179 @@
+package get
+
+import (
+	"io"
+
+	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
+	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
+	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
+	"github.com/ibm-verify/verifyctl/pkg/cmd/resource"
+	"github.com/ibm-verify/verifyctl/pkg/config"
+	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
+	"github.com/ibm-verify/verifyctl/pkg/util/templates"
+	"github.com/spf13/cobra"
+)
+
+const (
+	personalCertUsage         = `personalCerts [flags]`
+	personalCertMessagePrefix = "GetPersonalCerts"
+	personalCertEntitlements  = "Manage Personal Certs"
+	personalCertResourceName  = "personalCert"
+)
+
+var (
+	personalCertLongDesc = templates.LongDesc(cmdutil.TranslateLongDesc(personalCertMessagePrefix, `
+Get Verify personal certificate based on an optional filter or a specific personal certificate.
+
+Resources managed on Verify have specific entitlements, so ensure that the application or API client used
+with the 'auth' command is configured with the appropriate entitlements.
+
+You can identify the entitlement required by running:
+
+verifyctl get personalCert --entitlements`))
+
+	personalCertExamples = templates.Examples(cmdutil.TranslateExamples(personalCertMessagePrefix, `
+# Get a specific personal certificate by lable
+verifyctl get personalCert -o=yaml --name=testpersonalCert
+
+# Get 10 policies based on a given search criteria and sort it in the ascending order by name.
+		verifyctl get personal-certificate --count=2 --sort=label -o=yaml
+`))
+)
+
+type personalCertOptions struct {
+	options
+
+	config *config.CLIConfig
+	label  string
+}
+
+func newPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
+	o := &personalCertOptions{
+		config: config,
+	}
+
+	cmd := &cobra.Command{
+		Use:                   personalCertUsage,
+		Short:                 cmdutil.TranslateShortDesc(personalCertMessagePrefix, "Get Verify password policies based on an optional filter or a specific policy."),
+		Long:                  personalCertLongDesc,
+		Example:               personalCertExamples,
+		Aliases:               []string{"personalCert"},
+		DisableFlagsInUseLine: true,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
+		},
+	}
+
+	cmd.SetOut(streams)
+	cmd.SetErr(streams)
+	cmd.SetIn(streams)
+
+	o.AddFlags(cmd)
+
+	return cmd
+}
+
+func (o *personalCertOptions) AddFlags(cmd *cobra.Command) {
+	o.addCommonFlags(cmd, personalCertResourceName)
+	cmd.Flags().StringVar(&o.label, "personalCertLabel", o.label, i18n.Translate("personalCertName to get details"))
+	o.addSortFlags(cmd, personalCertResourceName)
+	o.addCountFlags(cmd, personalCertResourceName)
+}
+
+func (o *personalCertOptions) Complete(cmd *cobra.Command, args []string) error {
+	return nil
+}
+
+func (o *personalCertOptions) Validate(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		return nil
+	}
+	calledAs := cmd.CalledAs()
+	if calledAs == "personalCert" && o.label == "" {
+		return errorsx.G11NError(i18n.Translate("'personalCertName' flag is required."))
+	}
+	return nil
+}
+
+func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		cmdutil.WriteString(cmd, entitlementsMessage+" "+personalCertEntitlements)
+		return nil
+	}
+	_, err := o.config.SetAuthToContext(cmd.Context())
+	if err != nil {
+		return err
+	}
+	if cmd.CalledAs() == "personalCert" || len(o.label) > 0 {
+		return o.handleSinglePersonalCert(cmd, args)
+	}
+	return o.handlePersonalCertList(cmd, args)
+}
+
+func (o *personalCertOptions) handleSinglePersonalCert(cmd *cobra.Command, _ []string) error {
+
+	c := security.NewPersonalCertClient()
+	pcrt, uri, err := c.GetPersonalCert(cmd.Context(), o.label)
+	if err != nil {
+		return err
+	}
+	if o.output == "raw" {
+		cmdutil.WriteAsJSON(cmd, pcrt, cmd.OutOrStdout())
+		return nil
+	}
+	resourceObj := &resource.ResourceObject{
+		Kind:       resource.ResourceTypePrefix + "PersonalCert",
+		APIVersion: "1.0",
+		Metadata: &resource.ResourceObjectMetadata{
+			Name: pcrt.Label,
+			URI:  uri,
+		},
+		Data: pcrt,
+	}
+	if o.output == "json" {
+		cmdutil.WriteAsJSON(cmd, resourceObj, cmd.OutOrStdout())
+	} else {
+		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
+	}
+	return nil
+}
+
+func (o *personalCertOptions) handlePersonalCertList(cmd *cobra.Command, _ []string) error {
+	c := security.NewPersonalCertClient()
+	pcrts, uri, err := c.GetPersonalCerts(cmd.Context(), o.sort, o.count)
+	if err != nil {
+		return err
+	}
+	if o.output == "raw" {
+		cmdutil.WriteAsJSON(cmd, pcrts, cmd.OutOrStdout())
+		return nil
+	}
+
+	items := []*resource.ResourceObject{}
+	for _, pcrt := range pcrts.PersonalCerts {
+		items = append(items, &resource.ResourceObject{
+			Kind:       resource.ResourceTypePrefix + "PersonalCert",
+			APIVersion: "1.0",
+			Metadata: &resource.ResourceObjectMetadata{
+				Name: pcrt.Label,
+			},
+			Data: pcrt,
+		})
+	}
+	resourceObj := &resource.ResourceObjectList{
+		Kind:       resource.ResourceTypePrefix + "List",
+		APIVersion: "1.0",
+		Metadata: &resource.ResourceObjectMetadata{
+			URI: uri,
+		},
+		Items: items,
+	}
+	if o.output == "raw" || o.output == "json" {
+		cmdutil.WriteAsJSON(cmd, resourceObj, cmd.OutOrStdout())
+	} else {
+		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
+	}
+	return nil
+}
diff --git a/pkg/cmd/get/get.go b/pkg/cmd/get/get.go
index b82b027..0ff5d0c 100644
--- a/pkg/cmd/get/get.go
+++ b/pkg/cmd/get/get.go
@@ -88,6 +88,7 @@ func NewCommand(config *config.CLIConfig, streams io.ReadWriter, groupID string)
 	cmd.AddCommand(NewAPIClientsCommand(config, streams))
 	cmd.AddCommand(NewApplicationsCommand(config, streams))
 	cmd.AddCommand(newPasswordPolicyCommand(config, streams))
+	cmd.AddCommand(newPersonalCertCommand(config, streams))
 
 	return cmd
 }
diff --git a/pkg/cmd/replace/certificate.go b/pkg/cmd/replace/certificate.go
new file mode 100644
index 0000000..2f148e8
--- /dev/null
+++ b/pkg/cmd/replace/certificate.go
@@ -0,0 +1,169 @@
+package replace
+
+import (
+	"io"
+	"os"
+
+	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
+	contextx "github.com/ibm-verify/verify-sdk-go/pkg/core/context"
+	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
+	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
+	"github.com/ibm-verify/verifyctl/pkg/cmd/resource"
+	"github.com/ibm-verify/verifyctl/pkg/config"
+	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
+	"github.com/ibm-verify/verifyctl/pkg/util/templates"
+	"github.com/spf13/cobra"
+	"gopkg.in/yaml.v3"
+)
+
+const (
+	personalCertUsage         = `personalCert [options]`
+	personalCertMessagePrefix = "UpdatePersonalCert"
+	personalCertEntitlements  = "Manage Personal Certs"
+	personalCertResourceName  = "personalCert"
+)
+
+var (
+	personalCertShortDesc = cmdutil.TranslateShortDesc(personalCertMessagePrefix, "Update a personal certificate resource.")
+
+	personalCertLongDesc = templates.LongDesc(cmdutil.TranslateLongDesc(personalCertMessagePrefix, `
+		Update a personal certificate resource.
+		Resources managed on Verify require specific entitlements, so ensure that the application or API client used with the 'auth' command is configured with the appropriate entitlements.
+		An empty resource file can be generated using: verifyctl replace personalCert --boilerplate
+		You can identify the entitlement required by running: verifyctl replace personalCert --entitlements`))
+
+	personalCertExamples = templates.Examples(cmdutil.TranslateExamples(personalCertMessagePrefix, `
+		# Generate an empty personalCert resource template
+		verifyctl replace personalCert --boilerplate
+		# Update a personal certificate from a JSON file
+		verifyctl replace personalCert -f=./personal_cert.json
+	`))
+)
+
+type personalCertOptions struct {
+	options
+	config *config.CLIConfig
+}
+
+func NewPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
+	o := &personalCertOptions{
+		config: config,
+	}
+	cmd := &cobra.Command{
+		Use:                   personalCertUsage,
+		Short:                 personalCertShortDesc,
+		Long:                  personalCertLongDesc,
+		Example:               personalCertExamples,
+		DisableFlagsInUseLine: true,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
+		},
+	}
+	cmd.SetOut(streams)
+	cmd.SetErr(streams)
+	cmd.SetIn(streams)
+	o.AddFlags(cmd)
+	return cmd
+}
+
+func (o *personalCertOptions) AddFlags(cmd *cobra.Command) {
+	o.addCommonFlags(cmd, personalCertResourceName)
+	cmd.Flags().StringVarP(&o.file, "file", "f", "", i18n.Translate("Path to the file that contains the input data. The contents of the file are expected to be formatted to match the API contract."))
+}
+
+func (o *personalCertOptions) Complete(cmd *cobra.Command, args []string) error {
+	return nil
+}
+
+func (o *personalCertOptions) Validate(cmd *cobra.Command, args []string) error {
+	if o.entitlements || o.boilerplate {
+		return nil
+	}
+	if len(o.file) == 0 {
+		return errorsx.G11NError(i18n.Translate("'file' option is required if no other options are used."))
+	}
+	return nil
+}
+
+func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		cmdutil.WriteString(cmd, entitlementsMessage+" "+personalCertEntitlements)
+		return nil
+	}
+
+	if o.boilerplate {
+		resourceObj := &resource.ResourceObject{
+			Kind:       resource.ResourceTypePrefix + "PersonalCert",
+			APIVersion: "1.0",
+			Data: &security.PersonalCert{
+				Label: "<label>",
+			},
+		}
+		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
+		return nil
+	}
+
+	_, err := o.config.SetAuthToContext(cmd.Context())
+	if err != nil {
+		return err
+	}
+
+	return o.updatePersonalCert(cmd)
+}
+
+func (o *personalCertOptions) updatePersonalCert(cmd *cobra.Command) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+	b, err := os.ReadFile(o.file)
+	if err != nil {
+		vc.Logger.Errorf("unable to read file; filename=%s, err=%v", o.file, err)
+		return err
+	}
+	return o.updatePersonalCertWithData(cmd, b)
+}
+
+func (o *personalCertOptions) updatePersonalCertWithData(cmd *cobra.Command, data []byte) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+	personalCert := &security.PersonalCert{}
+	if err := yaml.Unmarshal(data, &personalCert); err != nil {
+		vc.Logger.Errorf("unable to unmarshal the personalCert; err=%v", err)
+		return err
+	}
+
+	client := security.NewPersonalCertClient()
+	if err := client.UpdatePersonalCert(ctx, personalCert); err != nil {
+		vc.Logger.Errorf("unable to update the personal certificate; err=%v, personalCert=%+v", err, personalCert)
+		return err
+	}
+
+	cmdutil.WriteString(cmd, "Personal Certificate updated successfully")
+	return nil
+}
+
+func (o *personalCertOptions) updatePersonalCertFromDataMap(cmd *cobra.Command, data map[string]interface{}) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+	personalCert := &security.PersonalCert{}
+	b, err := yaml.Marshal(data)
+	if err != nil {
+		vc.Logger.Errorf("failed to marshal the data map; err=%v", err)
+		return err
+	}
+
+	if err := yaml.Unmarshal(b, personalCert); err != nil {
+		vc.Logger.Errorf("unable to unmarshal to a personal certificate; err=%v", err)
+		return err
+	}
+
+	client := security.NewPersonalCertClient()
+	if err := client.UpdatePersonalCert(ctx, personalCert); err != nil {
+		vc.Logger.Errorf("unable to update personal certificate; err=%v, personalCert=%+v", err, personalCert)
+		return err
+	}
+
+	cmdutil.WriteString(cmd, "Resource updated")
+	return nil
+}
diff --git a/pkg/cmd/replace/replace.go b/pkg/cmd/replace/replace.go
index 4b0a129..04d81ce 100644
--- a/pkg/cmd/replace/replace.go
+++ b/pkg/cmd/replace/replace.go
@@ -91,6 +91,7 @@ func NewCommand(config *config.CLIConfig, streams io.ReadWriter, groupID string)
 	cmd.AddCommand(newAPIClientCommand(config, streams))
 	cmd.AddCommand(newApplicationCommand(config, streams))
 	cmd.AddCommand(newPasswordPolicyCommand(config, streams))
+	cmd.AddCommand(NewPersonalCertCommand(config, streams))
 
 	return cmd
 }
@@ -161,6 +162,10 @@ func (o *options) Run(cmd *cobra.Command, args []string) error {
 	case resource.ResourceTypePrefix + "PasswordPolicy":
 		options := &passwordPolicyOptions{}
 		err = options.updatePasswordPolicyFromDataMap(cmd, resourceObject.Data.(map[string]interface{}))
+
+	case resource.ResourceTypePrefix + "PersonalCert":
+		options := &personalCertOptions{}
+		err = options.updatePersonalCertFromDataMap(cmd, resourceObject.Data.(map[string]interface{}))
 	}
 
 	return err

From fe621cb96d0b26638b134aa7b5d6150bc4905b8c Mon Sep 17 00:00:00 2001
From: Manjusha Sonawane <manjusha.sonawane@ibm.com>
Date: Thu, 8 May 2025 11:20:52 +0530
Subject: [PATCH 2/9] Refactored get/certificate.go to return required response

---
 pkg/cmd/get/certificate.go | 58 +++++++++++++++++++++++---------------
 1 file changed, 36 insertions(+), 22 deletions(-)

diff --git a/pkg/cmd/get/certificate.go b/pkg/cmd/get/certificate.go
index 9825058..1bebc2b 100644
--- a/pkg/cmd/get/certificate.go
+++ b/pkg/cmd/get/certificate.go
@@ -22,27 +22,23 @@ const (
 
 var (
 	personalCertLongDesc = templates.LongDesc(cmdutil.TranslateLongDesc(personalCertMessagePrefix, `
-Get Verify personal certificate based on an optional filter or a specific personal certificate.
-
-Resources managed on Verify have specific entitlements, so ensure that the application or API client used
-with the 'auth' command is configured with the appropriate entitlements.
-
-You can identify the entitlement required by running:
-
-verifyctl get personalCert --entitlements`))
+		Get Verify personal certificate based on an optional filter or a specific personal certificate.
+ 
+		Resources managed on Verify have specific entitlements, so ensure that the application or API client used with the 'auth' command is configured with the appropriate entitlements.
+ 
+		You can identify the entitlement required by running: verifyctl get personalCert --entitlements`))
 
 	personalCertExamples = templates.Examples(cmdutil.TranslateExamples(personalCertMessagePrefix, `
-# Get a specific personal certificate by lable
-verifyctl get personalCert -o=yaml --name=testpersonalCert
-
-# Get 10 policies based on a given search criteria and sort it in the ascending order by name.
+		# Get a specific personal certificate by lable
+		verifyctl get personalCert -o=yaml --name=testpersonalCert
+ 
+		# Get 10 policies based on a given search criteria and sort it in the ascending order by name.
 		verifyctl get personal-certificate --count=2 --sort=label -o=yaml
-`))
+		`))
 )
 
 type personalCertOptions struct {
 	options
-
 	config *config.CLIConfig
 	label  string
 }
@@ -51,10 +47,9 @@ func newPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *co
 	o := &personalCertOptions{
 		config: config,
 	}
-
 	cmd := &cobra.Command{
 		Use:                   personalCertUsage,
-		Short:                 cmdutil.TranslateShortDesc(personalCertMessagePrefix, "Get Verify password policies based on an optional filter or a specific policy."),
+		Short:                 cmdutil.TranslateShortDesc(personalCertMessagePrefix, "Get Verify personal certificates based on an optional filter or a specific certificate."),
 		Long:                  personalCertLongDesc,
 		Example:               personalCertExamples,
 		Aliases:               []string{"personalCert"},
@@ -65,13 +60,10 @@ func newPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *co
 			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
 		},
 	}
-
 	cmd.SetOut(streams)
 	cmd.SetErr(streams)
 	cmd.SetIn(streams)
-
 	o.AddFlags(cmd)
-
 	return cmd
 }
 
@@ -102,27 +94,45 @@ func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
 		cmdutil.WriteString(cmd, entitlementsMessage+" "+personalCertEntitlements)
 		return nil
 	}
+
 	_, err := o.config.SetAuthToContext(cmd.Context())
 	if err != nil {
 		return err
 	}
+
 	if cmd.CalledAs() == "personalCert" || len(o.label) > 0 {
 		return o.handleSinglePersonalCert(cmd, args)
 	}
 	return o.handlePersonalCertList(cmd, args)
 }
 
-func (o *personalCertOptions) handleSinglePersonalCert(cmd *cobra.Command, _ []string) error {
+func filterPersonalCertData(pcrt *security.PersonalCert) map[string]interface{} {
+	return map[string]interface{}{
+		"notbefore":           pcrt.NotBefore,
+		"subject":             pcrt.Subject,
+		"notafter":            pcrt.NotAfter,
+		"serial_number":       pcrt.SerialNumber,
+		"label":               pcrt.Label,
+		"version":             pcrt.Version,
+		"issuer":              pcrt.Issuer,
+		"isDefault":           pcrt.IsDefault,
+		"keysize":             pcrt.KeySize,
+		"signature_algorithm": pcrt.SignatureAlgorithm,
+	}
+}
 
+func (o *personalCertOptions) handleSinglePersonalCert(cmd *cobra.Command, _ []string) error {
 	c := security.NewPersonalCertClient()
 	pcrt, uri, err := c.GetPersonalCert(cmd.Context(), o.label)
 	if err != nil {
 		return err
 	}
+
 	if o.output == "raw" {
 		cmdutil.WriteAsJSON(cmd, pcrt, cmd.OutOrStdout())
 		return nil
 	}
+
 	resourceObj := &resource.ResourceObject{
 		Kind:       resource.ResourceTypePrefix + "PersonalCert",
 		APIVersion: "1.0",
@@ -130,8 +140,9 @@ func (o *personalCertOptions) handleSinglePersonalCert(cmd *cobra.Command, _ []s
 			Name: pcrt.Label,
 			URI:  uri,
 		},
-		Data: pcrt,
+		Data: filterPersonalCertData(pcrt),
 	}
+
 	if o.output == "json" {
 		cmdutil.WriteAsJSON(cmd, resourceObj, cmd.OutOrStdout())
 	} else {
@@ -146,6 +157,7 @@ func (o *personalCertOptions) handlePersonalCertList(cmd *cobra.Command, _ []str
 	if err != nil {
 		return err
 	}
+
 	if o.output == "raw" {
 		cmdutil.WriteAsJSON(cmd, pcrts, cmd.OutOrStdout())
 		return nil
@@ -159,9 +171,10 @@ func (o *personalCertOptions) handlePersonalCertList(cmd *cobra.Command, _ []str
 			Metadata: &resource.ResourceObjectMetadata{
 				Name: pcrt.Label,
 			},
-			Data: pcrt,
+			Data: filterPersonalCertData(&pcrt),
 		})
 	}
+
 	resourceObj := &resource.ResourceObjectList{
 		Kind:       resource.ResourceTypePrefix + "List",
 		APIVersion: "1.0",
@@ -170,6 +183,7 @@ func (o *personalCertOptions) handlePersonalCertList(cmd *cobra.Command, _ []str
 		},
 		Items: items,
 	}
+
 	if o.output == "raw" || o.output == "json" {
 		cmdutil.WriteAsJSON(cmd, resourceObj, cmd.OutOrStdout())
 	} else {

From 5dbe6e73adfd446131ada9a048249bb122f10699 Mon Sep 17 00:00:00 2001
From: Manjusha Sonawane <manjusha.sonawane@ibm.com>
Date: Mon, 12 May 2025 10:47:37 +0530
Subject: [PATCH 3/9] Added support for Signer certificates for create, get,
 delete certificates to pkg\cmd module in verifyctl

---
 pkg/cmd/create/personal_cert.go  | 192 ++++++++++++++++++++++++++++++
 pkg/cmd/create/signer_cert.go    | 192 ++++++++++++++++++++++++++++++
 pkg/cmd/delete/personal_cert.go  | 108 +++++++++++++++++
 pkg/cmd/delete/signer_cert.go    | 108 +++++++++++++++++
 pkg/cmd/get/personal_cert.go     | 198 +++++++++++++++++++++++++++++++
 pkg/cmd/get/signer_cert.go       | 198 +++++++++++++++++++++++++++++++
 pkg/cmd/replace/personal_cert.go | 169 ++++++++++++++++++++++++++
 7 files changed, 1165 insertions(+)
 create mode 100644 pkg/cmd/create/personal_cert.go
 create mode 100644 pkg/cmd/create/signer_cert.go
 create mode 100644 pkg/cmd/delete/personal_cert.go
 create mode 100644 pkg/cmd/delete/signer_cert.go
 create mode 100644 pkg/cmd/get/personal_cert.go
 create mode 100644 pkg/cmd/get/signer_cert.go
 create mode 100644 pkg/cmd/replace/personal_cert.go

diff --git a/pkg/cmd/create/personal_cert.go b/pkg/cmd/create/personal_cert.go
new file mode 100644
index 0000000..6788000
--- /dev/null
+++ b/pkg/cmd/create/personal_cert.go
@@ -0,0 +1,192 @@
+package create
+
+import (
+	"encoding/json"
+	"io"
+	"os"
+
+	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
+	contextx "github.com/ibm-verify/verify-sdk-go/pkg/core/context"
+	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
+	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
+	"github.com/ibm-verify/verifyctl/pkg/cmd/resource"
+	"github.com/ibm-verify/verifyctl/pkg/config"
+	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
+	"github.com/ibm-verify/verifyctl/pkg/util/templates"
+	"github.com/spf13/cobra"
+	"gopkg.in/yaml.v3"
+)
+
+const (
+	personalCertUsage         = `personalCert [options]`
+	personalCertMessagePrefix = "CreatepersonalCert"
+	personalCertEntitlements  = "Manage personal certificates"
+	personalCertResourceName  = "personalCert"
+)
+
+var (
+	personalCertShortDesc = cmdutil.TranslateShortDesc(
+		personalCertMessagePrefix,
+		"Create a personal certificate with specified options.",
+	)
+	personalCertLongDesc = templates.LongDesc(
+		cmdutil.TranslateLongDesc(
+			personalCertMessagePrefix,
+			`Create a personal certificate resource. Resources managed on Verify require specific entitlements.
+			 Ensure the application or API client used with the 'auth' command has the "Manage personal certificates" entitlement. 
+			 Generate an empty resource file with: verifyctl create personalCert --boilerplate
+			Check required entitlements with: verifyctl create personalCert --entitlements
+			Input files can be in YAML or JSON format.`,
+		),
+	)
+	personalCertExamples = templates.Examples(
+		cmdutil.TranslateExamples(
+			personalCertMessagePrefix,
+			`# Create an empty personal certificate resource.
+		verifyctl create personalCert --boilerplate
+		# Create a personal certificate using a YAML file.
+		verifyctl create personalCert -f=./personal_cert.yaml
+		# Create a personal certificate using a JSON file.
+	verifyctl create personalCert -f=./personal_cert.json`,
+		),
+	)
+)
+
+type personalCertOptions struct {
+	options
+	file string
+}
+
+func newPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
+	o := &personalCertOptions{
+		options: options{
+			config: config,
+		},
+	}
+
+	cmd := &cobra.Command{
+		Use:                   personalCertUsage,
+		Short:                 personalCertShortDesc,
+		Long:                  personalCertLongDesc,
+		Example:               personalCertExamples,
+		DisableFlagsInUseLine: true,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
+		},
+	}
+
+	cmd.SetOut(streams)
+	cmd.SetErr(streams)
+	cmd.SetIn(streams)
+
+	o.AddFlags(cmd)
+
+	return cmd
+}
+
+func (o *personalCertOptions) AddFlags(cmd *cobra.Command) {
+	o.addCommonFlags(cmd, personalCertResourceName)
+	cmd.Flags().StringVarP(&o.file, "file", "f", "", i18n.Translate("Path to the YAML file that contains the input data."))
+}
+
+func (o *personalCertOptions) Complete(cmd *cobra.Command, args []string) error {
+	return nil
+}
+
+func (o *personalCertOptions) Validate(cmd *cobra.Command, args []string) error {
+	if o.entitlements || o.boilerplate {
+		return nil
+	}
+
+	if len(o.file) == 0 {
+		return errorsx.G11NError(i18n.Translate("'file' option is required if no other options are used."))
+	}
+	return nil
+}
+
+func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		cmdutil.WriteString(cmd, entitlementsMessage+"  "+personalCertEntitlements)
+		return nil
+	}
+
+	if o.boilerplate {
+		resourceObj := &resource.ResourceObject{
+			Kind:       resource.ResourceTypePrefix + "PersonalCert",
+			APIVersion: "1.0",
+			Data:       &security.PersonalCert{},
+		}
+
+		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
+		return nil
+	}
+
+	_, err := o.config.SetAuthToContext(cmd.Context())
+	if err != nil {
+		return err
+	}
+
+	return o.createPersonalCert(cmd)
+}
+
+func (o *personalCertOptions) createPersonalCert(cmd *cobra.Command) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+
+	b, err := os.ReadFile(o.file)
+	if err != nil {
+		vc.Logger.Errorf("unable to read file; filename=%s, err=%v", o.file, err)
+		return err
+	}
+
+	return o.createPersonalCertWithData(cmd, b)
+}
+
+func (o *personalCertOptions) createPersonalCertWithData(cmd *cobra.Command, data []byte) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+
+	personalCert := &security.PersonalCert{}
+	if err := yaml.Unmarshal(data, &personalCert); err != nil {
+		vc.Logger.Errorf("unable to unmarshal the personalCert; err=%v", err)
+		return err
+	}
+
+	client := security.NewPersonalCertClient()
+	resourceURI, err := client.CreatePersonalCert(ctx, personalCert)
+	if err != nil {
+		return err
+	}
+
+	cmdutil.WriteString(cmd, "Resource created: "+resourceURI)
+	return nil
+}
+
+func (o *personalCertOptions) createPersonalCertFromDataMap(cmd *cobra.Command, data map[string]interface{}) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+
+	personalCert := &security.PersonalCert{}
+	b, err := json.Marshal(data)
+	if err != nil {
+		vc.Logger.Errorf("failed to marshal the data map into json; err=%v", err)
+		return err
+	}
+
+	if err := json.Unmarshal(b, personalCert); err != nil {
+		vc.Logger.Errorf("unable to unmarshal to an personalCert; err=%v", err)
+		return err
+	}
+
+	client := security.NewPersonalCertClient()
+	resourceURI, err := client.CreatePersonalCert(ctx, personalCert)
+	if err != nil {
+		vc.Logger.Errorf("unable to create the personal certificate; err=%v, personalCert=%+v", err, personalCert)
+		return err
+	}
+
+	cmdutil.WriteString(cmd, "Resource created: "+resourceURI)
+	return nil
+}
diff --git a/pkg/cmd/create/signer_cert.go b/pkg/cmd/create/signer_cert.go
new file mode 100644
index 0000000..2794ba0
--- /dev/null
+++ b/pkg/cmd/create/signer_cert.go
@@ -0,0 +1,192 @@
+package create
+
+import (
+	"encoding/json"
+	"io"
+	"os"
+
+	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
+	contextx "github.com/ibm-verify/verify-sdk-go/pkg/core/context"
+	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
+	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
+	"github.com/ibm-verify/verifyctl/pkg/cmd/resource"
+	"github.com/ibm-verify/verifyctl/pkg/config"
+	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
+	"github.com/ibm-verify/verifyctl/pkg/util/templates"
+	"github.com/spf13/cobra"
+	"gopkg.in/yaml.v3"
+)
+
+const (
+	signerCertUsage         = `signerCert [options]`
+	signerCertMessagePrefix = "CreatesignerCert"
+	signerCertEntitlements  = "Manage signer certificates"
+	signerCertResourceName  = "signerCert"
+)
+
+var (
+	signerCertShortDesc = cmdutil.TranslateShortDesc(
+		signerCertMessagePrefix,
+		"Create a signer certificate with specified options.",
+	)
+	signerCertLongDesc = templates.LongDesc(
+		cmdutil.TranslateLongDesc(
+			signerCertMessagePrefix,
+			`Create a signer certificate resource. Resources managed on Verify require specific entitlements.
+			 Ensure the application or API client used with the 'auth' command has the "Manage signer certificates" entitlement. 
+			 Generate an empty resource file with: verifyctl create signerCert --boilerplate
+			Check required entitlements with: verifyctl create signerCert --entitlements
+			Input files can be in YAML or JSON format.`,
+		),
+	)
+	signerCertExamples = templates.Examples(
+		cmdutil.TranslateExamples(
+			signerCertMessagePrefix,
+			`# Create an empty signer certificate resource.
+		verifyctl create signerCert --boilerplate
+		# Create a signer certificate using a YAML file.
+		verifyctl create signerCert -f=./signer_cert.yaml
+		# Create a signer certificate using a JSON file.
+	verifyctl create signerCert -f=./signer_cert.json`,
+		),
+	)
+)
+
+type signerCertOptions struct {
+	options
+	file string
+}
+
+func newSignerCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
+	o := &signerCertOptions{
+		options: options{
+			config: config,
+		},
+	}
+
+	cmd := &cobra.Command{
+		Use:                   signerCertUsage,
+		Short:                 signerCertShortDesc,
+		Long:                  signerCertLongDesc,
+		Example:               signerCertExamples,
+		DisableFlagsInUseLine: true,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
+		},
+	}
+
+	cmd.SetOut(streams)
+	cmd.SetErr(streams)
+	cmd.SetIn(streams)
+
+	o.AddFlags(cmd)
+
+	return cmd
+}
+
+func (o *signerCertOptions) AddFlags(cmd *cobra.Command) {
+	o.addCommonFlags(cmd, signerCertResourceName)
+	cmd.Flags().StringVarP(&o.file, "file", "f", "", i18n.Translate("Path to the YAML file that contains the input data."))
+}
+
+func (o *signerCertOptions) Complete(cmd *cobra.Command, args []string) error {
+	return nil
+}
+
+func (o *signerCertOptions) Validate(cmd *cobra.Command, args []string) error {
+	if o.entitlements || o.boilerplate {
+		return nil
+	}
+
+	if len(o.file) == 0 {
+		return errorsx.G11NError(i18n.Translate("'file' option is required if no other options are used."))
+	}
+	return nil
+}
+
+func (o *signerCertOptions) Run(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		cmdutil.WriteString(cmd, entitlementsMessage+"  "+signerCertEntitlements)
+		return nil
+	}
+
+	if o.boilerplate {
+		resourceObj := &resource.ResourceObject{
+			Kind:       resource.ResourceTypePrefix + "SignerCert",
+			APIVersion: "1.0",
+			Data:       &security.SignerCert{},
+		}
+
+		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
+		return nil
+	}
+
+	_, err := o.config.SetAuthToContext(cmd.Context())
+	if err != nil {
+		return err
+	}
+
+	return o.createSignerCert(cmd)
+}
+
+func (o *signerCertOptions) createSignerCert(cmd *cobra.Command) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+
+	b, err := os.ReadFile(o.file)
+	if err != nil {
+		vc.Logger.Errorf("unable to read file; filename=%s, err=%v", o.file, err)
+		return err
+	}
+
+	return o.createSignerCertWithData(cmd, b)
+}
+
+func (o *signerCertOptions) createSignerCertWithData(cmd *cobra.Command, data []byte) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+
+	signerCert := &security.SignerCert{}
+	if err := yaml.Unmarshal(data, &signerCert); err != nil {
+		vc.Logger.Errorf("unable to unmarshal the signerCert; err=%v", err)
+		return err
+	}
+
+	client := security.NewSignerCertClient()
+	resourceURI, err := client.CreateSignerCert(ctx, signerCert)
+	if err != nil {
+		return err
+	}
+
+	cmdutil.WriteString(cmd, "Resource created: "+resourceURI)
+	return nil
+}
+
+func (o *signerCertOptions) createSignerCertFromDataMap(cmd *cobra.Command, data map[string]interface{}) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+
+	signerCert := &security.SignerCert{}
+	b, err := json.Marshal(data)
+	if err != nil {
+		vc.Logger.Errorf("failed to marshal the data map into json; err=%v", err)
+		return err
+	}
+
+	if err := json.Unmarshal(b, signerCert); err != nil {
+		vc.Logger.Errorf("unable to unmarshal to an signerCert; err=%v", err)
+		return err
+	}
+
+	client := security.NewSignerCertClient()
+	resourceURI, err := client.CreateSignerCert(ctx, signerCert)
+	if err != nil {
+		vc.Logger.Errorf("unable to create the signer certificate; err=%v, signerCert=%+v", err, signerCert)
+		return err
+	}
+
+	cmdutil.WriteString(cmd, "Resource created: "+resourceURI)
+	return nil
+}
diff --git a/pkg/cmd/delete/personal_cert.go b/pkg/cmd/delete/personal_cert.go
new file mode 100644
index 0000000..e18521f
--- /dev/null
+++ b/pkg/cmd/delete/personal_cert.go
@@ -0,0 +1,108 @@
+package delete
+
+import (
+	"io"
+
+	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
+	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
+	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
+	"github.com/ibm-verify/verifyctl/pkg/config"
+	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
+	"github.com/ibm-verify/verifyctl/pkg/util/templates"
+	"github.com/spf13/cobra"
+)
+
+const (
+	personalCertUsage         = `personalCert [options]`
+	personalCertMessagePrefix = "DeletePersonalCert"
+	personalCertEntitlements  = "Manage Personal Certs"
+	personalCertResourceName  = "personalCert"
+)
+
+var (
+	personalCertLongDesc = templates.LongDesc(cmdutil.TranslateLongDesc(personalCertMessagePrefix, `
+		Delete a personal certificate in IBM Security Verify based on label.
+		Resources managed on Verify have specific entitlements, so ensure that the application or API client used with the 'auth' command is configured with the appropriate entitlements.
+		You can identify the entitlement required by running: verifyctl delete personalCert --entitlements`))
+
+	personalCertExamples = templates.Examples(cmdutil.TranslateExamples(personalCertMessagePrefix, `
+		# Delete a personal certificate by label
+		verifyctl delete personalCert --name=certificateLabel
+	`))
+)
+
+type personalCertOptions struct {
+	options
+	config *config.CLIConfig
+	label  string
+}
+
+func NewPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
+	o := &personalCertOptions{
+		config: config,
+	}
+	cmd := &cobra.Command{
+		Use:                   personalCertUsage,
+		Short:                 cmdutil.TranslateShortDesc(personalCertMessagePrefix, "Delete Verify personal certificate based on a label."),
+		Long:                  personalCertLongDesc,
+		Example:               personalCertExamples,
+		DisableFlagsInUseLine: true,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
+		},
+	}
+	cmd.SetOut(streams)
+	cmd.SetErr(streams)
+	cmd.SetIn(streams)
+	o.AddFlags(cmd)
+	return cmd
+}
+
+func (o *personalCertOptions) AddFlags(cmd *cobra.Command) {
+	o.addCommonFlags(cmd)
+	cmd.Flags().StringVar(&o.label, "personalCertLabel", o.label, i18n.Translate("Label of the personal certificate to delete. (Required)"))
+}
+
+func (o *personalCertOptions) Complete(cmd *cobra.Command, args []string) error {
+	return nil
+}
+
+func (o *personalCertOptions) Validate(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		return nil
+	}
+	calledAs := cmd.CalledAs()
+	if calledAs == "personalCert" && o.label == "" {
+		return errorsx.G11NError(i18n.Translate("The 'name' flag is required to delete a personal certificate"))
+	}
+	return nil
+}
+
+func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		cmdutil.WriteString(cmd, entitlementsMessage+" "+personalCertEntitlements)
+		return nil
+	}
+
+	_, err := o.config.SetAuthToContext(cmd.Context())
+	if err != nil {
+		return err
+	}
+
+	if cmd.CalledAs() == "personalCert" || len(o.label) > 0 {
+		return o.handleSinglePersonalCert(cmd, args)
+	}
+	return nil
+}
+
+func (o *personalCertOptions) handleSinglePersonalCert(cmd *cobra.Command, _ []string) error {
+	c := security.NewPersonalCertClient()
+	err := c.DeletePersonalCert(cmd.Context(), o.label)
+	if err != nil {
+		return err
+	}
+	cmdutil.WriteString(cmd, "Resource deleted: "+o.label)
+	return nil
+}
diff --git a/pkg/cmd/delete/signer_cert.go b/pkg/cmd/delete/signer_cert.go
new file mode 100644
index 0000000..70d173c
--- /dev/null
+++ b/pkg/cmd/delete/signer_cert.go
@@ -0,0 +1,108 @@
+package delete
+
+import (
+	"io"
+
+	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
+	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
+	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
+	"github.com/ibm-verify/verifyctl/pkg/config"
+	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
+	"github.com/ibm-verify/verifyctl/pkg/util/templates"
+	"github.com/spf13/cobra"
+)
+
+const (
+	signerCertUsage         = `signerCert [options]`
+	signerCertMessagePrefix = "DeleteSignerCert"
+	signerCertEntitlements  = "Manage Signer Certs"
+	signerCertResourceName  = "signerCert"
+)
+
+var (
+	signerCertLongDesc = templates.LongDesc(cmdutil.TranslateLongDesc(signerCertMessagePrefix, `
+		Delete a signer certificate in IBM Security Verify based on label.
+		Resources managed on Verify have specific entitlements, so ensure that the application or API client used with the 'auth' command is configured with the appropriate entitlements.
+		You can identify the entitlement required by running: verifyctl delete signerCert --entitlements`))
+
+	signerCertExamples = templates.Examples(cmdutil.TranslateExamples(signerCertMessagePrefix, `
+		# Delete a signer certificate by label
+		verifyctl delete signerCert --name=certificateLabel
+	`))
+)
+
+type signerCertOptions struct {
+	options
+	config *config.CLIConfig
+	label  string
+}
+
+func NewSignerCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
+	o := &signerCertOptions{
+		config: config,
+	}
+	cmd := &cobra.Command{
+		Use:                   signerCertUsage,
+		Short:                 cmdutil.TranslateShortDesc(signerCertMessagePrefix, "Delete Verify signer certificate based on a label."),
+		Long:                  signerCertLongDesc,
+		Example:               signerCertExamples,
+		DisableFlagsInUseLine: true,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
+		},
+	}
+	cmd.SetOut(streams)
+	cmd.SetErr(streams)
+	cmd.SetIn(streams)
+	o.AddFlags(cmd)
+	return cmd
+}
+
+func (o *signerCertOptions) AddFlags(cmd *cobra.Command) {
+	o.addCommonFlags(cmd)
+	cmd.Flags().StringVar(&o.label, "signerCertLabel", o.label, i18n.Translate("Label of the signer certificate to delete. (Required)"))
+}
+
+func (o *signerCertOptions) Complete(cmd *cobra.Command, args []string) error {
+	return nil
+}
+
+func (o *signerCertOptions) Validate(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		return nil
+	}
+	calledAs := cmd.CalledAs()
+	if calledAs == "signerCert" && o.label == "" {
+		return errorsx.G11NError(i18n.Translate("The 'name' flag is required to delete a signer certificate"))
+	}
+	return nil
+}
+
+func (o *signerCertOptions) Run(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		cmdutil.WriteString(cmd, entitlementsMessage+" "+signerCertEntitlements)
+		return nil
+	}
+
+	_, err := o.config.SetAuthToContext(cmd.Context())
+	if err != nil {
+		return err
+	}
+
+	if cmd.CalledAs() == "signerCert" || len(o.label) > 0 {
+		return o.handleSingleSignerCert(cmd, args)
+	}
+	return nil
+}
+
+func (o *signerCertOptions) handleSingleSignerCert(cmd *cobra.Command, _ []string) error {
+	c := security.NewSignerCertClient()
+	err := c.DeleteSignerCert(cmd.Context(), o.label)
+	if err != nil {
+		return err
+	}
+	cmdutil.WriteString(cmd, "Resource deleted: "+o.label)
+	return nil
+}
diff --git a/pkg/cmd/get/personal_cert.go b/pkg/cmd/get/personal_cert.go
new file mode 100644
index 0000000..36f706b
--- /dev/null
+++ b/pkg/cmd/get/personal_cert.go
@@ -0,0 +1,198 @@
+package get
+
+import (
+	"io"
+
+	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
+	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
+	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
+	"github.com/ibm-verify/verifyctl/pkg/cmd/resource"
+	"github.com/ibm-verify/verifyctl/pkg/config"
+	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
+	"github.com/ibm-verify/verifyctl/pkg/util/templates"
+	"github.com/spf13/cobra"
+)
+
+const (
+	personalCertUsage         = `personalCerts [flags]`
+	personalCertMessagePrefix = "GetPersonalCerts"
+	personalCertEntitlements  = "Manage Personal Certs"
+	personalCertResourceName  = "personalCert"
+)
+
+var (
+	personalCertLongDesc = templates.LongDesc(cmdutil.TranslateLongDesc(personalCertMessagePrefix, `
+		Get Verify personal certificate based on an optional filter or a specific personal certificate.
+ 
+		Resources managed on Verify have specific entitlements, so ensure that the application or API client used with the 'auth' command is configured with the appropriate entitlements.
+ 
+		You can identify the entitlement required by running: verifyctl get personalCert --entitlements`))
+
+	personalCertExamples = templates.Examples(cmdutil.TranslateExamples(personalCertMessagePrefix, `
+		# Get a specific personal certificate by lable
+		verifyctl get personalCert -o=yaml --name=testpersonalCert
+ 
+		# Get 10 policies based on a given search criteria and sort it in the ascending order by name.
+		verifyctl get personal-certificate --count=2 --sort=label -o=yaml
+		`))
+)
+
+type personalCertOptions struct {
+	options
+	config *config.CLIConfig
+	label  string
+}
+
+func newPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
+	o := &personalCertOptions{
+		config: config,
+	}
+	cmd := &cobra.Command{
+		Use:                   personalCertUsage,
+		Short:                 cmdutil.TranslateShortDesc(personalCertMessagePrefix, "Get Verify personal certificates based on an optional filter or a specific certificate."),
+		Long:                  personalCertLongDesc,
+		Example:               personalCertExamples,
+		Aliases:               []string{"personalCert"},
+		DisableFlagsInUseLine: true,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
+		},
+	}
+	cmd.SetOut(streams)
+	cmd.SetErr(streams)
+	cmd.SetIn(streams)
+	o.AddFlags(cmd)
+	return cmd
+}
+
+func (o *personalCertOptions) AddFlags(cmd *cobra.Command) {
+	o.addCommonFlags(cmd, personalCertResourceName)
+	cmd.Flags().StringVar(&o.label, "personalCertLabel", o.label, i18n.Translate("personalCertName to get details"))
+	o.addSortFlags(cmd, personalCertResourceName)
+	o.addCountFlags(cmd, personalCertResourceName)
+}
+
+func (o *personalCertOptions) Complete(cmd *cobra.Command, args []string) error {
+	return nil
+}
+
+func (o *personalCertOptions) Validate(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		return nil
+	}
+	calledAs := cmd.CalledAs()
+	if calledAs == "personalCert" && o.label == "" {
+		return errorsx.G11NError(i18n.Translate("'personalCertName' flag is required."))
+	}
+	return nil
+}
+
+func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		cmdutil.WriteString(cmd, entitlementsMessage+" "+personalCertEntitlements)
+		return nil
+	}
+
+	_, err := o.config.SetAuthToContext(cmd.Context())
+	if err != nil {
+		return err
+	}
+
+	if cmd.CalledAs() == "personalCert" || len(o.label) > 0 {
+		return o.handleSinglePersonalCert(cmd, args)
+	}
+	return o.handlePersonalCertList(cmd, args)
+}
+
+func filterPersonalCertData(pcrt *security.PersonalCert, includeCert bool) map[string]interface{} {
+	data := map[string]interface{}{
+
+		"notbefore":           pcrt.NotBefore,
+		"subject":             pcrt.Subject,
+		"notafter":            pcrt.NotAfter,
+		"serial_number":       pcrt.SerialNumber,
+		"label":               pcrt.Label,
+		"version":             pcrt.Version,
+		"issuer":              pcrt.Issuer,
+		"isDefault":           pcrt.IsDefault,
+		"keysize":             pcrt.KeySize,
+		"signature_algorithm": pcrt.SignatureAlgorithm,
+	}
+	if includeCert {
+		data["cert"] = pcrt.Cert
+	}
+	return data
+}
+
+func (o *personalCertOptions) handleSinglePersonalCert(cmd *cobra.Command, _ []string) error {
+	c := security.NewPersonalCertClient()
+	pcrt, uri, err := c.GetPersonalCert(cmd.Context(), o.label)
+	if err != nil {
+		return err
+	}
+
+	if o.output == "raw" {
+		cmdutil.WriteAsJSON(cmd, pcrt, cmd.OutOrStdout())
+		return nil
+	}
+
+	resourceObj := &resource.ResourceObject{
+		Kind:       resource.ResourceTypePrefix + "PersonalCert",
+		APIVersion: "1.0",
+		Metadata: &resource.ResourceObjectMetadata{
+			Name: pcrt.Label,
+			URI:  uri,
+		},
+		Data: filterPersonalCertData(pcrt, true),
+	}
+
+	if o.output == "json" {
+		cmdutil.WriteAsJSON(cmd, resourceObj, cmd.OutOrStdout())
+	} else {
+		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
+	}
+	return nil
+}
+
+func (o *personalCertOptions) handlePersonalCertList(cmd *cobra.Command, _ []string) error {
+	c := security.NewPersonalCertClient()
+	pcrts, uri, err := c.GetPersonalCerts(cmd.Context(), o.sort, o.count)
+	if err != nil {
+		return err
+	}
+
+	if o.output == "raw" {
+		cmdutil.WriteAsJSON(cmd, pcrts, cmd.OutOrStdout())
+		return nil
+	}
+
+	items := []*resource.ResourceObject{}
+	for _, pcrt := range pcrts.PersonalCerts {
+		items = append(items, &resource.ResourceObject{
+			Kind:       resource.ResourceTypePrefix + "PersonalCert",
+			APIVersion: "1.0",
+			Metadata: &resource.ResourceObjectMetadata{
+				Name: pcrt.Label,
+			},
+			Data: filterPersonalCertData(&pcrt, false),
+		})
+	}
+
+	resourceObj := &resource.ResourceObjectList{
+		Kind:       resource.ResourceTypePrefix + "List",
+		APIVersion: "1.0",
+		Metadata: &resource.ResourceObjectMetadata{
+			URI: uri,
+		},
+		Items: items,
+	}
+
+	if o.output == "raw" || o.output == "json" {
+		cmdutil.WriteAsJSON(cmd, resourceObj, cmd.OutOrStdout())
+	} else {
+		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
+	}
+	return nil
+}
diff --git a/pkg/cmd/get/signer_cert.go b/pkg/cmd/get/signer_cert.go
new file mode 100644
index 0000000..fa84e16
--- /dev/null
+++ b/pkg/cmd/get/signer_cert.go
@@ -0,0 +1,198 @@
+package get
+
+import (
+	"io"
+
+	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
+	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
+	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
+	"github.com/ibm-verify/verifyctl/pkg/cmd/resource"
+	"github.com/ibm-verify/verifyctl/pkg/config"
+	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
+	"github.com/ibm-verify/verifyctl/pkg/util/templates"
+	"github.com/spf13/cobra"
+)
+
+const (
+	signerCertUsage         = `signerCerts [flags]`
+	signerCertMessagePrefix = "GetSignerCerts"
+	signerCertEntitlements  = "Manage Signer Certs"
+	signerCertResourceName  = "signerCert"
+)
+
+var (
+	signerCertLongDesc = templates.LongDesc(cmdutil.TranslateLongDesc(signerCertMessagePrefix, `
+		Get Verify Signer certificate based on an optional filter or a specific Signer certificate.
+
+		Resources managed on Verify have specific entitlements, so ensure that the application or API client used with the 'auth' command is configured with the appropriate entitlements.
+
+		You can identify the entitlement required by running: verifyctl get signerCert --entitlements`))
+
+	signerCertExamples = templates.Examples(cmdutil.TranslateExamples(signerCertMessagePrefix, `
+		# Get a specific Signer certificate by lable
+		verifyctl get signerCert -o=yaml --name=testsignerCert
+
+		# Get 10 policies based on a given search criteria and sort it in the ascending order by name.
+		verifyctl get Signer-certificate --count=2 --sort=label -o=yaml
+		`))
+)
+
+type signerCertOptions struct {
+	options
+	config *config.CLIConfig
+	label  string
+}
+
+func newSignerCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
+	o := &signerCertOptions{
+		config: config,
+	}
+	cmd := &cobra.Command{
+		Use:                   signerCertUsage,
+		Short:                 cmdutil.TranslateShortDesc(signerCertMessagePrefix, "Get Verify Signer certificates based on an optional filter or a specific certificate."),
+		Long:                  signerCertLongDesc,
+		Example:               signerCertExamples,
+		Aliases:               []string{"signerCert"},
+		DisableFlagsInUseLine: true,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
+		},
+	}
+	cmd.SetOut(streams)
+	cmd.SetErr(streams)
+	cmd.SetIn(streams)
+	o.AddFlags(cmd)
+	return cmd
+}
+
+func (o *signerCertOptions) AddFlags(cmd *cobra.Command) {
+	o.addCommonFlags(cmd, signerCertResourceName)
+	cmd.Flags().StringVar(&o.label, "signerCertLabel", o.label, i18n.Translate("signerCertName to get details"))
+	o.addSortFlags(cmd, signerCertResourceName)
+	o.addCountFlags(cmd, signerCertResourceName)
+}
+
+func (o *signerCertOptions) Complete(cmd *cobra.Command, args []string) error {
+	return nil
+}
+
+func (o *signerCertOptions) Validate(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		return nil
+	}
+	calledAs := cmd.CalledAs()
+	if calledAs == "signerCert" && o.label == "" {
+		return errorsx.G11NError(i18n.Translate("'signerCertName' flag is required."))
+	}
+	return nil
+}
+
+func (o *signerCertOptions) Run(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		cmdutil.WriteString(cmd, entitlementsMessage+" "+signerCertEntitlements)
+		return nil
+	}
+
+	_, err := o.config.SetAuthToContext(cmd.Context())
+	if err != nil {
+		return err
+	}
+
+	if cmd.CalledAs() == "signerCert" || len(o.label) > 0 {
+		return o.handleSingleSignerCert(cmd, args)
+	}
+	return o.handleSignerCertList(cmd, args)
+}
+
+func filterSignerCertData(scrt *security.SignerCert, includeCert bool) map[string]interface{} {
+	data := map[string]interface{}{
+
+		"notbefore":           scrt.NotBefore,
+		"subject":             scrt.Subject,
+		"notafter":            scrt.NotAfter,
+		"serial_number":       scrt.SerialNumber,
+		"label":               scrt.Label,
+		"version":             scrt.Version,
+		"issuer":              scrt.Issuer,
+		"isDefault":           scrt.IsDefault,
+		"keysize":             scrt.KeySize,
+		"signature_algorithm": scrt.SignatureAlgorithm,
+	}
+	if includeCert {
+		data["cert"] = scrt.Cert
+	}
+	return data
+}
+
+func (o *signerCertOptions) handleSingleSignerCert(cmd *cobra.Command, _ []string) error {
+	c := security.NewSignerCertClient()
+	scrt, uri, err := c.GetSignerCert(cmd.Context(), o.label)
+	if err != nil {
+		return err
+	}
+
+	if o.output == "raw" {
+		cmdutil.WriteAsJSON(cmd, scrt, cmd.OutOrStdout())
+		return nil
+	}
+
+	resourceObj := &resource.ResourceObject{
+		Kind:       resource.ResourceTypePrefix + "SignerCert",
+		APIVersion: "1.0",
+		Metadata: &resource.ResourceObjectMetadata{
+			Name: scrt.Label,
+			URI:  uri,
+		},
+		Data: filterSignerCertData(scrt, true),
+	}
+
+	if o.output == "json" {
+		cmdutil.WriteAsJSON(cmd, resourceObj, cmd.OutOrStdout())
+	} else {
+		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
+	}
+	return nil
+}
+
+func (o *signerCertOptions) handleSignerCertList(cmd *cobra.Command, _ []string) error {
+	c := security.NewSignerCertClient()
+	scrts, uri, err := c.GetSignerCerts(cmd.Context(), o.sort, o.count)
+	if err != nil {
+		return err
+	}
+
+	if o.output == "raw" {
+		cmdutil.WriteAsJSON(cmd, scrts, cmd.OutOrStdout())
+		return nil
+	}
+
+	items := []*resource.ResourceObject{}
+	for _, scrt := range scrts.SignerCerts {
+		items = append(items, &resource.ResourceObject{
+			Kind:       resource.ResourceTypePrefix + "SignerCert",
+			APIVersion: "1.0",
+			Metadata: &resource.ResourceObjectMetadata{
+				Name: scrt.Label,
+			},
+			Data: filterSignerCertData(&scrt, false),
+		})
+	}
+
+	resourceObj := &resource.ResourceObjectList{
+		Kind:       resource.ResourceTypePrefix + "List",
+		APIVersion: "1.0",
+		Metadata: &resource.ResourceObjectMetadata{
+			URI: uri,
+		},
+		Items: items,
+	}
+
+	if o.output == "raw" || o.output == "json" {
+		cmdutil.WriteAsJSON(cmd, resourceObj, cmd.OutOrStdout())
+	} else {
+		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
+	}
+	return nil
+}
diff --git a/pkg/cmd/replace/personal_cert.go b/pkg/cmd/replace/personal_cert.go
new file mode 100644
index 0000000..2f148e8
--- /dev/null
+++ b/pkg/cmd/replace/personal_cert.go
@@ -0,0 +1,169 @@
+package replace
+
+import (
+	"io"
+	"os"
+
+	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
+	contextx "github.com/ibm-verify/verify-sdk-go/pkg/core/context"
+	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
+	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
+	"github.com/ibm-verify/verifyctl/pkg/cmd/resource"
+	"github.com/ibm-verify/verifyctl/pkg/config"
+	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
+	"github.com/ibm-verify/verifyctl/pkg/util/templates"
+	"github.com/spf13/cobra"
+	"gopkg.in/yaml.v3"
+)
+
+const (
+	personalCertUsage         = `personalCert [options]`
+	personalCertMessagePrefix = "UpdatePersonalCert"
+	personalCertEntitlements  = "Manage Personal Certs"
+	personalCertResourceName  = "personalCert"
+)
+
+var (
+	personalCertShortDesc = cmdutil.TranslateShortDesc(personalCertMessagePrefix, "Update a personal certificate resource.")
+
+	personalCertLongDesc = templates.LongDesc(cmdutil.TranslateLongDesc(personalCertMessagePrefix, `
+		Update a personal certificate resource.
+		Resources managed on Verify require specific entitlements, so ensure that the application or API client used with the 'auth' command is configured with the appropriate entitlements.
+		An empty resource file can be generated using: verifyctl replace personalCert --boilerplate
+		You can identify the entitlement required by running: verifyctl replace personalCert --entitlements`))
+
+	personalCertExamples = templates.Examples(cmdutil.TranslateExamples(personalCertMessagePrefix, `
+		# Generate an empty personalCert resource template
+		verifyctl replace personalCert --boilerplate
+		# Update a personal certificate from a JSON file
+		verifyctl replace personalCert -f=./personal_cert.json
+	`))
+)
+
+type personalCertOptions struct {
+	options
+	config *config.CLIConfig
+}
+
+func NewPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
+	o := &personalCertOptions{
+		config: config,
+	}
+	cmd := &cobra.Command{
+		Use:                   personalCertUsage,
+		Short:                 personalCertShortDesc,
+		Long:                  personalCertLongDesc,
+		Example:               personalCertExamples,
+		DisableFlagsInUseLine: true,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
+			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
+		},
+	}
+	cmd.SetOut(streams)
+	cmd.SetErr(streams)
+	cmd.SetIn(streams)
+	o.AddFlags(cmd)
+	return cmd
+}
+
+func (o *personalCertOptions) AddFlags(cmd *cobra.Command) {
+	o.addCommonFlags(cmd, personalCertResourceName)
+	cmd.Flags().StringVarP(&o.file, "file", "f", "", i18n.Translate("Path to the file that contains the input data. The contents of the file are expected to be formatted to match the API contract."))
+}
+
+func (o *personalCertOptions) Complete(cmd *cobra.Command, args []string) error {
+	return nil
+}
+
+func (o *personalCertOptions) Validate(cmd *cobra.Command, args []string) error {
+	if o.entitlements || o.boilerplate {
+		return nil
+	}
+	if len(o.file) == 0 {
+		return errorsx.G11NError(i18n.Translate("'file' option is required if no other options are used."))
+	}
+	return nil
+}
+
+func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
+	if o.entitlements {
+		cmdutil.WriteString(cmd, entitlementsMessage+" "+personalCertEntitlements)
+		return nil
+	}
+
+	if o.boilerplate {
+		resourceObj := &resource.ResourceObject{
+			Kind:       resource.ResourceTypePrefix + "PersonalCert",
+			APIVersion: "1.0",
+			Data: &security.PersonalCert{
+				Label: "<label>",
+			},
+		}
+		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
+		return nil
+	}
+
+	_, err := o.config.SetAuthToContext(cmd.Context())
+	if err != nil {
+		return err
+	}
+
+	return o.updatePersonalCert(cmd)
+}
+
+func (o *personalCertOptions) updatePersonalCert(cmd *cobra.Command) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+	b, err := os.ReadFile(o.file)
+	if err != nil {
+		vc.Logger.Errorf("unable to read file; filename=%s, err=%v", o.file, err)
+		return err
+	}
+	return o.updatePersonalCertWithData(cmd, b)
+}
+
+func (o *personalCertOptions) updatePersonalCertWithData(cmd *cobra.Command, data []byte) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+	personalCert := &security.PersonalCert{}
+	if err := yaml.Unmarshal(data, &personalCert); err != nil {
+		vc.Logger.Errorf("unable to unmarshal the personalCert; err=%v", err)
+		return err
+	}
+
+	client := security.NewPersonalCertClient()
+	if err := client.UpdatePersonalCert(ctx, personalCert); err != nil {
+		vc.Logger.Errorf("unable to update the personal certificate; err=%v, personalCert=%+v", err, personalCert)
+		return err
+	}
+
+	cmdutil.WriteString(cmd, "Personal Certificate updated successfully")
+	return nil
+}
+
+func (o *personalCertOptions) updatePersonalCertFromDataMap(cmd *cobra.Command, data map[string]interface{}) error {
+	ctx := cmd.Context()
+	vc := contextx.GetVerifyContext(ctx)
+	personalCert := &security.PersonalCert{}
+	b, err := yaml.Marshal(data)
+	if err != nil {
+		vc.Logger.Errorf("failed to marshal the data map; err=%v", err)
+		return err
+	}
+
+	if err := yaml.Unmarshal(b, personalCert); err != nil {
+		vc.Logger.Errorf("unable to unmarshal to a personal certificate; err=%v", err)
+		return err
+	}
+
+	client := security.NewPersonalCertClient()
+	if err := client.UpdatePersonalCert(ctx, personalCert); err != nil {
+		vc.Logger.Errorf("unable to update personal certificate; err=%v, personalCert=%+v", err, personalCert)
+		return err
+	}
+
+	cmdutil.WriteString(cmd, "Resource updated")
+	return nil
+}

From 06b9f4b30b2051b72d50eac8105f8a4f8e17d1b5 Mon Sep 17 00:00:00 2001
From: Manjusha Sonawane <manjusha.sonawane@ibm.com>
Date: Mon, 12 May 2025 14:49:48 +0530
Subject: [PATCH 4/9] Added create/delete/get.go files for command support

---
 pkg/cmd/create/create.go | 5 +++++
 pkg/cmd/delete/delete.go | 1 +
 pkg/cmd/get/get.go       | 1 +
 3 files changed, 7 insertions(+)

diff --git a/pkg/cmd/create/create.go b/pkg/cmd/create/create.go
index 1ed6d5e..7fca7e2 100644
--- a/pkg/cmd/create/create.go
+++ b/pkg/cmd/create/create.go
@@ -95,6 +95,7 @@ func NewCommand(config *config.CLIConfig, streams io.ReadWriter, groupID string)
 	cmd.AddCommand(newApplicationCommand(config, streams))
 	cmd.AddCommand(newPasswordPolicyCommand(config, streams))
 	cmd.AddCommand(newPersonalCertCommand(config, streams))
+	cmd.AddCommand(newSignerCertCommand(config, streams))
 
 	return cmd
 }
@@ -170,6 +171,10 @@ func (o *options) Run(cmd *cobra.Command, args []string) error {
 		options := &personalCertOptions{}
 		err = options.createPersonalCertFromDataMap(cmd, resourceObject.Data.(map[string]interface{}))
 
+	case resource.ResourceTypePrefix + "SignerCert":
+		options := &signerCertOptions{}
+		err = options.createSignerCertFromDataMap(cmd, resourceObject.Data.(map[string]interface{}))
+
 	}
 
 	return err
diff --git a/pkg/cmd/delete/delete.go b/pkg/cmd/delete/delete.go
index 858d886..99948ae 100644
--- a/pkg/cmd/delete/delete.go
+++ b/pkg/cmd/delete/delete.go
@@ -76,6 +76,7 @@ func NewCommand(config *config.CLIConfig, streams io.ReadWriter, groupID string)
 	cmd.AddCommand(NewApplicationCommand(config, streams))
 	cmd.AddCommand(NewPasswordPolicyCommand(config, streams))
 	cmd.AddCommand(NewPersonalCertCommand(config, streams))
+	cmd.AddCommand(NewSignerCertCommand(config, streams))
 
 	return cmd
 }
diff --git a/pkg/cmd/get/get.go b/pkg/cmd/get/get.go
index 0ff5d0c..98e52e5 100644
--- a/pkg/cmd/get/get.go
+++ b/pkg/cmd/get/get.go
@@ -89,6 +89,7 @@ func NewCommand(config *config.CLIConfig, streams io.ReadWriter, groupID string)
 	cmd.AddCommand(NewApplicationsCommand(config, streams))
 	cmd.AddCommand(newPasswordPolicyCommand(config, streams))
 	cmd.AddCommand(newPersonalCertCommand(config, streams))
+	cmd.AddCommand(newSignerCertCommand(config, streams))
 
 	return cmd
 }

From 1e220b48f8f872b8b72c40cf9df9ddb2ae82c294 Mon Sep 17 00:00:00 2001
From: Manjusha Sonawane <manjusha.sonawane@ibm.com>
Date: Wed, 14 May 2025 10:39:50 +0530
Subject: [PATCH 5/9] Update get/signer_cert.go and get/personal_cert.go to
 align with verify-sdk repository changes

---
 pkg/cmd/get/personal_cert.go | 5 ++---
 pkg/cmd/get/signer_cert.go   | 5 ++---
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/pkg/cmd/get/personal_cert.go b/pkg/cmd/get/personal_cert.go
index 36f706b..d453beb 100644
--- a/pkg/cmd/get/personal_cert.go
+++ b/pkg/cmd/get/personal_cert.go
@@ -109,14 +109,13 @@ func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
 func filterPersonalCertData(pcrt *security.PersonalCert, includeCert bool) map[string]interface{} {
 	data := map[string]interface{}{
 
-		"notbefore":           pcrt.NotBefore,
+		"notbefore":           pcrt.Notbefore,
 		"subject":             pcrt.Subject,
-		"notafter":            pcrt.NotAfter,
+		"notafter":            pcrt.Notafter,
 		"serial_number":       pcrt.SerialNumber,
 		"label":               pcrt.Label,
 		"version":             pcrt.Version,
 		"issuer":              pcrt.Issuer,
-		"isDefault":           pcrt.IsDefault,
 		"keysize":             pcrt.KeySize,
 		"signature_algorithm": pcrt.SignatureAlgorithm,
 	}
diff --git a/pkg/cmd/get/signer_cert.go b/pkg/cmd/get/signer_cert.go
index fa84e16..bd2aac2 100644
--- a/pkg/cmd/get/signer_cert.go
+++ b/pkg/cmd/get/signer_cert.go
@@ -109,14 +109,13 @@ func (o *signerCertOptions) Run(cmd *cobra.Command, args []string) error {
 func filterSignerCertData(scrt *security.SignerCert, includeCert bool) map[string]interface{} {
 	data := map[string]interface{}{
 
-		"notbefore":           scrt.NotBefore,
+		"notbefore":           scrt.Notbefore,
 		"subject":             scrt.Subject,
-		"notafter":            scrt.NotAfter,
+		"notafter":            scrt.Notafter,
 		"serial_number":       scrt.SerialNumber,
 		"label":               scrt.Label,
 		"version":             scrt.Version,
 		"issuer":              scrt.Issuer,
-		"isDefault":           scrt.IsDefault,
 		"keysize":             scrt.KeySize,
 		"signature_algorithm": scrt.SignatureAlgorithm,
 	}

From c1d25fb202bd5a732b8daadd59d19546d282cf56 Mon Sep 17 00:00:00 2001
From: Manjusha Sonawane <manjusha.sonawane@ibm.com>
Date: Thu, 15 May 2025 14:11:10 +0530
Subject: [PATCH 6/9] Refactor get/personal_cert.go to get list of personal
 certificates

---
 pkg/cmd/get/personal_cert.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pkg/cmd/get/personal_cert.go b/pkg/cmd/get/personal_cert.go
index d453beb..c20734e 100644
--- a/pkg/cmd/get/personal_cert.go
+++ b/pkg/cmd/get/personal_cert.go
@@ -114,6 +114,7 @@ func filterPersonalCertData(pcrt *security.PersonalCert, includeCert bool) map[s
 		"notafter":            pcrt.Notafter,
 		"serial_number":       pcrt.SerialNumber,
 		"label":               pcrt.Label,
+		"isDefault":           pcrt.IsDefault,
 		"version":             pcrt.Version,
 		"issuer":              pcrt.Issuer,
 		"keysize":             pcrt.KeySize,

From 3a25bfc34d34ed97b217100a89e5a14c160ad251 Mon Sep 17 00:00:00 2001
From: Manjusha Sonawane <manjusha.sonawane@ibm.com>
Date: Thu, 15 May 2025 23:57:55 +0530
Subject: [PATCH 7/9] Refactor code to get isDefault field details in personal
 certificate

---
 pkg/cmd/get/personal_cert.go | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/pkg/cmd/get/personal_cert.go b/pkg/cmd/get/personal_cert.go
index c20734e..7ae3d38 100644
--- a/pkg/cmd/get/personal_cert.go
+++ b/pkg/cmd/get/personal_cert.go
@@ -109,14 +109,9 @@ func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
 func filterPersonalCertData(pcrt *security.PersonalCert, includeCert bool) map[string]interface{} {
 	data := map[string]interface{}{
 
-		"notbefore":           pcrt.Notbefore,
 		"subject":             pcrt.Subject,
-		"notafter":            pcrt.Notafter,
-		"serial_number":       pcrt.SerialNumber,
 		"label":               pcrt.Label,
 		"isDefault":           pcrt.IsDefault,
-		"version":             pcrt.Version,
-		"issuer":              pcrt.Issuer,
 		"keysize":             pcrt.KeySize,
 		"signature_algorithm": pcrt.SignatureAlgorithm,
 	}

From f65385ce0338a6418a38d53bc2118a1e272378c1 Mon Sep 17 00:00:00 2001
From: Sabuj Mondal <sabuj.mondal@partner.ibm.com>
Date: Thu, 22 May 2025 06:48:28 +0000
Subject: [PATCH 8/9] extra file removed

---
 pkg/cmd/create/certificate.go  | 192 --------------------------------
 pkg/cmd/delete/certificate.go  | 108 ------------------
 pkg/cmd/get/certificate.go     | 193 ---------------------------------
 pkg/cmd/replace/certificate.go | 169 -----------------------------
 4 files changed, 662 deletions(-)
 delete mode 100644 pkg/cmd/create/certificate.go
 delete mode 100644 pkg/cmd/delete/certificate.go
 delete mode 100644 pkg/cmd/get/certificate.go
 delete mode 100644 pkg/cmd/replace/certificate.go

diff --git a/pkg/cmd/create/certificate.go b/pkg/cmd/create/certificate.go
deleted file mode 100644
index b07f609..0000000
--- a/pkg/cmd/create/certificate.go
+++ /dev/null
@@ -1,192 +0,0 @@
-package create
-
-import (
-	"encoding/json"
-	"io"
-	"os"
-
-	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
-	contextx "github.com/ibm-verify/verify-sdk-go/pkg/core/context"
-	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
-	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
-	"github.com/ibm-verify/verifyctl/pkg/cmd/resource"
-	"github.com/ibm-verify/verifyctl/pkg/config"
-	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
-	"github.com/ibm-verify/verifyctl/pkg/util/templates"
-	"github.com/spf13/cobra"
-	"gopkg.in/yaml.v3"
-)
-
-const (
-	personalCertUsage         = `personalCert [options]`
-	personalCertMessagePrefix = "CreatepersonalCert"
-	personalCertEntitlements  = "Manage password policies"
-	personalCertResourceName  = "personalCert"
-)
-
-var (
-	personalCertShortDesc = cmdutil.TranslateShortDesc(
-		personalCertMessagePrefix,
-		"Create a personal certificate with specified options.",
-	)
-	personalCertLongDesc = templates.LongDesc(
-		cmdutil.TranslateLongDesc(
-			personalCertMessagePrefix,
-			`Create a personal certificate resource. Resources managed on Verify require specific entitlements.
-			 Ensure the application or API client used with the 'auth' command has the "Manage password policies" entitlement. 
-			 Generate an empty resource file with: verifyctl create personalCert --boilerplate
-			Check required entitlements with: verifyctl create personalCert --entitlements
-			Input files can be in YAML or JSON format.`,
-		),
-	)
-	personalCertExamples = templates.Examples(
-		cmdutil.TranslateExamples(
-			personalCertMessagePrefix,
-			`# Create an empty personal certificate resource.
-		verifyctl create personalCert --boilerplate
-		# Create a personal certificate using a YAML file.
-		verifyctl create personalCert -f=./personal_cert.yaml
-		# Create a personal certificate using a JSON file.
-	verifyctl create personalCert -f=./personal_cert.json`,
-		),
-	)
-)
-
-type personalCertOptions struct {
-	options
-	file string
-}
-
-func newPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
-	o := &personalCertOptions{
-		options: options{
-			config: config,
-		},
-	}
-
-	cmd := &cobra.Command{
-		Use:                   personalCertUsage,
-		Short:                 personalCertShortDesc,
-		Long:                  personalCertLongDesc,
-		Example:               personalCertExamples,
-		DisableFlagsInUseLine: true,
-		Run: func(cmd *cobra.Command, args []string) {
-			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
-			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
-			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
-		},
-	}
-
-	cmd.SetOut(streams)
-	cmd.SetErr(streams)
-	cmd.SetIn(streams)
-
-	o.AddFlags(cmd)
-
-	return cmd
-}
-
-func (o *personalCertOptions) AddFlags(cmd *cobra.Command) {
-	o.addCommonFlags(cmd, personalCertResourceName)
-	cmd.Flags().StringVarP(&o.file, "file", "f", "", i18n.Translate("Path to the YAML file that contains the input data."))
-}
-
-func (o *personalCertOptions) Complete(cmd *cobra.Command, args []string) error {
-	return nil
-}
-
-func (o *personalCertOptions) Validate(cmd *cobra.Command, args []string) error {
-	if o.entitlements || o.boilerplate {
-		return nil
-	}
-
-	if len(o.file) == 0 {
-		return errorsx.G11NError(i18n.Translate("'file' option is required if no other options are used."))
-	}
-	return nil
-}
-
-func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
-	if o.entitlements {
-		cmdutil.WriteString(cmd, entitlementsMessage+"  "+personalCertEntitlements)
-		return nil
-	}
-
-	if o.boilerplate {
-		resourceObj := &resource.ResourceObject{
-			Kind:       resource.ResourceTypePrefix + "PersonalCert",
-			APIVersion: "1.0",
-			Data:       &security.PersonalCert{},
-		}
-
-		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
-		return nil
-	}
-
-	_, err := o.config.SetAuthToContext(cmd.Context())
-	if err != nil {
-		return err
-	}
-
-	return o.createPersonalCert(cmd)
-}
-
-func (o *personalCertOptions) createPersonalCert(cmd *cobra.Command) error {
-	ctx := cmd.Context()
-	vc := contextx.GetVerifyContext(ctx)
-
-	b, err := os.ReadFile(o.file)
-	if err != nil {
-		vc.Logger.Errorf("unable to read file; filename=%s, err=%v", o.file, err)
-		return err
-	}
-
-	return o.createPersonalCertWithData(cmd, b)
-}
-
-func (o *personalCertOptions) createPersonalCertWithData(cmd *cobra.Command, data []byte) error {
-	ctx := cmd.Context()
-	vc := contextx.GetVerifyContext(ctx)
-
-	personalCert := &security.PersonalCert{}
-	if err := yaml.Unmarshal(data, &personalCert); err != nil {
-		vc.Logger.Errorf("unable to unmarshal the personalCert; err=%v", err)
-		return err
-	}
-
-	client := security.NewPersonalCertClient()
-	resourceURI, err := client.CreatePersonalCert(ctx, personalCert)
-	if err != nil {
-		return err
-	}
-
-	cmdutil.WriteString(cmd, "Resource created: "+resourceURI)
-	return nil
-}
-
-func (o *personalCertOptions) createPersonalCertFromDataMap(cmd *cobra.Command, data map[string]interface{}) error {
-	ctx := cmd.Context()
-	vc := contextx.GetVerifyContext(ctx)
-
-	personalCert := &security.PersonalCert{}
-	b, err := json.Marshal(data)
-	if err != nil {
-		vc.Logger.Errorf("failed to marshal the data map into json; err=%v", err)
-		return err
-	}
-
-	if err := json.Unmarshal(b, personalCert); err != nil {
-		vc.Logger.Errorf("unable to unmarshal to an personalCert; err=%v", err)
-		return err
-	}
-
-	client := security.NewPersonalCertClient()
-	resourceURI, err := client.CreatePersonalCert(ctx, personalCert)
-	if err != nil {
-		vc.Logger.Errorf("unable to create the password policy; err=%v, personalCert=%+v", err, personalCert)
-		return err
-	}
-
-	cmdutil.WriteString(cmd, "Resource created: "+resourceURI)
-	return nil
-}
diff --git a/pkg/cmd/delete/certificate.go b/pkg/cmd/delete/certificate.go
deleted file mode 100644
index e18521f..0000000
--- a/pkg/cmd/delete/certificate.go
+++ /dev/null
@@ -1,108 +0,0 @@
-package delete
-
-import (
-	"io"
-
-	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
-	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
-	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
-	"github.com/ibm-verify/verifyctl/pkg/config"
-	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
-	"github.com/ibm-verify/verifyctl/pkg/util/templates"
-	"github.com/spf13/cobra"
-)
-
-const (
-	personalCertUsage         = `personalCert [options]`
-	personalCertMessagePrefix = "DeletePersonalCert"
-	personalCertEntitlements  = "Manage Personal Certs"
-	personalCertResourceName  = "personalCert"
-)
-
-var (
-	personalCertLongDesc = templates.LongDesc(cmdutil.TranslateLongDesc(personalCertMessagePrefix, `
-		Delete a personal certificate in IBM Security Verify based on label.
-		Resources managed on Verify have specific entitlements, so ensure that the application or API client used with the 'auth' command is configured with the appropriate entitlements.
-		You can identify the entitlement required by running: verifyctl delete personalCert --entitlements`))
-
-	personalCertExamples = templates.Examples(cmdutil.TranslateExamples(personalCertMessagePrefix, `
-		# Delete a personal certificate by label
-		verifyctl delete personalCert --name=certificateLabel
-	`))
-)
-
-type personalCertOptions struct {
-	options
-	config *config.CLIConfig
-	label  string
-}
-
-func NewPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
-	o := &personalCertOptions{
-		config: config,
-	}
-	cmd := &cobra.Command{
-		Use:                   personalCertUsage,
-		Short:                 cmdutil.TranslateShortDesc(personalCertMessagePrefix, "Delete Verify personal certificate based on a label."),
-		Long:                  personalCertLongDesc,
-		Example:               personalCertExamples,
-		DisableFlagsInUseLine: true,
-		Run: func(cmd *cobra.Command, args []string) {
-			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
-			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
-			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
-		},
-	}
-	cmd.SetOut(streams)
-	cmd.SetErr(streams)
-	cmd.SetIn(streams)
-	o.AddFlags(cmd)
-	return cmd
-}
-
-func (o *personalCertOptions) AddFlags(cmd *cobra.Command) {
-	o.addCommonFlags(cmd)
-	cmd.Flags().StringVar(&o.label, "personalCertLabel", o.label, i18n.Translate("Label of the personal certificate to delete. (Required)"))
-}
-
-func (o *personalCertOptions) Complete(cmd *cobra.Command, args []string) error {
-	return nil
-}
-
-func (o *personalCertOptions) Validate(cmd *cobra.Command, args []string) error {
-	if o.entitlements {
-		return nil
-	}
-	calledAs := cmd.CalledAs()
-	if calledAs == "personalCert" && o.label == "" {
-		return errorsx.G11NError(i18n.Translate("The 'name' flag is required to delete a personal certificate"))
-	}
-	return nil
-}
-
-func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
-	if o.entitlements {
-		cmdutil.WriteString(cmd, entitlementsMessage+" "+personalCertEntitlements)
-		return nil
-	}
-
-	_, err := o.config.SetAuthToContext(cmd.Context())
-	if err != nil {
-		return err
-	}
-
-	if cmd.CalledAs() == "personalCert" || len(o.label) > 0 {
-		return o.handleSinglePersonalCert(cmd, args)
-	}
-	return nil
-}
-
-func (o *personalCertOptions) handleSinglePersonalCert(cmd *cobra.Command, _ []string) error {
-	c := security.NewPersonalCertClient()
-	err := c.DeletePersonalCert(cmd.Context(), o.label)
-	if err != nil {
-		return err
-	}
-	cmdutil.WriteString(cmd, "Resource deleted: "+o.label)
-	return nil
-}
diff --git a/pkg/cmd/get/certificate.go b/pkg/cmd/get/certificate.go
deleted file mode 100644
index 1bebc2b..0000000
--- a/pkg/cmd/get/certificate.go
+++ /dev/null
@@ -1,193 +0,0 @@
-package get
-
-import (
-	"io"
-
-	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
-	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
-	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
-	"github.com/ibm-verify/verifyctl/pkg/cmd/resource"
-	"github.com/ibm-verify/verifyctl/pkg/config"
-	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
-	"github.com/ibm-verify/verifyctl/pkg/util/templates"
-	"github.com/spf13/cobra"
-)
-
-const (
-	personalCertUsage         = `personalCerts [flags]`
-	personalCertMessagePrefix = "GetPersonalCerts"
-	personalCertEntitlements  = "Manage Personal Certs"
-	personalCertResourceName  = "personalCert"
-)
-
-var (
-	personalCertLongDesc = templates.LongDesc(cmdutil.TranslateLongDesc(personalCertMessagePrefix, `
-		Get Verify personal certificate based on an optional filter or a specific personal certificate.
- 
-		Resources managed on Verify have specific entitlements, so ensure that the application or API client used with the 'auth' command is configured with the appropriate entitlements.
- 
-		You can identify the entitlement required by running: verifyctl get personalCert --entitlements`))
-
-	personalCertExamples = templates.Examples(cmdutil.TranslateExamples(personalCertMessagePrefix, `
-		# Get a specific personal certificate by lable
-		verifyctl get personalCert -o=yaml --name=testpersonalCert
- 
-		# Get 10 policies based on a given search criteria and sort it in the ascending order by name.
-		verifyctl get personal-certificate --count=2 --sort=label -o=yaml
-		`))
-)
-
-type personalCertOptions struct {
-	options
-	config *config.CLIConfig
-	label  string
-}
-
-func newPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
-	o := &personalCertOptions{
-		config: config,
-	}
-	cmd := &cobra.Command{
-		Use:                   personalCertUsage,
-		Short:                 cmdutil.TranslateShortDesc(personalCertMessagePrefix, "Get Verify personal certificates based on an optional filter or a specific certificate."),
-		Long:                  personalCertLongDesc,
-		Example:               personalCertExamples,
-		Aliases:               []string{"personalCert"},
-		DisableFlagsInUseLine: true,
-		Run: func(cmd *cobra.Command, args []string) {
-			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
-			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
-			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
-		},
-	}
-	cmd.SetOut(streams)
-	cmd.SetErr(streams)
-	cmd.SetIn(streams)
-	o.AddFlags(cmd)
-	return cmd
-}
-
-func (o *personalCertOptions) AddFlags(cmd *cobra.Command) {
-	o.addCommonFlags(cmd, personalCertResourceName)
-	cmd.Flags().StringVar(&o.label, "personalCertLabel", o.label, i18n.Translate("personalCertName to get details"))
-	o.addSortFlags(cmd, personalCertResourceName)
-	o.addCountFlags(cmd, personalCertResourceName)
-}
-
-func (o *personalCertOptions) Complete(cmd *cobra.Command, args []string) error {
-	return nil
-}
-
-func (o *personalCertOptions) Validate(cmd *cobra.Command, args []string) error {
-	if o.entitlements {
-		return nil
-	}
-	calledAs := cmd.CalledAs()
-	if calledAs == "personalCert" && o.label == "" {
-		return errorsx.G11NError(i18n.Translate("'personalCertName' flag is required."))
-	}
-	return nil
-}
-
-func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
-	if o.entitlements {
-		cmdutil.WriteString(cmd, entitlementsMessage+" "+personalCertEntitlements)
-		return nil
-	}
-
-	_, err := o.config.SetAuthToContext(cmd.Context())
-	if err != nil {
-		return err
-	}
-
-	if cmd.CalledAs() == "personalCert" || len(o.label) > 0 {
-		return o.handleSinglePersonalCert(cmd, args)
-	}
-	return o.handlePersonalCertList(cmd, args)
-}
-
-func filterPersonalCertData(pcrt *security.PersonalCert) map[string]interface{} {
-	return map[string]interface{}{
-		"notbefore":           pcrt.NotBefore,
-		"subject":             pcrt.Subject,
-		"notafter":            pcrt.NotAfter,
-		"serial_number":       pcrt.SerialNumber,
-		"label":               pcrt.Label,
-		"version":             pcrt.Version,
-		"issuer":              pcrt.Issuer,
-		"isDefault":           pcrt.IsDefault,
-		"keysize":             pcrt.KeySize,
-		"signature_algorithm": pcrt.SignatureAlgorithm,
-	}
-}
-
-func (o *personalCertOptions) handleSinglePersonalCert(cmd *cobra.Command, _ []string) error {
-	c := security.NewPersonalCertClient()
-	pcrt, uri, err := c.GetPersonalCert(cmd.Context(), o.label)
-	if err != nil {
-		return err
-	}
-
-	if o.output == "raw" {
-		cmdutil.WriteAsJSON(cmd, pcrt, cmd.OutOrStdout())
-		return nil
-	}
-
-	resourceObj := &resource.ResourceObject{
-		Kind:       resource.ResourceTypePrefix + "PersonalCert",
-		APIVersion: "1.0",
-		Metadata: &resource.ResourceObjectMetadata{
-			Name: pcrt.Label,
-			URI:  uri,
-		},
-		Data: filterPersonalCertData(pcrt),
-	}
-
-	if o.output == "json" {
-		cmdutil.WriteAsJSON(cmd, resourceObj, cmd.OutOrStdout())
-	} else {
-		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
-	}
-	return nil
-}
-
-func (o *personalCertOptions) handlePersonalCertList(cmd *cobra.Command, _ []string) error {
-	c := security.NewPersonalCertClient()
-	pcrts, uri, err := c.GetPersonalCerts(cmd.Context(), o.sort, o.count)
-	if err != nil {
-		return err
-	}
-
-	if o.output == "raw" {
-		cmdutil.WriteAsJSON(cmd, pcrts, cmd.OutOrStdout())
-		return nil
-	}
-
-	items := []*resource.ResourceObject{}
-	for _, pcrt := range pcrts.PersonalCerts {
-		items = append(items, &resource.ResourceObject{
-			Kind:       resource.ResourceTypePrefix + "PersonalCert",
-			APIVersion: "1.0",
-			Metadata: &resource.ResourceObjectMetadata{
-				Name: pcrt.Label,
-			},
-			Data: filterPersonalCertData(&pcrt),
-		})
-	}
-
-	resourceObj := &resource.ResourceObjectList{
-		Kind:       resource.ResourceTypePrefix + "List",
-		APIVersion: "1.0",
-		Metadata: &resource.ResourceObjectMetadata{
-			URI: uri,
-		},
-		Items: items,
-	}
-
-	if o.output == "raw" || o.output == "json" {
-		cmdutil.WriteAsJSON(cmd, resourceObj, cmd.OutOrStdout())
-	} else {
-		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
-	}
-	return nil
-}
diff --git a/pkg/cmd/replace/certificate.go b/pkg/cmd/replace/certificate.go
deleted file mode 100644
index 2f148e8..0000000
--- a/pkg/cmd/replace/certificate.go
+++ /dev/null
@@ -1,169 +0,0 @@
-package replace
-
-import (
-	"io"
-	"os"
-
-	"github.com/ibm-verify/verify-sdk-go/pkg/config/security"
-	contextx "github.com/ibm-verify/verify-sdk-go/pkg/core/context"
-	errorsx "github.com/ibm-verify/verify-sdk-go/pkg/core/errors"
-	"github.com/ibm-verify/verify-sdk-go/pkg/i18n"
-	"github.com/ibm-verify/verifyctl/pkg/cmd/resource"
-	"github.com/ibm-verify/verifyctl/pkg/config"
-	cmdutil "github.com/ibm-verify/verifyctl/pkg/util/cmd"
-	"github.com/ibm-verify/verifyctl/pkg/util/templates"
-	"github.com/spf13/cobra"
-	"gopkg.in/yaml.v3"
-)
-
-const (
-	personalCertUsage         = `personalCert [options]`
-	personalCertMessagePrefix = "UpdatePersonalCert"
-	personalCertEntitlements  = "Manage Personal Certs"
-	personalCertResourceName  = "personalCert"
-)
-
-var (
-	personalCertShortDesc = cmdutil.TranslateShortDesc(personalCertMessagePrefix, "Update a personal certificate resource.")
-
-	personalCertLongDesc = templates.LongDesc(cmdutil.TranslateLongDesc(personalCertMessagePrefix, `
-		Update a personal certificate resource.
-		Resources managed on Verify require specific entitlements, so ensure that the application or API client used with the 'auth' command is configured with the appropriate entitlements.
-		An empty resource file can be generated using: verifyctl replace personalCert --boilerplate
-		You can identify the entitlement required by running: verifyctl replace personalCert --entitlements`))
-
-	personalCertExamples = templates.Examples(cmdutil.TranslateExamples(personalCertMessagePrefix, `
-		# Generate an empty personalCert resource template
-		verifyctl replace personalCert --boilerplate
-		# Update a personal certificate from a JSON file
-		verifyctl replace personalCert -f=./personal_cert.json
-	`))
-)
-
-type personalCertOptions struct {
-	options
-	config *config.CLIConfig
-}
-
-func NewPersonalCertCommand(config *config.CLIConfig, streams io.ReadWriter) *cobra.Command {
-	o := &personalCertOptions{
-		config: config,
-	}
-	cmd := &cobra.Command{
-		Use:                   personalCertUsage,
-		Short:                 personalCertShortDesc,
-		Long:                  personalCertLongDesc,
-		Example:               personalCertExamples,
-		DisableFlagsInUseLine: true,
-		Run: func(cmd *cobra.Command, args []string) {
-			cmdutil.ExitOnError(cmd, o.Complete(cmd, args))
-			cmdutil.ExitOnError(cmd, o.Validate(cmd, args))
-			cmdutil.ExitOnError(cmd, o.Run(cmd, args))
-		},
-	}
-	cmd.SetOut(streams)
-	cmd.SetErr(streams)
-	cmd.SetIn(streams)
-	o.AddFlags(cmd)
-	return cmd
-}
-
-func (o *personalCertOptions) AddFlags(cmd *cobra.Command) {
-	o.addCommonFlags(cmd, personalCertResourceName)
-	cmd.Flags().StringVarP(&o.file, "file", "f", "", i18n.Translate("Path to the file that contains the input data. The contents of the file are expected to be formatted to match the API contract."))
-}
-
-func (o *personalCertOptions) Complete(cmd *cobra.Command, args []string) error {
-	return nil
-}
-
-func (o *personalCertOptions) Validate(cmd *cobra.Command, args []string) error {
-	if o.entitlements || o.boilerplate {
-		return nil
-	}
-	if len(o.file) == 0 {
-		return errorsx.G11NError(i18n.Translate("'file' option is required if no other options are used."))
-	}
-	return nil
-}
-
-func (o *personalCertOptions) Run(cmd *cobra.Command, args []string) error {
-	if o.entitlements {
-		cmdutil.WriteString(cmd, entitlementsMessage+" "+personalCertEntitlements)
-		return nil
-	}
-
-	if o.boilerplate {
-		resourceObj := &resource.ResourceObject{
-			Kind:       resource.ResourceTypePrefix + "PersonalCert",
-			APIVersion: "1.0",
-			Data: &security.PersonalCert{
-				Label: "<label>",
-			},
-		}
-		cmdutil.WriteAsYAML(cmd, resourceObj, cmd.OutOrStdout())
-		return nil
-	}
-
-	_, err := o.config.SetAuthToContext(cmd.Context())
-	if err != nil {
-		return err
-	}
-
-	return o.updatePersonalCert(cmd)
-}
-
-func (o *personalCertOptions) updatePersonalCert(cmd *cobra.Command) error {
-	ctx := cmd.Context()
-	vc := contextx.GetVerifyContext(ctx)
-	b, err := os.ReadFile(o.file)
-	if err != nil {
-		vc.Logger.Errorf("unable to read file; filename=%s, err=%v", o.file, err)
-		return err
-	}
-	return o.updatePersonalCertWithData(cmd, b)
-}
-
-func (o *personalCertOptions) updatePersonalCertWithData(cmd *cobra.Command, data []byte) error {
-	ctx := cmd.Context()
-	vc := contextx.GetVerifyContext(ctx)
-	personalCert := &security.PersonalCert{}
-	if err := yaml.Unmarshal(data, &personalCert); err != nil {
-		vc.Logger.Errorf("unable to unmarshal the personalCert; err=%v", err)
-		return err
-	}
-
-	client := security.NewPersonalCertClient()
-	if err := client.UpdatePersonalCert(ctx, personalCert); err != nil {
-		vc.Logger.Errorf("unable to update the personal certificate; err=%v, personalCert=%+v", err, personalCert)
-		return err
-	}
-
-	cmdutil.WriteString(cmd, "Personal Certificate updated successfully")
-	return nil
-}
-
-func (o *personalCertOptions) updatePersonalCertFromDataMap(cmd *cobra.Command, data map[string]interface{}) error {
-	ctx := cmd.Context()
-	vc := contextx.GetVerifyContext(ctx)
-	personalCert := &security.PersonalCert{}
-	b, err := yaml.Marshal(data)
-	if err != nil {
-		vc.Logger.Errorf("failed to marshal the data map; err=%v", err)
-		return err
-	}
-
-	if err := yaml.Unmarshal(b, personalCert); err != nil {
-		vc.Logger.Errorf("unable to unmarshal to a personal certificate; err=%v", err)
-		return err
-	}
-
-	client := security.NewPersonalCertClient()
-	if err := client.UpdatePersonalCert(ctx, personalCert); err != nil {
-		vc.Logger.Errorf("unable to update personal certificate; err=%v, personalCert=%+v", err, personalCert)
-		return err
-	}
-
-	cmdutil.WriteString(cmd, "Resource updated")
-	return nil
-}

From 168bd83a43a3124d6637757dbf7c39f84d9f6e59 Mon Sep 17 00:00:00 2001
From: Manjusha Sonawane <manjusha.sonawane@ibm.com>
Date: Thu, 22 May 2025 16:02:14 +0530
Subject: [PATCH 9/9] Enhance UX with improved error messages for certificate
 commands for better user guidance\n\n- Tested create, delete, replace, and
 get operations for signer and personal certificates.

---
 pkg/cmd/create/personal_cert.go  | 4 ++--
 pkg/cmd/create/signer_cert.go    | 4 ++--
 pkg/cmd/delete/personal_cert.go  | 2 +-
 pkg/cmd/delete/signer_cert.go    | 2 +-
 pkg/cmd/get/personal_cert.go     | 6 +++---
 pkg/cmd/get/signer_cert.go       | 6 +++---
 pkg/cmd/replace/personal_cert.go | 4 ++--
 7 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/pkg/cmd/create/personal_cert.go b/pkg/cmd/create/personal_cert.go
index 6788000..33215a1 100644
--- a/pkg/cmd/create/personal_cert.go
+++ b/pkg/cmd/create/personal_cert.go
@@ -45,9 +45,9 @@ var (
 			`# Create an empty personal certificate resource.
 		verifyctl create personalCert --boilerplate
 		# Create a personal certificate using a YAML file.
-		verifyctl create personalCert -f=./personal_cert.yaml
+		verifyctl create -f=./personal_cert.yaml
 		# Create a personal certificate using a JSON file.
-	verifyctl create personalCert -f=./personal_cert.json`,
+	verifyctl create -f=./personal_cert.json`,
 		),
 	)
 )
diff --git a/pkg/cmd/create/signer_cert.go b/pkg/cmd/create/signer_cert.go
index 2794ba0..7edfac6 100644
--- a/pkg/cmd/create/signer_cert.go
+++ b/pkg/cmd/create/signer_cert.go
@@ -45,9 +45,9 @@ var (
 			`# Create an empty signer certificate resource.
 		verifyctl create signerCert --boilerplate
 		# Create a signer certificate using a YAML file.
-		verifyctl create signerCert -f=./signer_cert.yaml
+		verifyctl create -f=./signer_cert.yaml
 		# Create a signer certificate using a JSON file.
-	verifyctl create signerCert -f=./signer_cert.json`,
+	verifyctl create -f=./signer_cert.json`,
 		),
 	)
 )
diff --git a/pkg/cmd/delete/personal_cert.go b/pkg/cmd/delete/personal_cert.go
index e18521f..976d9f4 100644
--- a/pkg/cmd/delete/personal_cert.go
+++ b/pkg/cmd/delete/personal_cert.go
@@ -27,7 +27,7 @@ var (
 
 	personalCertExamples = templates.Examples(cmdutil.TranslateExamples(personalCertMessagePrefix, `
 		# Delete a personal certificate by label
-		verifyctl delete personalCert --name=certificateLabel
+		verifyctl delete personalCert --personalCertLabel=certificateLabel
 	`))
 )
 
diff --git a/pkg/cmd/delete/signer_cert.go b/pkg/cmd/delete/signer_cert.go
index 70d173c..7c530e4 100644
--- a/pkg/cmd/delete/signer_cert.go
+++ b/pkg/cmd/delete/signer_cert.go
@@ -27,7 +27,7 @@ var (
 
 	signerCertExamples = templates.Examples(cmdutil.TranslateExamples(signerCertMessagePrefix, `
 		# Delete a signer certificate by label
-		verifyctl delete signerCert --name=certificateLabel
+		verifyctl delete signerCert --signerCertLabel=certificateLabel
 	`))
 )
 
diff --git a/pkg/cmd/get/personal_cert.go b/pkg/cmd/get/personal_cert.go
index 7ae3d38..50629ed 100644
--- a/pkg/cmd/get/personal_cert.go
+++ b/pkg/cmd/get/personal_cert.go
@@ -30,10 +30,10 @@ var (
 
 	personalCertExamples = templates.Examples(cmdutil.TranslateExamples(personalCertMessagePrefix, `
 		# Get a specific personal certificate by lable
-		verifyctl get personalCert -o=yaml --name=testpersonalCert
+		verifyctl get personalCert -o=yaml --personalCertLabel=testpersonalCert
  
-		# Get 10 policies based on a given search criteria and sort it in the ascending order by name.
-		verifyctl get personal-certificate --count=2 --sort=label -o=yaml
+		# Get 2 policies based on a given search criteria and sort it in the ascending order by name.
+		verifyctl get personalCerts --count=2 --sort=personalCertLabel -o=yaml
 		`))
 )
 
diff --git a/pkg/cmd/get/signer_cert.go b/pkg/cmd/get/signer_cert.go
index bd2aac2..252a51f 100644
--- a/pkg/cmd/get/signer_cert.go
+++ b/pkg/cmd/get/signer_cert.go
@@ -30,10 +30,10 @@ var (
 
 	signerCertExamples = templates.Examples(cmdutil.TranslateExamples(signerCertMessagePrefix, `
 		# Get a specific Signer certificate by lable
-		verifyctl get signerCert -o=yaml --name=testsignerCert
+		verifyctl get signerCert -o=yaml --signerCertLabel=testsignerCert
 
-		# Get 10 policies based on a given search criteria and sort it in the ascending order by name.
-		verifyctl get Signer-certificate --count=2 --sort=label -o=yaml
+		# Get 2 policies based on a given search criteria and sort it in the ascending order by name.
+		verifyctl get signerCerts --count=2 --sort=signerCertLabel -o=yaml
 		`))
 )
 
diff --git a/pkg/cmd/replace/personal_cert.go b/pkg/cmd/replace/personal_cert.go
index 2f148e8..077fecb 100644
--- a/pkg/cmd/replace/personal_cert.go
+++ b/pkg/cmd/replace/personal_cert.go
@@ -35,8 +35,8 @@ var (
 	personalCertExamples = templates.Examples(cmdutil.TranslateExamples(personalCertMessagePrefix, `
 		# Generate an empty personalCert resource template
 		verifyctl replace personalCert --boilerplate
-		# Update a personal certificate from a JSON file
-		verifyctl replace personalCert -f=./personal_cert.json
+		# Update a personal certificate from a YAML file
+		verifyctl replace -f=./personal_cert.yaml
 	`))
 )