secondary_dns

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: 8 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ACLDeleteParams 

type ACLDeleteParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type ACLDeleteResponse 

type ACLDeleteResponse struct {
	ID   interface{}           `json:"id"`
	JSON aclDeleteResponseJSON `json:"-"`
}

func (*ACLDeleteResponse) UnmarshalJSON 

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

type ACLDeleteResponseEnvelope 

type ACLDeleteResponseEnvelope struct {
	Errors   []ACLDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ACLDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   ACLDeleteResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success ACLDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    aclDeleteResponseEnvelopeJSON    `json:"-"`
}

func (*ACLDeleteResponseEnvelope) UnmarshalJSON 

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

type ACLDeleteResponseEnvelopeErrors 

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

func (*ACLDeleteResponseEnvelopeErrors) UnmarshalJSON 

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

type ACLDeleteResponseEnvelopeMessages 

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

func (*ACLDeleteResponseEnvelopeMessages) UnmarshalJSON 

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

type ACLDeleteResponseEnvelopeSuccess 

type ACLDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	ACLDeleteResponseEnvelopeSuccessTrue ACLDeleteResponseEnvelopeSuccess = true
)

type ACLGetParams 

type ACLGetParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type ACLGetResponseEnvelope 

type ACLGetResponseEnvelope struct {
	Errors   []ACLGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ACLGetResponseEnvelopeMessages `json:"messages,required"`
	Result   SecondaryDNSACL                  `json:"result,required"`
	// Whether the API call was successful
	Success ACLGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    aclGetResponseEnvelopeJSON    `json:"-"`
}

func (*ACLGetResponseEnvelope) UnmarshalJSON 

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

type ACLGetResponseEnvelopeErrors 

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

func (*ACLGetResponseEnvelopeErrors) UnmarshalJSON 

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

type ACLGetResponseEnvelopeMessages 

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

func (*ACLGetResponseEnvelopeMessages) UnmarshalJSON 

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

type ACLGetResponseEnvelopeSuccess 

type ACLGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	ACLGetResponseEnvelopeSuccessTrue ACLGetResponseEnvelopeSuccess = true
)

type ACLListParams 

type ACLListParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type ACLListResponseEnvelope 

type ACLListResponseEnvelope struct {
	Errors   []ACLListResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ACLListResponseEnvelopeMessages `json:"messages,required"`
	Result   []SecondaryDNSACL                 `json:"result,required,nullable"`
	// Whether the API call was successful
	Success    ACLListResponseEnvelopeSuccess    `json:"success,required"`
	ResultInfo ACLListResponseEnvelopeResultInfo `json:"result_info"`
	JSON       aclListResponseEnvelopeJSON       `json:"-"`
}

func (*ACLListResponseEnvelope) UnmarshalJSON 

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

type ACLListResponseEnvelopeErrors 

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

func (*ACLListResponseEnvelopeErrors) UnmarshalJSON 

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

type ACLListResponseEnvelopeMessages 

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

func (*ACLListResponseEnvelopeMessages) UnmarshalJSON 

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

type ACLListResponseEnvelopeResultInfo 

type ACLListResponseEnvelopeResultInfo 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       aclListResponseEnvelopeResultInfoJSON `json:"-"`
}

func (*ACLListResponseEnvelopeResultInfo) UnmarshalJSON 

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

type ACLListResponseEnvelopeSuccess 

type ACLListResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	ACLListResponseEnvelopeSuccessTrue ACLListResponseEnvelopeSuccess = true
)

type ACLNewParams 

type ACLNewParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
	Body      param.Field[interface{}] `json:"body,required"`
}

func (ACLNewParams) MarshalJSON 

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

type ACLNewResponseEnvelope 

type ACLNewResponseEnvelope struct {
	Errors   []ACLNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ACLNewResponseEnvelopeMessages `json:"messages,required"`
	Result   SecondaryDNSACL                  `json:"result,required"`
	// Whether the API call was successful
	Success ACLNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    aclNewResponseEnvelopeJSON    `json:"-"`
}

func (*ACLNewResponseEnvelope) UnmarshalJSON 

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

type ACLNewResponseEnvelopeErrors 

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

func (*ACLNewResponseEnvelopeErrors) UnmarshalJSON 

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

type ACLNewResponseEnvelopeMessages 

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

func (*ACLNewResponseEnvelopeMessages) UnmarshalJSON 

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

type ACLNewResponseEnvelopeSuccess 

type ACLNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	ACLNewResponseEnvelopeSuccessTrue ACLNewResponseEnvelopeSuccess = true
)

type ACLService 

type ACLService struct {
	Options []option.RequestOption
}

ACLService 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 NewACLService method instead.

func NewACLService 

func NewACLService(opts ...option.RequestOption) (r *ACLService)

NewACLService 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 (*ACLService) Delete 

func (r *ACLService) Delete(ctx context.Context, aclID interface{}, body ACLDeleteParams, opts ...option.RequestOption) (res *ACLDeleteResponse, err error)

Delete ACL.

func (*ACLService) Get 

func (r *ACLService) Get(ctx context.Context, aclID interface{}, query ACLGetParams, opts ...option.RequestOption) (res *SecondaryDNSACL, err error)

Get ACL.

func (*ACLService) List 

func (r *ACLService) List(ctx context.Context, query ACLListParams, opts ...option.RequestOption) (res *[]SecondaryDNSACL, err error)

List ACLs.

func (*ACLService) New 

func (r *ACLService) New(ctx context.Context, params ACLNewParams, opts ...option.RequestOption) (res *SecondaryDNSACL, err error)

Create ACL.

func (*ACLService) Update 

func (r *ACLService) Update(ctx context.Context, aclID interface{}, params ACLUpdateParams, opts ...option.RequestOption) (res *SecondaryDNSACL, err error)

Modify ACL.

type ACLUpdateParams 

type ACLUpdateParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
	// Allowed IPv4/IPv6 address range of primary or secondary nameservers. This will
	// be applied for the entire account. The IP range is used to allow additional
	// NOTIFY IPs for secondary zones and IPs Cloudflare allows AXFR/IXFR requests from
	// for primary zones. CIDRs are limited to a maximum of /24 for IPv4 and /64 for
	// IPv6 respectively.
	IPRange param.Field[string] `json:"ip_range,required"`
	// The name of the acl.
	Name param.Field[string] `json:"name,required"`
}

func (ACLUpdateParams) MarshalJSON 

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

type ACLUpdateResponseEnvelope 

type ACLUpdateResponseEnvelope struct {
	Errors   []ACLUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ACLUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   SecondaryDNSACL                     `json:"result,required"`
	// Whether the API call was successful
	Success ACLUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    aclUpdateResponseEnvelopeJSON    `json:"-"`
}

func (*ACLUpdateResponseEnvelope) UnmarshalJSON 

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

type ACLUpdateResponseEnvelopeErrors 

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

func (*ACLUpdateResponseEnvelopeErrors) UnmarshalJSON 

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

type ACLUpdateResponseEnvelopeMessages 

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

func (*ACLUpdateResponseEnvelopeMessages) UnmarshalJSON 

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

type ACLUpdateResponseEnvelopeSuccess 

type ACLUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	ACLUpdateResponseEnvelopeSuccessTrue ACLUpdateResponseEnvelopeSuccess = true
)

type Error 

type Error = apierror.Error

type ForceAXFRNewParams 

type ForceAXFRNewParams struct {
	ZoneID param.Field[interface{}] `path:"zone_id,required"`
}

type ForceAXFRNewResponseEnvelope 

type ForceAXFRNewResponseEnvelope struct {
	Errors   []ForceAXFRNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ForceAXFRNewResponseEnvelopeMessages `json:"messages,required"`
	// When force_axfr query parameter is set to true, the response is a simple string
	Result SecondaryDNSForceResult `json:"result,required"`
	// Whether the API call was successful
	Success ForceAXFRNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    forceAXFRNewResponseEnvelopeJSON    `json:"-"`
}

func (*ForceAXFRNewResponseEnvelope) UnmarshalJSON 

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

type ForceAXFRNewResponseEnvelopeErrors 

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

func (*ForceAXFRNewResponseEnvelopeErrors) UnmarshalJSON 

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

type ForceAXFRNewResponseEnvelopeMessages 

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

func (*ForceAXFRNewResponseEnvelopeMessages) UnmarshalJSON 

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

type ForceAXFRNewResponseEnvelopeSuccess 

type ForceAXFRNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	ForceAXFRNewResponseEnvelopeSuccessTrue ForceAXFRNewResponseEnvelopeSuccess = true
)

type ForceAXFRService 

type ForceAXFRService struct {
	Options []option.RequestOption
}

ForceAXFRService 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 NewForceAXFRService method instead.

func NewForceAXFRService 

func NewForceAXFRService(opts ...option.RequestOption) (r *ForceAXFRService)

NewForceAXFRService 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 (*ForceAXFRService) New 

func (r *ForceAXFRService) New(ctx context.Context, body ForceAXFRNewParams, opts ...option.RequestOption) (res *SecondaryDNSForceResult, err error)

Sends AXFR zone transfer request to primary nameserver(s).

type IncomingDeleteParams 

type IncomingDeleteParams struct {
	ZoneID param.Field[interface{}] `path:"zone_id,required"`
}

type IncomingDeleteResponse 

type IncomingDeleteResponse struct {
	ID   interface{}                `json:"id"`
	JSON incomingDeleteResponseJSON `json:"-"`
}

func (*IncomingDeleteResponse) UnmarshalJSON 

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

type IncomingDeleteResponseEnvelope 

type IncomingDeleteResponseEnvelope struct {
	Errors   []IncomingDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []IncomingDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   IncomingDeleteResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success IncomingDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    incomingDeleteResponseEnvelopeJSON    `json:"-"`
}

func (*IncomingDeleteResponseEnvelope) UnmarshalJSON 

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

type IncomingDeleteResponseEnvelopeErrors 

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

func (*IncomingDeleteResponseEnvelopeErrors) UnmarshalJSON 

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

type IncomingDeleteResponseEnvelopeMessages 

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

func (*IncomingDeleteResponseEnvelopeMessages) UnmarshalJSON 

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

type IncomingDeleteResponseEnvelopeSuccess 

type IncomingDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	IncomingDeleteResponseEnvelopeSuccessTrue IncomingDeleteResponseEnvelopeSuccess = true
)

type IncomingGetParams 

type IncomingGetParams struct {
	ZoneID param.Field[interface{}] `path:"zone_id,required"`
}

type IncomingGetResponse 

type IncomingGetResponse struct {
	ID interface{} `json:"id"`
	// How often should a secondary zone auto refresh regardless of DNS NOTIFY. Not
	// applicable for primary zones.
	AutoRefreshSeconds float64 `json:"auto_refresh_seconds"`
	// The time for a specific event.
	CheckedTime string `json:"checked_time"`
	// The time for a specific event.
	CreatedTime string `json:"created_time"`
	// The time for a specific event.
	ModifiedTime string `json:"modified_time"`
	// Zone name.
	Name string `json:"name"`
	// A list of peer tags.
	Peers []interface{} `json:"peers"`
	// The serial number of the SOA for the given zone.
	SoaSerial float64                 `json:"soa_serial"`
	JSON      incomingGetResponseJSON `json:"-"`
}

func (*IncomingGetResponse) UnmarshalJSON 

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

type IncomingGetResponseEnvelope 

type IncomingGetResponseEnvelope struct {
	Errors   []IncomingGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []IncomingGetResponseEnvelopeMessages `json:"messages,required"`
	Result   IncomingGetResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success IncomingGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    incomingGetResponseEnvelopeJSON    `json:"-"`
}

func (*IncomingGetResponseEnvelope) UnmarshalJSON 

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

type IncomingGetResponseEnvelopeErrors 

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

func (*IncomingGetResponseEnvelopeErrors) UnmarshalJSON 

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

type IncomingGetResponseEnvelopeMessages 

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

func (*IncomingGetResponseEnvelopeMessages) UnmarshalJSON 

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

type IncomingGetResponseEnvelopeSuccess 

type IncomingGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	IncomingGetResponseEnvelopeSuccessTrue IncomingGetResponseEnvelopeSuccess = true
)

type IncomingNewParams 

type IncomingNewParams struct {
	ZoneID param.Field[interface{}] `path:"zone_id,required"`
	// How often should a secondary zone auto refresh regardless of DNS NOTIFY. Not
	// applicable for primary zones.
	AutoRefreshSeconds param.Field[float64] `json:"auto_refresh_seconds,required"`
	// Zone name.
	Name param.Field[string] `json:"name,required"`
	// A list of peer tags.
	Peers param.Field[[]interface{}] `json:"peers,required"`
}

func (IncomingNewParams) MarshalJSON 

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

type IncomingNewResponse 

type IncomingNewResponse struct {
	ID interface{} `json:"id"`
	// How often should a secondary zone auto refresh regardless of DNS NOTIFY. Not
	// applicable for primary zones.
	AutoRefreshSeconds float64 `json:"auto_refresh_seconds"`
	// The time for a specific event.
	CheckedTime string `json:"checked_time"`
	// The time for a specific event.
	CreatedTime string `json:"created_time"`
	// The time for a specific event.
	ModifiedTime string `json:"modified_time"`
	// Zone name.
	Name string `json:"name"`
	// A list of peer tags.
	Peers []interface{} `json:"peers"`
	// The serial number of the SOA for the given zone.
	SoaSerial float64                 `json:"soa_serial"`
	JSON      incomingNewResponseJSON `json:"-"`
}

func (*IncomingNewResponse) UnmarshalJSON 

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

type IncomingNewResponseEnvelope 

type IncomingNewResponseEnvelope struct {
	Errors   []IncomingNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []IncomingNewResponseEnvelopeMessages `json:"messages,required"`
	Result   IncomingNewResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success IncomingNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    incomingNewResponseEnvelopeJSON    `json:"-"`
}

func (*IncomingNewResponseEnvelope) UnmarshalJSON 

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

type IncomingNewResponseEnvelopeErrors 

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

func (*IncomingNewResponseEnvelopeErrors) UnmarshalJSON 

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

type IncomingNewResponseEnvelopeMessages 

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

func (*IncomingNewResponseEnvelopeMessages) UnmarshalJSON 

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

type IncomingNewResponseEnvelopeSuccess 

type IncomingNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	IncomingNewResponseEnvelopeSuccessTrue IncomingNewResponseEnvelopeSuccess = true
)

type IncomingService 

type IncomingService struct {
	Options []option.RequestOption
}

IncomingService 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 NewIncomingService method instead.

func NewIncomingService 

func NewIncomingService(opts ...option.RequestOption) (r *IncomingService)

NewIncomingService 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 (*IncomingService) Delete 

func (r *IncomingService) Delete(ctx context.Context, body IncomingDeleteParams, opts ...option.RequestOption) (res *IncomingDeleteResponse, err error)

Delete secondary zone configuration for incoming zone transfers.

func (*IncomingService) Get 

func (r *IncomingService) Get(ctx context.Context, query IncomingGetParams, opts ...option.RequestOption) (res *IncomingGetResponse, err error)

Get secondary zone configuration for incoming zone transfers.

func (*IncomingService) New 

func (r *IncomingService) New(ctx context.Context, params IncomingNewParams, opts ...option.RequestOption) (res *IncomingNewResponse, err error)

Create secondary zone configuration for incoming zone transfers.

func (*IncomingService) Update 

func (r *IncomingService) Update(ctx context.Context, params IncomingUpdateParams, opts ...option.RequestOption) (res *IncomingUpdateResponse, err error)

Update secondary zone configuration for incoming zone transfers.

type IncomingUpdateParams 

type IncomingUpdateParams struct {
	ZoneID param.Field[interface{}] `path:"zone_id,required"`
	// How often should a secondary zone auto refresh regardless of DNS NOTIFY. Not
	// applicable for primary zones.
	AutoRefreshSeconds param.Field[float64] `json:"auto_refresh_seconds,required"`
	// Zone name.
	Name param.Field[string] `json:"name,required"`
	// A list of peer tags.
	Peers param.Field[[]interface{}] `json:"peers,required"`
}

func (IncomingUpdateParams) MarshalJSON 

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

type IncomingUpdateResponse 

type IncomingUpdateResponse struct {
	ID interface{} `json:"id"`
	// How often should a secondary zone auto refresh regardless of DNS NOTIFY. Not
	// applicable for primary zones.
	AutoRefreshSeconds float64 `json:"auto_refresh_seconds"`
	// The time for a specific event.
	CheckedTime string `json:"checked_time"`
	// The time for a specific event.
	CreatedTime string `json:"created_time"`
	// The time for a specific event.
	ModifiedTime string `json:"modified_time"`
	// Zone name.
	Name string `json:"name"`
	// A list of peer tags.
	Peers []interface{} `json:"peers"`
	// The serial number of the SOA for the given zone.
	SoaSerial float64                    `json:"soa_serial"`
	JSON      incomingUpdateResponseJSON `json:"-"`
}

func (*IncomingUpdateResponse) UnmarshalJSON 

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

type IncomingUpdateResponseEnvelope 

type IncomingUpdateResponseEnvelope struct {
	Errors   []IncomingUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []IncomingUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   IncomingUpdateResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success IncomingUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    incomingUpdateResponseEnvelopeJSON    `json:"-"`
}

func (*IncomingUpdateResponseEnvelope) UnmarshalJSON 

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

type IncomingUpdateResponseEnvelopeErrors 

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

func (*IncomingUpdateResponseEnvelopeErrors) UnmarshalJSON 

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

type IncomingUpdateResponseEnvelopeMessages 

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

func (*IncomingUpdateResponseEnvelopeMessages) UnmarshalJSON 

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

type IncomingUpdateResponseEnvelopeSuccess 

type IncomingUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	IncomingUpdateResponseEnvelopeSuccessTrue IncomingUpdateResponseEnvelopeSuccess = true
)

type OutgoingDeleteParams 

type OutgoingDeleteParams struct {
	ZoneID param.Field[interface{}] `path:"zone_id,required"`
}

type OutgoingDeleteResponse 

type OutgoingDeleteResponse struct {
	ID   interface{}                `json:"id"`
	JSON outgoingDeleteResponseJSON `json:"-"`
}

func (*OutgoingDeleteResponse) UnmarshalJSON 

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

type OutgoingDeleteResponseEnvelope 

type OutgoingDeleteResponseEnvelope struct {
	Errors   []OutgoingDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []OutgoingDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   OutgoingDeleteResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success OutgoingDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    outgoingDeleteResponseEnvelopeJSON    `json:"-"`
}

func (*OutgoingDeleteResponseEnvelope) UnmarshalJSON 

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

type OutgoingDeleteResponseEnvelopeErrors 

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

func (*OutgoingDeleteResponseEnvelopeErrors) UnmarshalJSON 

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

type OutgoingDeleteResponseEnvelopeMessages 

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

func (*OutgoingDeleteResponseEnvelopeMessages) UnmarshalJSON 

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

type OutgoingDeleteResponseEnvelopeSuccess 

type OutgoingDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	OutgoingDeleteResponseEnvelopeSuccessTrue OutgoingDeleteResponseEnvelopeSuccess = true
)

type OutgoingDisableParams 

type OutgoingDisableParams struct {
	ZoneID param.Field[interface{}] `path:"zone_id,required"`
}

type OutgoingDisableResponseEnvelope 

type OutgoingDisableResponseEnvelope struct {
	Errors   []OutgoingDisableResponseEnvelopeErrors   `json:"errors,required"`
	Messages []OutgoingDisableResponseEnvelopeMessages `json:"messages,required"`
	// The zone transfer status of a primary zone
	Result SecondaryDNSDisableTransferResult `json:"result,required"`
	// Whether the API call was successful
	Success OutgoingDisableResponseEnvelopeSuccess `json:"success,required"`
	JSON    outgoingDisableResponseEnvelopeJSON    `json:"-"`
}

func (*OutgoingDisableResponseEnvelope) UnmarshalJSON 

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

type OutgoingDisableResponseEnvelopeErrors 

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

func (*OutgoingDisableResponseEnvelopeErrors) UnmarshalJSON 

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

type OutgoingDisableResponseEnvelopeMessages 

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

func (*OutgoingDisableResponseEnvelopeMessages) UnmarshalJSON 

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

type OutgoingDisableResponseEnvelopeSuccess 

type OutgoingDisableResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	OutgoingDisableResponseEnvelopeSuccessTrue OutgoingDisableResponseEnvelopeSuccess = true
)

type OutgoingEnableParams 

type OutgoingEnableParams struct {
	ZoneID param.Field[interface{}] `path:"zone_id,required"`
}

type OutgoingEnableResponseEnvelope 

type OutgoingEnableResponseEnvelope struct {
	Errors   []OutgoingEnableResponseEnvelopeErrors   `json:"errors,required"`
	Messages []OutgoingEnableResponseEnvelopeMessages `json:"messages,required"`
	// The zone transfer status of a primary zone
	Result SecondaryDNSEnableTransferResult `json:"result,required"`
	// Whether the API call was successful
	Success OutgoingEnableResponseEnvelopeSuccess `json:"success,required"`
	JSON    outgoingEnableResponseEnvelopeJSON    `json:"-"`
}

func (*OutgoingEnableResponseEnvelope) UnmarshalJSON 

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

type OutgoingEnableResponseEnvelopeErrors 

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

func (*OutgoingEnableResponseEnvelopeErrors) UnmarshalJSON 

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

type OutgoingEnableResponseEnvelopeMessages 

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

func (*OutgoingEnableResponseEnvelopeMessages) UnmarshalJSON 

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

type OutgoingEnableResponseEnvelopeSuccess 

type OutgoingEnableResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	OutgoingEnableResponseEnvelopeSuccessTrue OutgoingEnableResponseEnvelopeSuccess = true
)

type OutgoingForceNotifyParams 

type OutgoingForceNotifyParams struct {
	ZoneID param.Field[interface{}] `path:"zone_id,required"`
}

type OutgoingForceNotifyResponseEnvelope 

type OutgoingForceNotifyResponseEnvelope struct {
	Errors   []OutgoingForceNotifyResponseEnvelopeErrors   `json:"errors,required"`
	Messages []OutgoingForceNotifyResponseEnvelopeMessages `json:"messages,required"`
	// When force_notify query parameter is set to true, the response is a simple
	// string
	Result SecondaryDNSSchemasForceResult `json:"result,required"`
	// Whether the API call was successful
	Success OutgoingForceNotifyResponseEnvelopeSuccess `json:"success,required"`
	JSON    outgoingForceNotifyResponseEnvelopeJSON    `json:"-"`
}

func (*OutgoingForceNotifyResponseEnvelope) UnmarshalJSON 

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

type OutgoingForceNotifyResponseEnvelopeErrors 

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

func (*OutgoingForceNotifyResponseEnvelopeErrors) UnmarshalJSON 

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

type OutgoingForceNotifyResponseEnvelopeMessages 

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

func (*OutgoingForceNotifyResponseEnvelopeMessages) UnmarshalJSON 

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

type OutgoingForceNotifyResponseEnvelopeSuccess 

type OutgoingForceNotifyResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	OutgoingForceNotifyResponseEnvelopeSuccessTrue OutgoingForceNotifyResponseEnvelopeSuccess = true
)

type OutgoingGetParams 

type OutgoingGetParams struct {
	ZoneID param.Field[interface{}] `path:"zone_id,required"`
}

type OutgoingGetResponse 

type OutgoingGetResponse struct {
	ID interface{} `json:"id"`
	// The time for a specific event.
	CheckedTime string `json:"checked_time"`
	// The time for a specific event.
	CreatedTime string `json:"created_time"`
	// The time for a specific event.
	LastTransferredTime string `json:"last_transferred_time"`
	// Zone name.
	Name string `json:"name"`
	// A list of peer tags.
	Peers []interface{} `json:"peers"`
	// The serial number of the SOA for the given zone.
	SoaSerial float64                 `json:"soa_serial"`
	JSON      outgoingGetResponseJSON `json:"-"`
}

func (*OutgoingGetResponse) UnmarshalJSON 

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

type OutgoingGetResponseEnvelope 

type OutgoingGetResponseEnvelope struct {
	Errors   []OutgoingGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []OutgoingGetResponseEnvelopeMessages `json:"messages,required"`
	Result   OutgoingGetResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success OutgoingGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    outgoingGetResponseEnvelopeJSON    `json:"-"`
}

func (*OutgoingGetResponseEnvelope) UnmarshalJSON 

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

type OutgoingGetResponseEnvelopeErrors 

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

func (*OutgoingGetResponseEnvelopeErrors) UnmarshalJSON 

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

type OutgoingGetResponseEnvelopeMessages 

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

func (*OutgoingGetResponseEnvelopeMessages) UnmarshalJSON 

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

type OutgoingGetResponseEnvelopeSuccess 

type OutgoingGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	OutgoingGetResponseEnvelopeSuccessTrue OutgoingGetResponseEnvelopeSuccess = true
)

type OutgoingNewParams 

type OutgoingNewParams struct {
	ZoneID param.Field[interface{}] `path:"zone_id,required"`
	// Zone name.
	Name param.Field[string] `json:"name,required"`
	// A list of peer tags.
	Peers param.Field[[]interface{}] `json:"peers,required"`
}

func (OutgoingNewParams) MarshalJSON 

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

type OutgoingNewResponse 

type OutgoingNewResponse struct {
	ID interface{} `json:"id"`
	// The time for a specific event.
	CheckedTime string `json:"checked_time"`
	// The time for a specific event.
	CreatedTime string `json:"created_time"`
	// The time for a specific event.
	LastTransferredTime string `json:"last_transferred_time"`
	// Zone name.
	Name string `json:"name"`
	// A list of peer tags.
	Peers []interface{} `json:"peers"`
	// The serial number of the SOA for the given zone.
	SoaSerial float64                 `json:"soa_serial"`
	JSON      outgoingNewResponseJSON `json:"-"`
}

func (*OutgoingNewResponse) UnmarshalJSON 

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

type OutgoingNewResponseEnvelope 

type OutgoingNewResponseEnvelope struct {
	Errors   []OutgoingNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []OutgoingNewResponseEnvelopeMessages `json:"messages,required"`
	Result   OutgoingNewResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success OutgoingNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    outgoingNewResponseEnvelopeJSON    `json:"-"`
}

func (*OutgoingNewResponseEnvelope) UnmarshalJSON 

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

type OutgoingNewResponseEnvelopeErrors 

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

func (*OutgoingNewResponseEnvelopeErrors) UnmarshalJSON 

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

type OutgoingNewResponseEnvelopeMessages 

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

func (*OutgoingNewResponseEnvelopeMessages) UnmarshalJSON 

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

type OutgoingNewResponseEnvelopeSuccess 

type OutgoingNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	OutgoingNewResponseEnvelopeSuccessTrue OutgoingNewResponseEnvelopeSuccess = true
)

type OutgoingService 

type OutgoingService struct {
	Options []option.RequestOption
	Status  *OutgoingStatusService
}

OutgoingService 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 NewOutgoingService method instead.

func NewOutgoingService 

func NewOutgoingService(opts ...option.RequestOption) (r *OutgoingService)

NewOutgoingService 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 (*OutgoingService) Delete 

func (r *OutgoingService) Delete(ctx context.Context, body OutgoingDeleteParams, opts ...option.RequestOption) (res *OutgoingDeleteResponse, err error)

Delete primary zone configuration for outgoing zone transfers.

func (*OutgoingService) Disable 

func (r *OutgoingService) Disable(ctx context.Context, body OutgoingDisableParams, opts ...option.RequestOption) (res *SecondaryDNSDisableTransferResult, err error)

Disable outgoing zone transfers for primary zone and clears IXFR backlog of primary zone.

func (*OutgoingService) Enable 

func (r *OutgoingService) Enable(ctx context.Context, body OutgoingEnableParams, opts ...option.RequestOption) (res *SecondaryDNSEnableTransferResult, err error)

Enable outgoing zone transfers for primary zone.

func (*OutgoingService) ForceNotify 

func (r *OutgoingService) ForceNotify(ctx context.Context, body OutgoingForceNotifyParams, opts ...option.RequestOption) (res *SecondaryDNSSchemasForceResult, err error)

Notifies the secondary nameserver(s) and clears IXFR backlog of primary zone.

func (*OutgoingService) Get 

func (r *OutgoingService) Get(ctx context.Context, query OutgoingGetParams, opts ...option.RequestOption) (res *OutgoingGetResponse, err error)

Get primary zone configuration for outgoing zone transfers.

func (*OutgoingService) New 

func (r *OutgoingService) New(ctx context.Context, params OutgoingNewParams, opts ...option.RequestOption) (res *OutgoingNewResponse, err error)

Create primary zone configuration for outgoing zone transfers.

func (*OutgoingService) Update 

func (r *OutgoingService) Update(ctx context.Context, params OutgoingUpdateParams, opts ...option.RequestOption) (res *OutgoingUpdateResponse, err error)

Update primary zone configuration for outgoing zone transfers.

type OutgoingStatusGetParams 

type OutgoingStatusGetParams struct {
	ZoneID param.Field[interface{}] `path:"zone_id,required"`
}

type OutgoingStatusGetResponseEnvelope 

type OutgoingStatusGetResponseEnvelope struct {
	Errors   []OutgoingStatusGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []OutgoingStatusGetResponseEnvelopeMessages `json:"messages,required"`
	// The zone transfer status of a primary zone
	Result SecondaryDNSEnableTransferResult `json:"result,required"`
	// Whether the API call was successful
	Success OutgoingStatusGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    outgoingStatusGetResponseEnvelopeJSON    `json:"-"`
}

func (*OutgoingStatusGetResponseEnvelope) UnmarshalJSON 

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

type OutgoingStatusGetResponseEnvelopeErrors 

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

func (*OutgoingStatusGetResponseEnvelopeErrors) UnmarshalJSON 

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

type OutgoingStatusGetResponseEnvelopeMessages 

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

func (*OutgoingStatusGetResponseEnvelopeMessages) UnmarshalJSON 

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

type OutgoingStatusGetResponseEnvelopeSuccess 

type OutgoingStatusGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	OutgoingStatusGetResponseEnvelopeSuccessTrue OutgoingStatusGetResponseEnvelopeSuccess = true
)

type OutgoingStatusService 

type OutgoingStatusService struct {
	Options []option.RequestOption
}

OutgoingStatusService 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 NewOutgoingStatusService method instead.

func NewOutgoingStatusService 

func NewOutgoingStatusService(opts ...option.RequestOption) (r *OutgoingStatusService)

NewOutgoingStatusService 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 (*OutgoingStatusService) Get 

func (r *OutgoingStatusService) Get(ctx context.Context, query OutgoingStatusGetParams, opts ...option.RequestOption) (res *SecondaryDNSEnableTransferResult, err error)

Get primary zone transfer status.

type OutgoingUpdateParams 

type OutgoingUpdateParams struct {
	ZoneID param.Field[interface{}] `path:"zone_id,required"`
	// Zone name.
	Name param.Field[string] `json:"name,required"`
	// A list of peer tags.
	Peers param.Field[[]interface{}] `json:"peers,required"`
}

func (OutgoingUpdateParams) MarshalJSON 

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

type OutgoingUpdateResponse 

type OutgoingUpdateResponse struct {
	ID interface{} `json:"id"`
	// The time for a specific event.
	CheckedTime string `json:"checked_time"`
	// The time for a specific event.
	CreatedTime string `json:"created_time"`
	// The time for a specific event.
	LastTransferredTime string `json:"last_transferred_time"`
	// Zone name.
	Name string `json:"name"`
	// A list of peer tags.
	Peers []interface{} `json:"peers"`
	// The serial number of the SOA for the given zone.
	SoaSerial float64                    `json:"soa_serial"`
	JSON      outgoingUpdateResponseJSON `json:"-"`
}

func (*OutgoingUpdateResponse) UnmarshalJSON 

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

type OutgoingUpdateResponseEnvelope 

type OutgoingUpdateResponseEnvelope struct {
	Errors   []OutgoingUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []OutgoingUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   OutgoingUpdateResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success OutgoingUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    outgoingUpdateResponseEnvelopeJSON    `json:"-"`
}

func (*OutgoingUpdateResponseEnvelope) UnmarshalJSON 

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

type OutgoingUpdateResponseEnvelopeErrors 

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

func (*OutgoingUpdateResponseEnvelopeErrors) UnmarshalJSON 

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

type OutgoingUpdateResponseEnvelopeMessages 

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

func (*OutgoingUpdateResponseEnvelopeMessages) UnmarshalJSON 

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

type OutgoingUpdateResponseEnvelopeSuccess 

type OutgoingUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	OutgoingUpdateResponseEnvelopeSuccessTrue OutgoingUpdateResponseEnvelopeSuccess = true
)

type PeerDeleteParams 

type PeerDeleteParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type PeerDeleteResponse 

type PeerDeleteResponse struct {
	ID   interface{}            `json:"id"`
	JSON peerDeleteResponseJSON `json:"-"`
}

func (*PeerDeleteResponse) UnmarshalJSON 

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

type PeerDeleteResponseEnvelope 

type PeerDeleteResponseEnvelope struct {
	Errors   []PeerDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []PeerDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   PeerDeleteResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success PeerDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    peerDeleteResponseEnvelopeJSON    `json:"-"`
}

func (*PeerDeleteResponseEnvelope) UnmarshalJSON 

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

type PeerDeleteResponseEnvelopeErrors 

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

func (*PeerDeleteResponseEnvelopeErrors) UnmarshalJSON 

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

type PeerDeleteResponseEnvelopeMessages 

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

func (*PeerDeleteResponseEnvelopeMessages) UnmarshalJSON 

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

type PeerDeleteResponseEnvelopeSuccess 

type PeerDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	PeerDeleteResponseEnvelopeSuccessTrue PeerDeleteResponseEnvelopeSuccess = true
)

type PeerGetParams 

type PeerGetParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type PeerGetResponseEnvelope 

type PeerGetResponseEnvelope struct {
	Errors   []PeerGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []PeerGetResponseEnvelopeMessages `json:"messages,required"`
	Result   SecondaryDNSPeer                  `json:"result,required"`
	// Whether the API call was successful
	Success PeerGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    peerGetResponseEnvelopeJSON    `json:"-"`
}

func (*PeerGetResponseEnvelope) UnmarshalJSON 

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

type PeerGetResponseEnvelopeErrors 

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

func (*PeerGetResponseEnvelopeErrors) UnmarshalJSON 

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

type PeerGetResponseEnvelopeMessages 

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

func (*PeerGetResponseEnvelopeMessages) UnmarshalJSON 

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

type PeerGetResponseEnvelopeSuccess 

type PeerGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	PeerGetResponseEnvelopeSuccessTrue PeerGetResponseEnvelopeSuccess = true
)

type PeerListParams 

type PeerListParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type PeerListResponseEnvelope 

type PeerListResponseEnvelope struct {
	Errors   []PeerListResponseEnvelopeErrors   `json:"errors,required"`
	Messages []PeerListResponseEnvelopeMessages `json:"messages,required"`
	Result   []SecondaryDNSPeer                 `json:"result,required,nullable"`
	// Whether the API call was successful
	Success    PeerListResponseEnvelopeSuccess    `json:"success,required"`
	ResultInfo PeerListResponseEnvelopeResultInfo `json:"result_info"`
	JSON       peerListResponseEnvelopeJSON       `json:"-"`
}

func (*PeerListResponseEnvelope) UnmarshalJSON 

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

type PeerListResponseEnvelopeErrors 

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

func (*PeerListResponseEnvelopeErrors) UnmarshalJSON 

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

type PeerListResponseEnvelopeMessages 

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

func (*PeerListResponseEnvelopeMessages) UnmarshalJSON 

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

type PeerListResponseEnvelopeResultInfo 

type PeerListResponseEnvelopeResultInfo 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       peerListResponseEnvelopeResultInfoJSON `json:"-"`
}

func (*PeerListResponseEnvelopeResultInfo) UnmarshalJSON 

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

type PeerListResponseEnvelopeSuccess 

type PeerListResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	PeerListResponseEnvelopeSuccessTrue PeerListResponseEnvelopeSuccess = true
)

type PeerNewParams 

type PeerNewParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
	Body      param.Field[interface{}] `json:"body,required"`
}

func (PeerNewParams) MarshalJSON 

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

type PeerNewResponseEnvelope 

type PeerNewResponseEnvelope struct {
	Errors   []PeerNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []PeerNewResponseEnvelopeMessages `json:"messages,required"`
	Result   SecondaryDNSPeer                  `json:"result,required"`
	// Whether the API call was successful
	Success PeerNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    peerNewResponseEnvelopeJSON    `json:"-"`
}

func (*PeerNewResponseEnvelope) UnmarshalJSON 

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

type PeerNewResponseEnvelopeErrors 

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

func (*PeerNewResponseEnvelopeErrors) UnmarshalJSON 

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

type PeerNewResponseEnvelopeMessages 

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

func (*PeerNewResponseEnvelopeMessages) UnmarshalJSON 

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

type PeerNewResponseEnvelopeSuccess 

type PeerNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	PeerNewResponseEnvelopeSuccessTrue PeerNewResponseEnvelopeSuccess = true
)

type PeerService 

type PeerService struct {
	Options []option.RequestOption
}

PeerService 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 NewPeerService method instead.

func NewPeerService 

func NewPeerService(opts ...option.RequestOption) (r *PeerService)

NewPeerService 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 (*PeerService) Delete 

func (r *PeerService) Delete(ctx context.Context, peerID interface{}, body PeerDeleteParams, opts ...option.RequestOption) (res *PeerDeleteResponse, err error)

Delete Peer.

func (*PeerService) Get 

func (r *PeerService) Get(ctx context.Context, peerID interface{}, query PeerGetParams, opts ...option.RequestOption) (res *SecondaryDNSPeer, err error)

Get Peer.

func (*PeerService) List 

func (r *PeerService) List(ctx context.Context, query PeerListParams, opts ...option.RequestOption) (res *[]SecondaryDNSPeer, err error)

List Peers.

func (*PeerService) New 

func (r *PeerService) New(ctx context.Context, params PeerNewParams, opts ...option.RequestOption) (res *SecondaryDNSPeer, err error)

Create Peer.

func (*PeerService) Update 

func (r *PeerService) Update(ctx context.Context, peerID interface{}, params PeerUpdateParams, opts ...option.RequestOption) (res *SecondaryDNSPeer, err error)

Modify Peer.

type PeerUpdateParams 

type PeerUpdateParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
	// The name of the peer.
	Name param.Field[string] `json:"name,required"`
	// IPv4/IPv6 address of primary or secondary nameserver, depending on what zone
	// this peer is linked to. For primary zones this IP defines the IP of the
	// secondary nameserver Cloudflare will NOTIFY upon zone changes. For secondary
	// zones this IP defines the IP of the primary nameserver Cloudflare will send
	// AXFR/IXFR requests to.
	IP param.Field[string] `json:"ip"`
	// Enable IXFR transfer protocol, default is AXFR. Only applicable to secondary
	// zones.
	IxfrEnable param.Field[bool] `json:"ixfr_enable"`
	// DNS port of primary or secondary nameserver, depending on what zone this peer is
	// linked to.
	Port param.Field[float64] `json:"port"`
	// TSIG authentication will be used for zone transfer if configured.
	TSIGID param.Field[string] `json:"tsig_id"`
}

func (PeerUpdateParams) MarshalJSON 

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

type PeerUpdateResponseEnvelope 

type PeerUpdateResponseEnvelope struct {
	Errors   []PeerUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []PeerUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   SecondaryDNSPeer                     `json:"result,required"`
	// Whether the API call was successful
	Success PeerUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    peerUpdateResponseEnvelopeJSON    `json:"-"`
}

func (*PeerUpdateResponseEnvelope) UnmarshalJSON 

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

type PeerUpdateResponseEnvelopeErrors 

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

func (*PeerUpdateResponseEnvelopeErrors) UnmarshalJSON 

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

type PeerUpdateResponseEnvelopeMessages 

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

func (*PeerUpdateResponseEnvelopeMessages) UnmarshalJSON 

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

type PeerUpdateResponseEnvelopeSuccess 

type PeerUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	PeerUpdateResponseEnvelopeSuccessTrue PeerUpdateResponseEnvelopeSuccess = true
)

type SecondaryDNSACL 

type SecondaryDNSACL struct {
	ID interface{} `json:"id,required"`
	// Allowed IPv4/IPv6 address range of primary or secondary nameservers. This will
	// be applied for the entire account. The IP range is used to allow additional
	// NOTIFY IPs for secondary zones and IPs Cloudflare allows AXFR/IXFR requests from
	// for primary zones. CIDRs are limited to a maximum of /24 for IPv4 and /64 for
	// IPv6 respectively.
	IPRange string `json:"ip_range,required"`
	// The name of the acl.
	Name string              `json:"name,required"`
	JSON secondaryDnsaclJSON `json:"-"`
}

func (*SecondaryDNSACL) UnmarshalJSON 

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

type SecondaryDNSDisableTransferResult 

type SecondaryDNSDisableTransferResult = string

type SecondaryDNSEnableTransferResult 

type SecondaryDNSEnableTransferResult = string

type SecondaryDNSForceResult 

type SecondaryDNSForceResult = string

type SecondaryDNSPeer 

type SecondaryDNSPeer struct {
	ID interface{} `json:"id,required"`
	// The name of the peer.
	Name string `json:"name,required"`
	// IPv4/IPv6 address of primary or secondary nameserver, depending on what zone
	// this peer is linked to. For primary zones this IP defines the IP of the
	// secondary nameserver Cloudflare will NOTIFY upon zone changes. For secondary
	// zones this IP defines the IP of the primary nameserver Cloudflare will send
	// AXFR/IXFR requests to.
	IP string `json:"ip"`
	// Enable IXFR transfer protocol, default is AXFR. Only applicable to secondary
	// zones.
	IxfrEnable bool `json:"ixfr_enable"`
	// DNS port of primary or secondary nameserver, depending on what zone this peer is
	// linked to.
	Port float64 `json:"port"`
	// TSIG authentication will be used for zone transfer if configured.
	TSIGID string               `json:"tsig_id"`
	JSON   secondaryDNSPeerJSON `json:"-"`
}

func (*SecondaryDNSPeer) UnmarshalJSON 

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

type SecondaryDNSSchemasForceResult 

type SecondaryDNSSchemasForceResult = string

type SecondaryDNSService 

type SecondaryDNSService struct {
	Options   []option.RequestOption
	ForceAXFR *ForceAXFRService
	Incoming  *IncomingService
	Outgoing  *OutgoingService
	ACLs      *ACLService
	Peers     *PeerService
	TSIGs     *TSIGService
}

SecondaryDNSService 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 NewSecondaryDNSService method instead.

func NewSecondaryDNSService 

func NewSecondaryDNSService(opts ...option.RequestOption) (r *SecondaryDNSService)

NewSecondaryDNSService 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.

type SecondaryDNSTSIG 

type SecondaryDNSTSIG struct {
	ID interface{} `json:"id,required"`
	// TSIG algorithm.
	Algo string `json:"algo,required"`
	// TSIG key name.
	Name string `json:"name,required"`
	// TSIG secret.
	Secret string               `json:"secret,required"`
	JSON   secondaryDnstsigJSON `json:"-"`
}

func (*SecondaryDNSTSIG) UnmarshalJSON 

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

type TSIGDeleteParams 

type TSIGDeleteParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type TSIGDeleteResponse 

type TSIGDeleteResponse struct {
	ID   interface{}            `json:"id"`
	JSON tsigDeleteResponseJSON `json:"-"`
}

func (*TSIGDeleteResponse) UnmarshalJSON 

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

type TSIGDeleteResponseEnvelope 

type TSIGDeleteResponseEnvelope struct {
	Errors   []TSIGDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []TSIGDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   TSIGDeleteResponse                   `json:"result,required"`
	// Whether the API call was successful
	Success TSIGDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    tsigDeleteResponseEnvelopeJSON    `json:"-"`
}

func (*TSIGDeleteResponseEnvelope) UnmarshalJSON 

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

type TSIGDeleteResponseEnvelopeErrors 

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

func (*TSIGDeleteResponseEnvelopeErrors) UnmarshalJSON 

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

type TSIGDeleteResponseEnvelopeMessages 

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

func (*TSIGDeleteResponseEnvelopeMessages) UnmarshalJSON 

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

type TSIGDeleteResponseEnvelopeSuccess 

type TSIGDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	TSIGDeleteResponseEnvelopeSuccessTrue TSIGDeleteResponseEnvelopeSuccess = true
)

type TSIGGetParams 

type TSIGGetParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type TSIGGetResponseEnvelope 

type TSIGGetResponseEnvelope struct {
	Errors   []TSIGGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []TSIGGetResponseEnvelopeMessages `json:"messages,required"`
	Result   SecondaryDNSTSIG                  `json:"result,required"`
	// Whether the API call was successful
	Success TSIGGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    tsigGetResponseEnvelopeJSON    `json:"-"`
}

func (*TSIGGetResponseEnvelope) UnmarshalJSON 

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

type TSIGGetResponseEnvelopeErrors 

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

func (*TSIGGetResponseEnvelopeErrors) UnmarshalJSON 

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

type TSIGGetResponseEnvelopeMessages 

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

func (*TSIGGetResponseEnvelopeMessages) UnmarshalJSON 

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

type TSIGGetResponseEnvelopeSuccess 

type TSIGGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	TSIGGetResponseEnvelopeSuccessTrue TSIGGetResponseEnvelopeSuccess = true
)

type TSIGListParams 

type TSIGListParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
}

type TSIGListResponseEnvelope 

type TSIGListResponseEnvelope struct {
	Errors   []TSIGListResponseEnvelopeErrors   `json:"errors,required"`
	Messages []TSIGListResponseEnvelopeMessages `json:"messages,required"`
	Result   []SecondaryDNSTSIG                 `json:"result,required,nullable"`
	// Whether the API call was successful
	Success    TSIGListResponseEnvelopeSuccess    `json:"success,required"`
	ResultInfo TSIGListResponseEnvelopeResultInfo `json:"result_info"`
	JSON       tsigListResponseEnvelopeJSON       `json:"-"`
}

func (*TSIGListResponseEnvelope) UnmarshalJSON 

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

type TSIGListResponseEnvelopeErrors 

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

func (*TSIGListResponseEnvelopeErrors) UnmarshalJSON 

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

type TSIGListResponseEnvelopeMessages 

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

func (*TSIGListResponseEnvelopeMessages) UnmarshalJSON 

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

type TSIGListResponseEnvelopeResultInfo 

type TSIGListResponseEnvelopeResultInfo 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       tsigListResponseEnvelopeResultInfoJSON `json:"-"`
}

func (*TSIGListResponseEnvelopeResultInfo) UnmarshalJSON 

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

type TSIGListResponseEnvelopeSuccess 

type TSIGListResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	TSIGListResponseEnvelopeSuccessTrue TSIGListResponseEnvelopeSuccess = true
)

type TSIGNewParams 

type TSIGNewParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
	// TSIG algorithm.
	Algo param.Field[string] `json:"algo,required"`
	// TSIG key name.
	Name param.Field[string] `json:"name,required"`
	// TSIG secret.
	Secret param.Field[string] `json:"secret,required"`
}

func (TSIGNewParams) MarshalJSON 

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

type TSIGNewResponseEnvelope 

type TSIGNewResponseEnvelope struct {
	Errors   []TSIGNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []TSIGNewResponseEnvelopeMessages `json:"messages,required"`
	Result   SecondaryDNSTSIG                  `json:"result,required"`
	// Whether the API call was successful
	Success TSIGNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    tsigNewResponseEnvelopeJSON    `json:"-"`
}

func (*TSIGNewResponseEnvelope) UnmarshalJSON 

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

type TSIGNewResponseEnvelopeErrors 

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

func (*TSIGNewResponseEnvelopeErrors) UnmarshalJSON 

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

type TSIGNewResponseEnvelopeMessages 

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

func (*TSIGNewResponseEnvelopeMessages) UnmarshalJSON 

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

type TSIGNewResponseEnvelopeSuccess 

type TSIGNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	TSIGNewResponseEnvelopeSuccessTrue TSIGNewResponseEnvelopeSuccess = true
)

type TSIGService 

type TSIGService struct {
	Options []option.RequestOption
}

TSIGService 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 NewTSIGService method instead.

func NewTSIGService 

func NewTSIGService(opts ...option.RequestOption) (r *TSIGService)

NewTSIGService 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 (*TSIGService) Delete 

func (r *TSIGService) Delete(ctx context.Context, tsigID interface{}, body TSIGDeleteParams, opts ...option.RequestOption) (res *TSIGDeleteResponse, err error)

Delete TSIG.

func (*TSIGService) Get 

func (r *TSIGService) Get(ctx context.Context, tsigID interface{}, query TSIGGetParams, opts ...option.RequestOption) (res *SecondaryDNSTSIG, err error)

Get TSIG.

func (*TSIGService) List 

func (r *TSIGService) List(ctx context.Context, query TSIGListParams, opts ...option.RequestOption) (res *[]SecondaryDNSTSIG, err error)

List TSIGs.

func (*TSIGService) New 

func (r *TSIGService) New(ctx context.Context, params TSIGNewParams, opts ...option.RequestOption) (res *SecondaryDNSTSIG, err error)

Create TSIG.

func (*TSIGService) Update 

func (r *TSIGService) Update(ctx context.Context, tsigID interface{}, params TSIGUpdateParams, opts ...option.RequestOption) (res *SecondaryDNSTSIG, err error)

Modify TSIG.

type TSIGUpdateParams 

type TSIGUpdateParams struct {
	AccountID param.Field[interface{}] `path:"account_id,required"`
	// TSIG algorithm.
	Algo param.Field[string] `json:"algo,required"`
	// TSIG key name.
	Name param.Field[string] `json:"name,required"`
	// TSIG secret.
	Secret param.Field[string] `json:"secret,required"`
}

func (TSIGUpdateParams) MarshalJSON 

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

type TSIGUpdateResponseEnvelope 

type TSIGUpdateResponseEnvelope struct {
	Errors   []TSIGUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []TSIGUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   SecondaryDNSTSIG                     `json:"result,required"`
	// Whether the API call was successful
	Success TSIGUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    tsigUpdateResponseEnvelopeJSON    `json:"-"`
}

func (*TSIGUpdateResponseEnvelope) UnmarshalJSON 

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

type TSIGUpdateResponseEnvelopeErrors 

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

func (*TSIGUpdateResponseEnvelopeErrors) UnmarshalJSON 

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

type TSIGUpdateResponseEnvelopeMessages 

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

func (*TSIGUpdateResponseEnvelopeMessages) UnmarshalJSON 

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

type TSIGUpdateResponseEnvelopeSuccess 

type TSIGUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	TSIGUpdateResponseEnvelopeSuccessTrue TSIGUpdateResponseEnvelopeSuccess = true
)

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.