keyless_certificates

package
v2.0.0-beta.6 Latest Latest
Warning

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

 Go to latest Published: Mar 14, 2024 License: Apache-2.0 Imports: 9 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Error 

type Error = apierror.Error

type KeylessCertificateDeleteParams 

type KeylessCertificateDeleteParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
}

type KeylessCertificateDeleteResponse 

type KeylessCertificateDeleteResponse struct {
	// Identifier
	ID   string                               `json:"id"`
	JSON keylessCertificateDeleteResponseJSON `json:"-"`
}

func (*KeylessCertificateDeleteResponse) UnmarshalJSON 

func (r *KeylessCertificateDeleteResponse) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateDeleteResponseEnvelope 

type KeylessCertificateDeleteResponseEnvelope struct {
	Errors   []KeylessCertificateDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []KeylessCertificateDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   KeylessCertificateDeleteResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success KeylessCertificateDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    keylessCertificateDeleteResponseEnvelopeJSON    `json:"-"`
}

func (*KeylessCertificateDeleteResponseEnvelope) UnmarshalJSON 

func (r *KeylessCertificateDeleteResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateDeleteResponseEnvelopeErrors 

type KeylessCertificateDeleteResponseEnvelopeErrors struct {
	Code    int64                                              `json:"code,required"`
	Message string                                             `json:"message,required"`
	JSON    keylessCertificateDeleteResponseEnvelopeErrorsJSON `json:"-"`
}

func (*KeylessCertificateDeleteResponseEnvelopeErrors) UnmarshalJSON 

func (r *KeylessCertificateDeleteResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateDeleteResponseEnvelopeMessages 

type KeylessCertificateDeleteResponseEnvelopeMessages struct {
	Code    int64                                                `json:"code,required"`
	Message string                                               `json:"message,required"`
	JSON    keylessCertificateDeleteResponseEnvelopeMessagesJSON `json:"-"`
}

func (*KeylessCertificateDeleteResponseEnvelopeMessages) UnmarshalJSON 

func (r *KeylessCertificateDeleteResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateDeleteResponseEnvelopeSuccess 

type KeylessCertificateDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	KeylessCertificateDeleteResponseEnvelopeSuccessTrue KeylessCertificateDeleteResponseEnvelopeSuccess = true
)

type KeylessCertificateEditParams 

type KeylessCertificateEditParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// Whether or not the Keyless SSL is on or off.
	Enabled param.Field[bool] `json:"enabled"`
	// The keyless SSL name.
	Host param.Field[string] `json:"host" format:"hostname"`
	// The keyless SSL name.
	Name param.Field[string] `json:"name"`
	// The keyless SSL port used to communicate between Cloudflare and the client's
	// Keyless SSL server.
	Port param.Field[float64] `json:"port"`
	// Configuration for using Keyless SSL through a Cloudflare Tunnel
	Tunnel param.Field[KeylessCertificateEditParamsTunnel] `json:"tunnel"`
}

func (KeylessCertificateEditParams) MarshalJSON 

func (r KeylessCertificateEditParams) MarshalJSON() (data []byte, err error)

type KeylessCertificateEditParamsTunnel 

type KeylessCertificateEditParamsTunnel struct {
	// Private IP of the Key Server Host
	PrivateIP param.Field[string] `json:"private_ip,required"`
	// Cloudflare Tunnel Virtual Network ID
	VnetID param.Field[string] `json:"vnet_id,required"`
}

Configuration for using Keyless SSL through a Cloudflare Tunnel

func (KeylessCertificateEditParamsTunnel) MarshalJSON 

func (r KeylessCertificateEditParamsTunnel) MarshalJSON() (data []byte, err error)

type KeylessCertificateEditResponseEnvelope 

type KeylessCertificateEditResponseEnvelope struct {
	Errors   []KeylessCertificateEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []KeylessCertificateEditResponseEnvelopeMessages `json:"messages,required"`
	Result   TLSCertificatesAndHostnamesBase                  `json:"result,required"`
	// Whether the API call was successful
	Success KeylessCertificateEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    keylessCertificateEditResponseEnvelopeJSON    `json:"-"`
}

func (*KeylessCertificateEditResponseEnvelope) UnmarshalJSON 

func (r *KeylessCertificateEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateEditResponseEnvelopeErrors 

type KeylessCertificateEditResponseEnvelopeErrors struct {
	Code    int64                                            `json:"code,required"`
	Message string                                           `json:"message,required"`
	JSON    keylessCertificateEditResponseEnvelopeErrorsJSON `json:"-"`
}

func (*KeylessCertificateEditResponseEnvelopeErrors) UnmarshalJSON 

func (r *KeylessCertificateEditResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateEditResponseEnvelopeMessages 

type KeylessCertificateEditResponseEnvelopeMessages struct {
	Code    int64                                              `json:"code,required"`
	Message string                                             `json:"message,required"`
	JSON    keylessCertificateEditResponseEnvelopeMessagesJSON `json:"-"`
}

func (*KeylessCertificateEditResponseEnvelopeMessages) UnmarshalJSON 

func (r *KeylessCertificateEditResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateEditResponseEnvelopeSuccess 

type KeylessCertificateEditResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	KeylessCertificateEditResponseEnvelopeSuccessTrue KeylessCertificateEditResponseEnvelopeSuccess = true
)

type KeylessCertificateGetParams 

type KeylessCertificateGetParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
}

type KeylessCertificateGetResponseEnvelope 

type KeylessCertificateGetResponseEnvelope struct {
	Errors   []KeylessCertificateGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []KeylessCertificateGetResponseEnvelopeMessages `json:"messages,required"`
	Result   TLSCertificatesAndHostnamesBase                 `json:"result,required"`
	// Whether the API call was successful
	Success KeylessCertificateGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    keylessCertificateGetResponseEnvelopeJSON    `json:"-"`
}

func (*KeylessCertificateGetResponseEnvelope) UnmarshalJSON 

func (r *KeylessCertificateGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateGetResponseEnvelopeErrors 

type KeylessCertificateGetResponseEnvelopeErrors struct {
	Code    int64                                           `json:"code,required"`
	Message string                                          `json:"message,required"`
	JSON    keylessCertificateGetResponseEnvelopeErrorsJSON `json:"-"`
}

func (*KeylessCertificateGetResponseEnvelopeErrors) UnmarshalJSON 

func (r *KeylessCertificateGetResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateGetResponseEnvelopeMessages 

type KeylessCertificateGetResponseEnvelopeMessages struct {
	Code    int64                                             `json:"code,required"`
	Message string                                            `json:"message,required"`
	JSON    keylessCertificateGetResponseEnvelopeMessagesJSON `json:"-"`
}

func (*KeylessCertificateGetResponseEnvelopeMessages) UnmarshalJSON 

func (r *KeylessCertificateGetResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateGetResponseEnvelopeSuccess 

type KeylessCertificateGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	KeylessCertificateGetResponseEnvelopeSuccessTrue KeylessCertificateGetResponseEnvelopeSuccess = true
)

type KeylessCertificateListParams 

type KeylessCertificateListParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
}

type KeylessCertificateListResponseEnvelope 

type KeylessCertificateListResponseEnvelope struct {
	Errors   []KeylessCertificateListResponseEnvelopeErrors   `json:"errors,required"`
	Messages []KeylessCertificateListResponseEnvelopeMessages `json:"messages,required"`
	Result   []TLSCertificatesAndHostnamesBase                `json:"result,required,nullable"`
	// Whether the API call was successful
	Success    KeylessCertificateListResponseEnvelopeSuccess    `json:"success,required"`
	ResultInfo KeylessCertificateListResponseEnvelopeResultInfo `json:"result_info"`
	JSON       keylessCertificateListResponseEnvelopeJSON       `json:"-"`
}

func (*KeylessCertificateListResponseEnvelope) UnmarshalJSON 

func (r *KeylessCertificateListResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateListResponseEnvelopeErrors 

type KeylessCertificateListResponseEnvelopeErrors struct {
	Code    int64                                            `json:"code,required"`
	Message string                                           `json:"message,required"`
	JSON    keylessCertificateListResponseEnvelopeErrorsJSON `json:"-"`
}

func (*KeylessCertificateListResponseEnvelopeErrors) UnmarshalJSON 

func (r *KeylessCertificateListResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateListResponseEnvelopeMessages 

type KeylessCertificateListResponseEnvelopeMessages struct {
	Code    int64                                              `json:"code,required"`
	Message string                                             `json:"message,required"`
	JSON    keylessCertificateListResponseEnvelopeMessagesJSON `json:"-"`
}

func (*KeylessCertificateListResponseEnvelopeMessages) UnmarshalJSON 

func (r *KeylessCertificateListResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateListResponseEnvelopeResultInfo 

type KeylessCertificateListResponseEnvelopeResultInfo struct {
	// Total number of results for the requested service
	Count float64 `json:"count"`
	// Current page within paginated list of results
	Page float64 `json:"page"`
	// Number of results per page of results
	PerPage float64 `json:"per_page"`
	// Total results available without any search parameters
	TotalCount float64                                              `json:"total_count"`
	JSON       keylessCertificateListResponseEnvelopeResultInfoJSON `json:"-"`
}

func (*KeylessCertificateListResponseEnvelopeResultInfo) UnmarshalJSON 

func (r *KeylessCertificateListResponseEnvelopeResultInfo) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateListResponseEnvelopeSuccess 

type KeylessCertificateListResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	KeylessCertificateListResponseEnvelopeSuccessTrue KeylessCertificateListResponseEnvelopeSuccess = true
)

type KeylessCertificateNewParams 

type KeylessCertificateNewParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The zone's SSL certificate or SSL certificate and intermediate(s).
	Certificate param.Field[string] `json:"certificate,required"`
	// The keyless SSL name.
	Host param.Field[string] `json:"host,required" format:"hostname"`
	// The keyless SSL port used to communicate between Cloudflare and the client's
	// Keyless SSL server.
	Port param.Field[float64] `json:"port,required"`
	// A ubiquitous bundle has the highest probability of being verified everywhere,
	// even by clients using outdated or unusual trust stores. An optimal bundle uses
	// the shortest chain and newest intermediates. And the force bundle verifies the
	// chain, but does not otherwise modify it.
	BundleMethod param.Field[KeylessCertificateNewParamsBundleMethod] `json:"bundle_method"`
	// The keyless SSL name.
	Name param.Field[string] `json:"name"`
	// Configuration for using Keyless SSL through a Cloudflare Tunnel
	Tunnel param.Field[KeylessCertificateNewParamsTunnel] `json:"tunnel"`
}

func (KeylessCertificateNewParams) MarshalJSON 

func (r KeylessCertificateNewParams) MarshalJSON() (data []byte, err error)

type KeylessCertificateNewParamsBundleMethod 

type KeylessCertificateNewParamsBundleMethod string

A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates. And the force bundle verifies the chain, but does not otherwise modify it. 

const (
	KeylessCertificateNewParamsBundleMethodUbiquitous KeylessCertificateNewParamsBundleMethod = "ubiquitous"
	KeylessCertificateNewParamsBundleMethodOptimal    KeylessCertificateNewParamsBundleMethod = "optimal"
	KeylessCertificateNewParamsBundleMethodForce      KeylessCertificateNewParamsBundleMethod = "force"
)

type KeylessCertificateNewParamsTunnel 

type KeylessCertificateNewParamsTunnel struct {
	// Private IP of the Key Server Host
	PrivateIP param.Field[string] `json:"private_ip,required"`
	// Cloudflare Tunnel Virtual Network ID
	VnetID param.Field[string] `json:"vnet_id,required"`
}

Configuration for using Keyless SSL through a Cloudflare Tunnel

func (KeylessCertificateNewParamsTunnel) MarshalJSON 

func (r KeylessCertificateNewParamsTunnel) MarshalJSON() (data []byte, err error)

type KeylessCertificateNewResponseEnvelope 

type KeylessCertificateNewResponseEnvelope struct {
	Errors   []KeylessCertificateNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []KeylessCertificateNewResponseEnvelopeMessages `json:"messages,required"`
	Result   TLSCertificatesAndHostnamesBase                 `json:"result,required"`
	// Whether the API call was successful
	Success KeylessCertificateNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    keylessCertificateNewResponseEnvelopeJSON    `json:"-"`
}

func (*KeylessCertificateNewResponseEnvelope) UnmarshalJSON 

func (r *KeylessCertificateNewResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateNewResponseEnvelopeErrors 

type KeylessCertificateNewResponseEnvelopeErrors struct {
	Code    int64                                           `json:"code,required"`
	Message string                                          `json:"message,required"`
	JSON    keylessCertificateNewResponseEnvelopeErrorsJSON `json:"-"`
}

func (*KeylessCertificateNewResponseEnvelopeErrors) UnmarshalJSON 

func (r *KeylessCertificateNewResponseEnvelopeErrors) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateNewResponseEnvelopeMessages 

type KeylessCertificateNewResponseEnvelopeMessages struct {
	Code    int64                                             `json:"code,required"`
	Message string                                            `json:"message,required"`
	JSON    keylessCertificateNewResponseEnvelopeMessagesJSON `json:"-"`
}

func (*KeylessCertificateNewResponseEnvelopeMessages) UnmarshalJSON 

func (r *KeylessCertificateNewResponseEnvelopeMessages) UnmarshalJSON(data []byte) (err error)

type KeylessCertificateNewResponseEnvelopeSuccess 

type KeylessCertificateNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	KeylessCertificateNewResponseEnvelopeSuccessTrue KeylessCertificateNewResponseEnvelopeSuccess = true
)

type KeylessCertificateService 

type KeylessCertificateService struct {
	Options []option.RequestOption
}

KeylessCertificateService contains methods and other services that help with interacting with the cloudflare API. Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewKeylessCertificateService method instead.

func NewKeylessCertificateService 

func NewKeylessCertificateService(opts ...option.RequestOption) (r *KeylessCertificateService)

NewKeylessCertificateService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*KeylessCertificateService) Delete 

func (r *KeylessCertificateService) Delete(ctx context.Context, keylessCertificateID string, body KeylessCertificateDeleteParams, opts ...option.RequestOption) (res *KeylessCertificateDeleteResponse, err error)

Delete Keyless SSL Configuration

func (*KeylessCertificateService) Edit 

func (r *KeylessCertificateService) Edit(ctx context.Context, keylessCertificateID string, params KeylessCertificateEditParams, opts ...option.RequestOption) (res *TLSCertificatesAndHostnamesBase, err error)

This will update attributes of a Keyless SSL. Consists of one or more of the following: host,name,port.

func (*KeylessCertificateService) Get 

func (r *KeylessCertificateService) Get(ctx context.Context, keylessCertificateID string, query KeylessCertificateGetParams, opts ...option.RequestOption) (res *TLSCertificatesAndHostnamesBase, err error)

Get details for one Keyless SSL configuration.

func (*KeylessCertificateService) List 

func (r *KeylessCertificateService) List(ctx context.Context, query KeylessCertificateListParams, opts ...option.RequestOption) (res *[]TLSCertificatesAndHostnamesBase, err error)

List all Keyless SSL configurations for a given zone.

func (*KeylessCertificateService) New 

func (r *KeylessCertificateService) New(ctx context.Context, params KeylessCertificateNewParams, opts ...option.RequestOption) (res *TLSCertificatesAndHostnamesBase, err error)

Create Keyless SSL Configuration

type TLSCertificatesAndHostnamesBase 

type TLSCertificatesAndHostnamesBase struct {
	// Keyless certificate identifier tag.
	ID string `json:"id,required"`
	// When the Keyless SSL was created.
	CreatedOn time.Time `json:"created_on,required" format:"date-time"`
	// Whether or not the Keyless SSL is on or off.
	Enabled bool `json:"enabled,required"`
	// The keyless SSL name.
	Host string `json:"host,required" format:"hostname"`
	// When the Keyless SSL was last modified.
	ModifiedOn time.Time `json:"modified_on,required" format:"date-time"`
	// The keyless SSL name.
	Name string `json:"name,required"`
	// Available permissions for the Keyless SSL for the current user requesting the
	// item.
	Permissions []interface{} `json:"permissions,required"`
	// The keyless SSL port used to communicate between Cloudflare and the client's
	// Keyless SSL server.
	Port float64 `json:"port,required"`
	// Status of the Keyless SSL.
	Status TLSCertificatesAndHostnamesBaseStatus `json:"status,required"`
	// Configuration for using Keyless SSL through a Cloudflare Tunnel
	Tunnel TLSCertificatesAndHostnamesBaseTunnel `json:"tunnel"`
	JSON   tlsCertificatesAndHostnamesBaseJSON   `json:"-"`
}

func (*TLSCertificatesAndHostnamesBase) UnmarshalJSON 

func (r *TLSCertificatesAndHostnamesBase) UnmarshalJSON(data []byte) (err error)

type TLSCertificatesAndHostnamesBaseStatus 

type TLSCertificatesAndHostnamesBaseStatus string

Status of the Keyless SSL. 

const (
	TLSCertificatesAndHostnamesBaseStatusActive  TLSCertificatesAndHostnamesBaseStatus = "active"
	TLSCertificatesAndHostnamesBaseStatusDeleted TLSCertificatesAndHostnamesBaseStatus = "deleted"
)

type TLSCertificatesAndHostnamesBaseTunnel 

type TLSCertificatesAndHostnamesBaseTunnel struct {
	// Private IP of the Key Server Host
	PrivateIP string `json:"private_ip,required"`
	// Cloudflare Tunnel Virtual Network ID
	VnetID string                                    `json:"vnet_id,required"`
	JSON   tlsCertificatesAndHostnamesBaseTunnelJSON `json:"-"`
}

Configuration for using Keyless SSL through a Cloudflare Tunnel

func (*TLSCertificatesAndHostnamesBaseTunnel) UnmarshalJSON 

func (r *TLSCertificatesAndHostnamesBaseTunnel) UnmarshalJSON(data []byte) (err error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

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