web3

package
v2.0.0-beta.17 Latest Latest
Warning

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

 Go to latest Published: Apr 2, 2024 License: Apache-2.0 Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type DistributedWebConfigContentList 

type DistributedWebConfigContentList struct {
	// Behavior of the content list.
	Action DistributedWebConfigContentListAction `json:"action"`
	JSON   distributedWebConfigContentListJSON   `json:"-"`
}

func (*DistributedWebConfigContentList) UnmarshalJSON 

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

type DistributedWebConfigContentListAction 

type DistributedWebConfigContentListAction string

Behavior of the content list. 

const (
	DistributedWebConfigContentListActionBlock DistributedWebConfigContentListAction = "block"
)

func (DistributedWebConfigContentListAction) IsKnown 

func (r DistributedWebConfigContentListAction) IsKnown() bool

type DistributedWebConfigContentListEntry 

type DistributedWebConfigContentListEntry struct {
	// Identifier
	ID string `json:"id"`
	// CID or content path of content to block.
	Content   string    `json:"content"`
	CreatedOn time.Time `json:"created_on" format:"date-time"`
	// An optional description of the content list entry.
	Description string    `json:"description"`
	ModifiedOn  time.Time `json:"modified_on" format:"date-time"`
	// Type of content list entry to block.
	Type DistributedWebConfigContentListEntryType `json:"type"`
	JSON distributedWebConfigContentListEntryJSON `json:"-"`
}

Content list entry to be blocked.

func (*DistributedWebConfigContentListEntry) UnmarshalJSON 

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

type DistributedWebConfigContentListEntryParam 

type DistributedWebConfigContentListEntryParam struct {
	// CID or content path of content to block.
	Content param.Field[string] `json:"content"`
	// An optional description of the content list entry.
	Description param.Field[string] `json:"description"`
	// Type of content list entry to block.
	Type param.Field[DistributedWebConfigContentListEntryType] `json:"type"`
}

Content list entry to be blocked.

func (DistributedWebConfigContentListEntryParam) MarshalJSON 

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

type DistributedWebConfigContentListEntryType 

type DistributedWebConfigContentListEntryType string

Type of content list entry to block. 

const (
	DistributedWebConfigContentListEntryTypeCid         DistributedWebConfigContentListEntryType = "cid"
	DistributedWebConfigContentListEntryTypeContentPath DistributedWebConfigContentListEntryType = "content_path"
)

func (DistributedWebConfigContentListEntryType) IsKnown 

func (r DistributedWebConfigContentListEntryType) IsKnown() bool

type DistributedWebHostname 

type DistributedWebHostname struct {
	// Identifier
	ID        string    `json:"id"`
	CreatedOn time.Time `json:"created_on" format:"date-time"`
	// An optional description of the hostname.
	Description string `json:"description"`
	// DNSLink value used if the target is ipfs.
	Dnslink    string    `json:"dnslink"`
	ModifiedOn time.Time `json:"modified_on" format:"date-time"`
	// The hostname that will point to the target gateway via CNAME.
	Name string `json:"name"`
	// Status of the hostname's activation.
	Status DistributedWebHostnameStatus `json:"status"`
	// Target gateway of the hostname.
	Target DistributedWebHostnameTarget `json:"target"`
	JSON   distributedWebHostnameJSON   `json:"-"`
}

func (*DistributedWebHostname) UnmarshalJSON 

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

type DistributedWebHostnameStatus 

type DistributedWebHostnameStatus string

Status of the hostname's activation. 

const (
	DistributedWebHostnameStatusActive   DistributedWebHostnameStatus = "active"
	DistributedWebHostnameStatusPending  DistributedWebHostnameStatus = "pending"
	DistributedWebHostnameStatusDeleting DistributedWebHostnameStatus = "deleting"
	DistributedWebHostnameStatusError    DistributedWebHostnameStatus = "error"
)

func (DistributedWebHostnameStatus) IsKnown 

func (r DistributedWebHostnameStatus) IsKnown() bool

type DistributedWebHostnameTarget 

type DistributedWebHostnameTarget string

Target gateway of the hostname. 

const (
	DistributedWebHostnameTargetEthereum          DistributedWebHostnameTarget = "ethereum"
	DistributedWebHostnameTargetIPFS              DistributedWebHostnameTarget = "ipfs"
	DistributedWebHostnameTargetIPFSUniversalPath DistributedWebHostnameTarget = "ipfs_universal_path"
)

func (DistributedWebHostnameTarget) IsKnown 

func (r DistributedWebHostnameTarget) IsKnown() bool

type Error 

type Error = apierror.Error

type ErrorData 

type ErrorData = shared.ErrorData

This is an alias to an internal type.

type HostnameDeleteResponse 

type HostnameDeleteResponse struct {
	// Identifier
	ID   string                     `json:"id,required"`
	JSON hostnameDeleteResponseJSON `json:"-"`
}

func (*HostnameDeleteResponse) UnmarshalJSON 

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

type HostnameDeleteResponseEnvelope 

type HostnameDeleteResponseEnvelope struct {
	Errors   []HostnameDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []HostnameDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   HostnameDeleteResponse                   `json:"result,required,nullable"`
	// Whether the API call was successful
	Success HostnameDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    hostnameDeleteResponseEnvelopeJSON    `json:"-"`
}

func (*HostnameDeleteResponseEnvelope) UnmarshalJSON 

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

type HostnameDeleteResponseEnvelopeErrors 

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

func (*HostnameDeleteResponseEnvelopeErrors) UnmarshalJSON 

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

type HostnameDeleteResponseEnvelopeMessages 

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

func (*HostnameDeleteResponseEnvelopeMessages) UnmarshalJSON 

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

type HostnameDeleteResponseEnvelopeSuccess 

type HostnameDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	HostnameDeleteResponseEnvelopeSuccessTrue HostnameDeleteResponseEnvelopeSuccess = true
)

func (HostnameDeleteResponseEnvelopeSuccess) IsKnown 

func (r HostnameDeleteResponseEnvelopeSuccess) IsKnown() bool

type HostnameEditParams 

type HostnameEditParams struct {
	// An optional description of the hostname.
	Description param.Field[string] `json:"description"`
	// DNSLink value used if the target is ipfs.
	Dnslink param.Field[string] `json:"dnslink"`
}

func (HostnameEditParams) MarshalJSON 

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

type HostnameEditResponseEnvelope 

type HostnameEditResponseEnvelope struct {
	Errors   []HostnameEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []HostnameEditResponseEnvelopeMessages `json:"messages,required"`
	Result   DistributedWebHostname                 `json:"result,required"`
	// Whether the API call was successful
	Success HostnameEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    hostnameEditResponseEnvelopeJSON    `json:"-"`
}

func (*HostnameEditResponseEnvelope) UnmarshalJSON 

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

type HostnameEditResponseEnvelopeErrors 

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

func (*HostnameEditResponseEnvelopeErrors) UnmarshalJSON 

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

type HostnameEditResponseEnvelopeMessages 

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

func (*HostnameEditResponseEnvelopeMessages) UnmarshalJSON 

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

type HostnameEditResponseEnvelopeSuccess 

type HostnameEditResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	HostnameEditResponseEnvelopeSuccessTrue HostnameEditResponseEnvelopeSuccess = true
)

func (HostnameEditResponseEnvelopeSuccess) IsKnown 

func (r HostnameEditResponseEnvelopeSuccess) IsKnown() bool

type HostnameGetResponseEnvelope 

type HostnameGetResponseEnvelope struct {
	Errors   []HostnameGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []HostnameGetResponseEnvelopeMessages `json:"messages,required"`
	Result   DistributedWebHostname                `json:"result,required"`
	// Whether the API call was successful
	Success HostnameGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    hostnameGetResponseEnvelopeJSON    `json:"-"`
}

func (*HostnameGetResponseEnvelope) UnmarshalJSON 

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

type HostnameGetResponseEnvelopeErrors 

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

func (*HostnameGetResponseEnvelopeErrors) UnmarshalJSON 

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

type HostnameGetResponseEnvelopeMessages 

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

func (*HostnameGetResponseEnvelopeMessages) UnmarshalJSON 

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

type HostnameGetResponseEnvelopeSuccess 

type HostnameGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	HostnameGetResponseEnvelopeSuccessTrue HostnameGetResponseEnvelopeSuccess = true
)

func (HostnameGetResponseEnvelopeSuccess) IsKnown 

func (r HostnameGetResponseEnvelopeSuccess) IsKnown() bool

type HostnameIPFSUniversalPathContentListEntryDeleteResponse 

type HostnameIPFSUniversalPathContentListEntryDeleteResponse struct {
	// Identifier
	ID   string                                                      `json:"id,required"`
	JSON hostnameIPFSUniversalPathContentListEntryDeleteResponseJSON `json:"-"`
}

func (*HostnameIPFSUniversalPathContentListEntryDeleteResponse) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelope 

type HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelope struct {
	Errors   []HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeMessages `json:"messages,required"`
	Result   HostnameIPFSUniversalPathContentListEntryDeleteResponse                   `json:"result,required,nullable"`
	// Whether the API call was successful
	Success HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    hostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeJSON    `json:"-"`
}

func (*HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelope) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeErrors 

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

func (*HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeErrors) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeMessages 

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

func (*HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeMessages) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeSuccess 

type HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeSuccessTrue HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeSuccess = true
)

func (HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeSuccess) IsKnown 

func (r HostnameIPFSUniversalPathContentListEntryDeleteResponseEnvelopeSuccess) IsKnown() bool

type HostnameIPFSUniversalPathContentListEntryGetResponseEnvelope 

type HostnameIPFSUniversalPathContentListEntryGetResponseEnvelope struct {
	Errors   []HostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []HostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeMessages `json:"messages,required"`
	// Content list entry to be blocked.
	Result DistributedWebConfigContentListEntry `json:"result,required"`
	// Whether the API call was successful
	Success HostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    hostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeJSON    `json:"-"`
}

func (*HostnameIPFSUniversalPathContentListEntryGetResponseEnvelope) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeErrors 

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

func (*HostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeErrors) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeMessages 

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

func (*HostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeMessages) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeSuccess 

type HostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	HostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeSuccessTrue HostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeSuccess = true
)

func (HostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeSuccess) IsKnown 

func (r HostnameIPFSUniversalPathContentListEntryGetResponseEnvelopeSuccess) IsKnown() bool

type HostnameIPFSUniversalPathContentListEntryListResponse 

type HostnameIPFSUniversalPathContentListEntryListResponse struct {
	// Content list entries.
	Entries []DistributedWebConfigContentListEntry                    `json:"entries"`
	JSON    hostnameIPFSUniversalPathContentListEntryListResponseJSON `json:"-"`
}

func (*HostnameIPFSUniversalPathContentListEntryListResponse) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryListResponseEnvelope 

type HostnameIPFSUniversalPathContentListEntryListResponseEnvelope struct {
	Errors   []HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeErrors   `json:"errors,required"`
	Messages []HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeMessages `json:"messages,required"`
	Result   HostnameIPFSUniversalPathContentListEntryListResponse                   `json:"result,required,nullable"`
	// Whether the API call was successful
	Success    HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeSuccess    `json:"success,required"`
	ResultInfo HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeResultInfo `json:"result_info"`
	JSON       hostnameIPFSUniversalPathContentListEntryListResponseEnvelopeJSON       `json:"-"`
}

func (*HostnameIPFSUniversalPathContentListEntryListResponseEnvelope) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeErrors 

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

func (*HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeErrors) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeMessages 

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

func (*HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeMessages) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeResultInfo 

type HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeResultInfo 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       hostnameIPFSUniversalPathContentListEntryListResponseEnvelopeResultInfoJSON `json:"-"`
}

func (*HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeResultInfo) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeSuccess 

type HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeSuccessTrue HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeSuccess = true
)

func (HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeSuccess) IsKnown 

func (r HostnameIPFSUniversalPathContentListEntryListResponseEnvelopeSuccess) IsKnown() bool

type HostnameIPFSUniversalPathContentListEntryNewParams 

type HostnameIPFSUniversalPathContentListEntryNewParams struct {
	// CID or content path of content to block.
	Content param.Field[string] `json:"content,required"`
	// Type of content list entry to block.
	Type param.Field[HostnameIPFSUniversalPathContentListEntryNewParamsType] `json:"type,required"`
	// An optional description of the content list entry.
	Description param.Field[string] `json:"description"`
}

func (HostnameIPFSUniversalPathContentListEntryNewParams) MarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryNewParamsType 

type HostnameIPFSUniversalPathContentListEntryNewParamsType string

Type of content list entry to block. 

const (
	HostnameIPFSUniversalPathContentListEntryNewParamsTypeCid         HostnameIPFSUniversalPathContentListEntryNewParamsType = "cid"
	HostnameIPFSUniversalPathContentListEntryNewParamsTypeContentPath HostnameIPFSUniversalPathContentListEntryNewParamsType = "content_path"
)

func (HostnameIPFSUniversalPathContentListEntryNewParamsType) IsKnown 

func (r HostnameIPFSUniversalPathContentListEntryNewParamsType) IsKnown() bool

type HostnameIPFSUniversalPathContentListEntryNewResponseEnvelope 

type HostnameIPFSUniversalPathContentListEntryNewResponseEnvelope struct {
	Errors   []HostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []HostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeMessages `json:"messages,required"`
	// Content list entry to be blocked.
	Result DistributedWebConfigContentListEntry `json:"result,required"`
	// Whether the API call was successful
	Success HostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    hostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeJSON    `json:"-"`
}

func (*HostnameIPFSUniversalPathContentListEntryNewResponseEnvelope) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeErrors 

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

func (*HostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeErrors) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeMessages 

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

func (*HostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeMessages) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeSuccess 

type HostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	HostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeSuccessTrue HostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeSuccess = true
)

func (HostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeSuccess) IsKnown 

func (r HostnameIPFSUniversalPathContentListEntryNewResponseEnvelopeSuccess) IsKnown() bool

type HostnameIPFSUniversalPathContentListEntryService 

type HostnameIPFSUniversalPathContentListEntryService struct {
	Options []option.RequestOption
}

HostnameIPFSUniversalPathContentListEntryService 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 NewHostnameIPFSUniversalPathContentListEntryService method instead.

func NewHostnameIPFSUniversalPathContentListEntryService 

func NewHostnameIPFSUniversalPathContentListEntryService(opts ...option.RequestOption) (r *HostnameIPFSUniversalPathContentListEntryService)

NewHostnameIPFSUniversalPathContentListEntryService 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 (*HostnameIPFSUniversalPathContentListEntryService) Delete 

func (r *HostnameIPFSUniversalPathContentListEntryService) Delete(ctx context.Context, zoneIdentifier string, identifier string, contentListEntryIdentifier string, opts ...option.RequestOption) (res *HostnameIPFSUniversalPathContentListEntryDeleteResponse, err error)

Delete IPFS Universal Path Gateway Content List Entry

func (*HostnameIPFSUniversalPathContentListEntryService) Get 

func (r *HostnameIPFSUniversalPathContentListEntryService) Get(ctx context.Context, zoneIdentifier string, identifier string, contentListEntryIdentifier string, opts ...option.RequestOption) (res *DistributedWebConfigContentListEntry, err error)

IPFS Universal Path Gateway Content List Entry Details

func (*HostnameIPFSUniversalPathContentListEntryService) List 

func (r *HostnameIPFSUniversalPathContentListEntryService) List(ctx context.Context, zoneIdentifier string, identifier string, opts ...option.RequestOption) (res *HostnameIPFSUniversalPathContentListEntryListResponse, err error)

List IPFS Universal Path Gateway Content List Entries

func (*HostnameIPFSUniversalPathContentListEntryService) New 

func (r *HostnameIPFSUniversalPathContentListEntryService) New(ctx context.Context, zoneIdentifier string, identifier string, body HostnameIPFSUniversalPathContentListEntryNewParams, opts ...option.RequestOption) (res *DistributedWebConfigContentListEntry, err error)

Create IPFS Universal Path Gateway Content List Entry

func (*HostnameIPFSUniversalPathContentListEntryService) Update 

func (r *HostnameIPFSUniversalPathContentListEntryService) Update(ctx context.Context, zoneIdentifier string, identifier string, contentListEntryIdentifier string, body HostnameIPFSUniversalPathContentListEntryUpdateParams, opts ...option.RequestOption) (res *DistributedWebConfigContentListEntry, err error)

Edit IPFS Universal Path Gateway Content List Entry

type HostnameIPFSUniversalPathContentListEntryUpdateParams 

type HostnameIPFSUniversalPathContentListEntryUpdateParams struct {
	// CID or content path of content to block.
	Content param.Field[string] `json:"content,required"`
	// Type of content list entry to block.
	Type param.Field[HostnameIPFSUniversalPathContentListEntryUpdateParamsType] `json:"type,required"`
	// An optional description of the content list entry.
	Description param.Field[string] `json:"description"`
}

func (HostnameIPFSUniversalPathContentListEntryUpdateParams) MarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryUpdateParamsType 

type HostnameIPFSUniversalPathContentListEntryUpdateParamsType string

Type of content list entry to block. 

const (
	HostnameIPFSUniversalPathContentListEntryUpdateParamsTypeCid         HostnameIPFSUniversalPathContentListEntryUpdateParamsType = "cid"
	HostnameIPFSUniversalPathContentListEntryUpdateParamsTypeContentPath HostnameIPFSUniversalPathContentListEntryUpdateParamsType = "content_path"
)

func (HostnameIPFSUniversalPathContentListEntryUpdateParamsType) IsKnown 

func (r HostnameIPFSUniversalPathContentListEntryUpdateParamsType) IsKnown() bool

type HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelope 

type HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelope struct {
	Errors   []HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeMessages `json:"messages,required"`
	// Content list entry to be blocked.
	Result DistributedWebConfigContentListEntry `json:"result,required"`
	// Whether the API call was successful
	Success HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    hostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeJSON    `json:"-"`
}

func (*HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelope) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeErrors 

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

func (*HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeErrors) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeMessages 

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

func (*HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeMessages) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeSuccess 

type HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeSuccessTrue HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeSuccess = true
)

func (HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeSuccess) IsKnown 

func (r HostnameIPFSUniversalPathContentListEntryUpdateResponseEnvelopeSuccess) IsKnown() bool

type HostnameIPFSUniversalPathContentListGetResponseEnvelope 

type HostnameIPFSUniversalPathContentListGetResponseEnvelope struct {
	Errors   []HostnameIPFSUniversalPathContentListGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []HostnameIPFSUniversalPathContentListGetResponseEnvelopeMessages `json:"messages,required"`
	Result   DistributedWebConfigContentList                                   `json:"result,required"`
	// Whether the API call was successful
	Success HostnameIPFSUniversalPathContentListGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    hostnameIPFSUniversalPathContentListGetResponseEnvelopeJSON    `json:"-"`
}

func (*HostnameIPFSUniversalPathContentListGetResponseEnvelope) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListGetResponseEnvelopeErrors 

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

func (*HostnameIPFSUniversalPathContentListGetResponseEnvelopeErrors) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListGetResponseEnvelopeMessages 

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

func (*HostnameIPFSUniversalPathContentListGetResponseEnvelopeMessages) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListGetResponseEnvelopeSuccess 

type HostnameIPFSUniversalPathContentListGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	HostnameIPFSUniversalPathContentListGetResponseEnvelopeSuccessTrue HostnameIPFSUniversalPathContentListGetResponseEnvelopeSuccess = true
)

func (HostnameIPFSUniversalPathContentListGetResponseEnvelopeSuccess) IsKnown 

func (r HostnameIPFSUniversalPathContentListGetResponseEnvelopeSuccess) IsKnown() bool

type HostnameIPFSUniversalPathContentListService 

type HostnameIPFSUniversalPathContentListService struct {
	Options []option.RequestOption
	Entries *HostnameIPFSUniversalPathContentListEntryService
}

HostnameIPFSUniversalPathContentListService 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 NewHostnameIPFSUniversalPathContentListService method instead.

func NewHostnameIPFSUniversalPathContentListService 

func NewHostnameIPFSUniversalPathContentListService(opts ...option.RequestOption) (r *HostnameIPFSUniversalPathContentListService)

NewHostnameIPFSUniversalPathContentListService 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 (*HostnameIPFSUniversalPathContentListService) Get 

func (r *HostnameIPFSUniversalPathContentListService) Get(ctx context.Context, zoneIdentifier string, identifier string, opts ...option.RequestOption) (res *DistributedWebConfigContentList, err error)

IPFS Universal Path Gateway Content List Details

func (*HostnameIPFSUniversalPathContentListService) Update 

func (r *HostnameIPFSUniversalPathContentListService) Update(ctx context.Context, zoneIdentifier string, identifier string, body HostnameIPFSUniversalPathContentListUpdateParams, opts ...option.RequestOption) (res *DistributedWebConfigContentList, err error)

Update IPFS Universal Path Gateway Content List

type HostnameIPFSUniversalPathContentListUpdateParams 

type HostnameIPFSUniversalPathContentListUpdateParams struct {
	// Behavior of the content list.
	Action param.Field[HostnameIPFSUniversalPathContentListUpdateParamsAction] `json:"action,required"`
	// Content list entries.
	Entries param.Field[[]DistributedWebConfigContentListEntryParam] `json:"entries,required"`
}

func (HostnameIPFSUniversalPathContentListUpdateParams) MarshalJSON 

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

type HostnameIPFSUniversalPathContentListUpdateParamsAction 

type HostnameIPFSUniversalPathContentListUpdateParamsAction string

Behavior of the content list. 

const (
	HostnameIPFSUniversalPathContentListUpdateParamsActionBlock HostnameIPFSUniversalPathContentListUpdateParamsAction = "block"
)

func (HostnameIPFSUniversalPathContentListUpdateParamsAction) IsKnown 

func (r HostnameIPFSUniversalPathContentListUpdateParamsAction) IsKnown() bool

type HostnameIPFSUniversalPathContentListUpdateResponseEnvelope 

type HostnameIPFSUniversalPathContentListUpdateResponseEnvelope struct {
	Errors   []HostnameIPFSUniversalPathContentListUpdateResponseEnvelopeErrors   `json:"errors,required"`
	Messages []HostnameIPFSUniversalPathContentListUpdateResponseEnvelopeMessages `json:"messages,required"`
	Result   DistributedWebConfigContentList                                      `json:"result,required"`
	// Whether the API call was successful
	Success HostnameIPFSUniversalPathContentListUpdateResponseEnvelopeSuccess `json:"success,required"`
	JSON    hostnameIPFSUniversalPathContentListUpdateResponseEnvelopeJSON    `json:"-"`
}

func (*HostnameIPFSUniversalPathContentListUpdateResponseEnvelope) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListUpdateResponseEnvelopeErrors 

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

func (*HostnameIPFSUniversalPathContentListUpdateResponseEnvelopeErrors) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListUpdateResponseEnvelopeMessages 

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

func (*HostnameIPFSUniversalPathContentListUpdateResponseEnvelopeMessages) UnmarshalJSON 

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

type HostnameIPFSUniversalPathContentListUpdateResponseEnvelopeSuccess 

type HostnameIPFSUniversalPathContentListUpdateResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	HostnameIPFSUniversalPathContentListUpdateResponseEnvelopeSuccessTrue HostnameIPFSUniversalPathContentListUpdateResponseEnvelopeSuccess = true
)

func (HostnameIPFSUniversalPathContentListUpdateResponseEnvelopeSuccess) IsKnown 

func (r HostnameIPFSUniversalPathContentListUpdateResponseEnvelopeSuccess) IsKnown() bool

type HostnameIPFSUniversalPathService 

type HostnameIPFSUniversalPathService struct {
	Options      []option.RequestOption
	ContentLists *HostnameIPFSUniversalPathContentListService
}

HostnameIPFSUniversalPathService 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 NewHostnameIPFSUniversalPathService method instead.

func NewHostnameIPFSUniversalPathService 

func NewHostnameIPFSUniversalPathService(opts ...option.RequestOption) (r *HostnameIPFSUniversalPathService)

NewHostnameIPFSUniversalPathService 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 HostnameNewParams 

type HostnameNewParams struct {
	// Target gateway of the hostname.
	Target param.Field[HostnameNewParamsTarget] `json:"target,required"`
	// An optional description of the hostname.
	Description param.Field[string] `json:"description"`
	// DNSLink value used if the target is ipfs.
	Dnslink param.Field[string] `json:"dnslink"`
}

func (HostnameNewParams) MarshalJSON 

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

type HostnameNewParamsTarget 

type HostnameNewParamsTarget string

Target gateway of the hostname. 

const (
	HostnameNewParamsTargetEthereum          HostnameNewParamsTarget = "ethereum"
	HostnameNewParamsTargetIPFS              HostnameNewParamsTarget = "ipfs"
	HostnameNewParamsTargetIPFSUniversalPath HostnameNewParamsTarget = "ipfs_universal_path"
)

func (HostnameNewParamsTarget) IsKnown 

func (r HostnameNewParamsTarget) IsKnown() bool

type HostnameNewResponseEnvelope 

type HostnameNewResponseEnvelope struct {
	Errors   []HostnameNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []HostnameNewResponseEnvelopeMessages `json:"messages,required"`
	Result   DistributedWebHostname                `json:"result,required"`
	// Whether the API call was successful
	Success HostnameNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    hostnameNewResponseEnvelopeJSON    `json:"-"`
}

func (*HostnameNewResponseEnvelope) UnmarshalJSON 

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

type HostnameNewResponseEnvelopeErrors 

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

func (*HostnameNewResponseEnvelopeErrors) UnmarshalJSON 

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

type HostnameNewResponseEnvelopeMessages 

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

func (*HostnameNewResponseEnvelopeMessages) UnmarshalJSON 

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

type HostnameNewResponseEnvelopeSuccess 

type HostnameNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	HostnameNewResponseEnvelopeSuccessTrue HostnameNewResponseEnvelopeSuccess = true
)

func (HostnameNewResponseEnvelopeSuccess) IsKnown 

func (r HostnameNewResponseEnvelopeSuccess) IsKnown() bool

type HostnameService 

type HostnameService struct {
	Options            []option.RequestOption
	IPFSUniversalPaths *HostnameIPFSUniversalPathService
}

HostnameService 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 NewHostnameService method instead.

func NewHostnameService 

func NewHostnameService(opts ...option.RequestOption) (r *HostnameService)

NewHostnameService 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 (*HostnameService) Delete 

func (r *HostnameService) Delete(ctx context.Context, zoneIdentifier string, identifier string, opts ...option.RequestOption) (res *HostnameDeleteResponse, err error)

Delete Web3 Hostname

func (*HostnameService) Edit 

func (r *HostnameService) Edit(ctx context.Context, zoneIdentifier string, identifier string, body HostnameEditParams, opts ...option.RequestOption) (res *DistributedWebHostname, err error)

Edit Web3 Hostname

func (*HostnameService) Get 

func (r *HostnameService) Get(ctx context.Context, zoneIdentifier string, identifier string, opts ...option.RequestOption) (res *DistributedWebHostname, err error)

Web3 Hostname Details

func (*HostnameService) List 

func (r *HostnameService) List(ctx context.Context, zoneIdentifier string, opts ...option.RequestOption) (res *pagination.SinglePage[DistributedWebHostname], err error)

List Web3 Hostnames

func (*HostnameService) ListAutoPaging 

func (r *HostnameService) ListAutoPaging(ctx context.Context, zoneIdentifier string, opts ...option.RequestOption) *pagination.SinglePageAutoPager[DistributedWebHostname]

List Web3 Hostnames

func (*HostnameService) New 

func (r *HostnameService) New(ctx context.Context, zoneIdentifier string, body HostnameNewParams, opts ...option.RequestOption) (res *DistributedWebHostname, err error)

Create Web3 Hostname

type Web3Service 

type Web3Service struct {
	Options   []option.RequestOption
	Hostnames *HostnameService
}

Web3Service 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 NewWeb3Service method instead.

func NewWeb3Service 

func NewWeb3Service(opts ...option.RequestOption) (r *Web3Service)

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

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.