speed

package
v2.0.0 Latest Latest
Warning

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

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

Documentation

Index

Constants

View Source 
const AuditLogActorTypeAdmin = shared.AuditLogActorTypeAdmin

This is an alias to an internal value.

View Source 
const AuditLogActorTypeCloudflare = shared.AuditLogActorTypeCloudflare

This is an alias to an internal value.

View Source 
const AuditLogActorTypeUser = shared.AuditLogActorTypeUser

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeCNI = shared.CloudflareTunnelTunTypeCNI

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeCfdTunnel = shared.CloudflareTunnelTunTypeCfdTunnel

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeGRE = shared.CloudflareTunnelTunTypeGRE

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeIPSec = shared.CloudflareTunnelTunTypeIPSec

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeWARPConnector = shared.CloudflareTunnelTunTypeWARPConnector

This is an alias to an internal value.

Variables

This section is empty.

Functions

This section is empty.

Types

type AuditLog 

type AuditLog = shared.AuditLog

This is an alias to an internal type.

type AuditLogAction 

type AuditLogAction = shared.AuditLogAction

This is an alias to an internal type.

type AuditLogActor 

type AuditLogActor = shared.AuditLogActor

This is an alias to an internal type.

type AuditLogActorType 

type AuditLogActorType = shared.AuditLogActorType

The type of actor, whether a User, Cloudflare Admin, or an Automated System.

This is an alias to an internal type.

type AuditLogOwner 

type AuditLogOwner = shared.AuditLogOwner

This is an alias to an internal type.

type AuditLogResource 

type AuditLogResource = shared.AuditLogResource

This is an alias to an internal type.

type Availability 

type Availability struct {
	Quota          AvailabilityQuota `json:"quota"`
	Regions        []LabeledRegion   `json:"regions"`
	RegionsPerPlan interface{}       `json:"regionsPerPlan"`
	JSON           availabilityJSON  `json:"-"`
}

func (*Availability) UnmarshalJSON 

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

type AvailabilityListParams 

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

type AvailabilityListResponseEnvelope 

type AvailabilityListResponseEnvelope struct {
	Errors   interface{}                          `json:"errors,required"`
	Messages interface{}                          `json:"messages,required"`
	Success  interface{}                          `json:"success,required"`
	Result   Availability                         `json:"result"`
	JSON     availabilityListResponseEnvelopeJSON `json:"-"`
}

func (*AvailabilityListResponseEnvelope) UnmarshalJSON 

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

type AvailabilityQuota 

type AvailabilityQuota struct {
	// Cloudflare plan.
	Plan string `json:"plan"`
	// The number of tests available per plan.
	QuotasPerPlan map[string]float64 `json:"quotasPerPlan"`
	// The number of remaining schedules available.
	RemainingSchedules float64 `json:"remainingSchedules"`
	// The number of remaining tests available.
	RemainingTests float64 `json:"remainingTests"`
	// The number of schedules available per plan.
	ScheduleQuotasPerPlan map[string]float64    `json:"scheduleQuotasPerPlan"`
	JSON                  availabilityQuotaJSON `json:"-"`
}

func (*AvailabilityQuota) UnmarshalJSON 

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

type AvailabilityService 

type AvailabilityService struct {
	Options []option.RequestOption
}

AvailabilityService 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 NewAvailabilityService method instead.

func NewAvailabilityService 

func NewAvailabilityService(opts ...option.RequestOption) (r *AvailabilityService)

NewAvailabilityService 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 (*AvailabilityService) List 

func (r *AvailabilityService) List(ctx context.Context, query AvailabilityListParams, opts ...option.RequestOption) (res *Availability, err error)

Retrieves quota for all plans, as well as the current zone quota.

type CloudflareTunnel 

type CloudflareTunnel = shared.CloudflareTunnel

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

This is an alias to an internal type.

type CloudflareTunnelConnection 

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

This is an alias to an internal type.

type CloudflareTunnelTunType 

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

The type of tunnel.

This is an alias to an internal type.

type Error 

type Error = apierror.Error

type ErrorData 

type ErrorData = shared.ErrorData

This is an alias to an internal type.

type LabeledRegion 

type LabeledRegion struct {
	Label string `json:"label"`
	// A test region.
	Value LabeledRegionValue `json:"value"`
	JSON  labeledRegionJSON  `json:"-"`
}

A test region with a label.

func (*LabeledRegion) UnmarshalJSON 

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

type LabeledRegionValue 

type LabeledRegionValue string

A test region. 

const (
	LabeledRegionValueAsiaEast1           LabeledRegionValue = "asia-east1"
	LabeledRegionValueAsiaNortheast1      LabeledRegionValue = "asia-northeast1"
	LabeledRegionValueAsiaNortheast2      LabeledRegionValue = "asia-northeast2"
	LabeledRegionValueAsiaSouth1          LabeledRegionValue = "asia-south1"
	LabeledRegionValueAsiaSoutheast1      LabeledRegionValue = "asia-southeast1"
	LabeledRegionValueAustraliaSoutheast1 LabeledRegionValue = "australia-southeast1"
	LabeledRegionValueEuropeNorth1        LabeledRegionValue = "europe-north1"
	LabeledRegionValueEuropeSouthwest1    LabeledRegionValue = "europe-southwest1"
	LabeledRegionValueEuropeWest1         LabeledRegionValue = "europe-west1"
	LabeledRegionValueEuropeWest2         LabeledRegionValue = "europe-west2"
	LabeledRegionValueEuropeWest3         LabeledRegionValue = "europe-west3"
	LabeledRegionValueEuropeWest4         LabeledRegionValue = "europe-west4"
	LabeledRegionValueEuropeWest8         LabeledRegionValue = "europe-west8"
	LabeledRegionValueEuropeWest9         LabeledRegionValue = "europe-west9"
	LabeledRegionValueMeWest1             LabeledRegionValue = "me-west1"
	LabeledRegionValueSouthamericaEast1   LabeledRegionValue = "southamerica-east1"
	LabeledRegionValueUsCentral1          LabeledRegionValue = "us-central1"
	LabeledRegionValueUsEast1             LabeledRegionValue = "us-east1"
	LabeledRegionValueUsEast4             LabeledRegionValue = "us-east4"
	LabeledRegionValueUsSouth1            LabeledRegionValue = "us-south1"
	LabeledRegionValueUsWest1             LabeledRegionValue = "us-west1"
)

func (LabeledRegionValue) IsKnown 

func (r LabeledRegionValue) IsKnown() bool

type LighthouseReport 

type LighthouseReport struct {
	// Cumulative Layout Shift.
	Cls float64 `json:"cls"`
	// The type of device.
	DeviceType LighthouseReportDeviceType `json:"deviceType"`
	Error      LighthouseReportError      `json:"error"`
	// First Contentful Paint.
	Fcp float64 `json:"fcp"`
	// The URL to the full Lighthouse JSON report.
	JsonReportURL string `json:"jsonReportUrl"`
	// Largest Contentful Paint.
	Lcp float64 `json:"lcp"`
	// The Lighthouse performance score.
	PerformanceScore float64 `json:"performanceScore"`
	// Speed Index.
	Si float64 `json:"si"`
	// The state of the Lighthouse report.
	State LighthouseReportState `json:"state"`
	// Total Blocking Time.
	Tbt float64 `json:"tbt"`
	// Time To First Byte.
	Ttfb float64 `json:"ttfb"`
	// Time To Interactive.
	Tti  float64              `json:"tti"`
	JSON lighthouseReportJSON `json:"-"`
}

The Lighthouse report.

func (*LighthouseReport) UnmarshalJSON 

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

type LighthouseReportDeviceType 

type LighthouseReportDeviceType string

The type of device. 

const (
	LighthouseReportDeviceTypeDesktop LighthouseReportDeviceType = "DESKTOP"
	LighthouseReportDeviceTypeMobile  LighthouseReportDeviceType = "MOBILE"
)

func (LighthouseReportDeviceType) IsKnown 

func (r LighthouseReportDeviceType) IsKnown() bool

type LighthouseReportError 

type LighthouseReportError struct {
	// The error code of the Lighthouse result.
	Code LighthouseReportErrorCode `json:"code"`
	// Detailed error message.
	Detail string `json:"detail"`
	// The final URL displayed to the user.
	FinalDisplayedURL string                    `json:"finalDisplayedUrl"`
	JSON              lighthouseReportErrorJSON `json:"-"`
}

func (*LighthouseReportError) UnmarshalJSON 

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

type LighthouseReportErrorCode 

type LighthouseReportErrorCode string

The error code of the Lighthouse result. 

const (
	LighthouseReportErrorCodeNotReachable      LighthouseReportErrorCode = "NOT_REACHABLE"
	LighthouseReportErrorCodeDNSFailure        LighthouseReportErrorCode = "DNS_FAILURE"
	LighthouseReportErrorCodeNotHTML           LighthouseReportErrorCode = "NOT_HTML"
	LighthouseReportErrorCodeLighthouseTimeout LighthouseReportErrorCode = "LIGHTHOUSE_TIMEOUT"
	LighthouseReportErrorCodeUnknown           LighthouseReportErrorCode = "UNKNOWN"
)

func (LighthouseReportErrorCode) IsKnown 

func (r LighthouseReportErrorCode) IsKnown() bool

type LighthouseReportState 

type LighthouseReportState string

The state of the Lighthouse report. 

const (
	LighthouseReportStateRunning  LighthouseReportState = "RUNNING"
	LighthouseReportStateComplete LighthouseReportState = "COMPLETE"
	LighthouseReportStateFailed   LighthouseReportState = "FAILED"
)

func (LighthouseReportState) IsKnown 

func (r LighthouseReportState) IsKnown() bool

type PageListParams 

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

type PageListResponse 

type PageListResponse struct {
	// A test region with a label.
	Region LabeledRegion `json:"region"`
	// The frequency of the test.
	ScheduleFrequency PageListResponseScheduleFrequency `json:"scheduleFrequency"`
	Tests             []Test                            `json:"tests"`
	// A URL.
	URL  string               `json:"url"`
	JSON pageListResponseJSON `json:"-"`
}

func (*PageListResponse) UnmarshalJSON 

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

type PageListResponseScheduleFrequency 

type PageListResponseScheduleFrequency string

The frequency of the test. 

const (
	PageListResponseScheduleFrequencyDaily  PageListResponseScheduleFrequency = "DAILY"
	PageListResponseScheduleFrequencyWeekly PageListResponseScheduleFrequency = "WEEKLY"
)

func (PageListResponseScheduleFrequency) IsKnown 

func (r PageListResponseScheduleFrequency) IsKnown() bool

type PageService 

type PageService struct {
	Options []option.RequestOption
}

PageService 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 NewPageService method instead.

func NewPageService 

func NewPageService(opts ...option.RequestOption) (r *PageService)

NewPageService 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 (*PageService) List 

func (r *PageService) List(ctx context.Context, query PageListParams, opts ...option.RequestOption) (res *pagination.SinglePage[PageListResponse], err error)

Lists all webpages which have been tested.

func (*PageService) ListAutoPaging 

func (r *PageService) ListAutoPaging(ctx context.Context, query PageListParams, opts ...option.RequestOption) *pagination.SinglePageAutoPager[PageListResponse]

Lists all webpages which have been tested.

type Permission 

type Permission = shared.Permission

This is an alias to an internal type.

type PermissionGrant 

type PermissionGrant = shared.PermissionGrant

This is an alias to an internal type.

type PermissionGrantParam 

type PermissionGrantParam = shared.PermissionGrantParam

This is an alias to an internal type.

type ResponseInfo 

type ResponseInfo = shared.ResponseInfo

This is an alias to an internal type.

type Role 

type Role = shared.Role

This is an alias to an internal type.

type Schedule 

type Schedule struct {
	// The frequency of the test.
	Frequency ScheduleFrequency `json:"frequency"`
	// A test region.
	Region ScheduleRegion `json:"region"`
	// A URL.
	URL  string       `json:"url"`
	JSON scheduleJSON `json:"-"`
}

The test schedule.

func (*Schedule) UnmarshalJSON 

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

type ScheduleFrequency 

type ScheduleFrequency string

The frequency of the test. 

const (
	ScheduleFrequencyDaily  ScheduleFrequency = "DAILY"
	ScheduleFrequencyWeekly ScheduleFrequency = "WEEKLY"
)

func (ScheduleFrequency) IsKnown 

func (r ScheduleFrequency) IsKnown() bool

type ScheduleNewParams 

type ScheduleNewParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// A test region.
	Region param.Field[ScheduleNewParamsRegion] `query:"region"`
}

func (ScheduleNewParams) URLQuery 

func (r ScheduleNewParams) URLQuery() (v url.Values)

URLQuery serializes ScheduleNewParams's query parameters as `url.Values`.

type ScheduleNewParamsRegion 

type ScheduleNewParamsRegion string

A test region. 

const (
	ScheduleNewParamsRegionAsiaEast1           ScheduleNewParamsRegion = "asia-east1"
	ScheduleNewParamsRegionAsiaNortheast1      ScheduleNewParamsRegion = "asia-northeast1"
	ScheduleNewParamsRegionAsiaNortheast2      ScheduleNewParamsRegion = "asia-northeast2"
	ScheduleNewParamsRegionAsiaSouth1          ScheduleNewParamsRegion = "asia-south1"
	ScheduleNewParamsRegionAsiaSoutheast1      ScheduleNewParamsRegion = "asia-southeast1"
	ScheduleNewParamsRegionAustraliaSoutheast1 ScheduleNewParamsRegion = "australia-southeast1"
	ScheduleNewParamsRegionEuropeNorth1        ScheduleNewParamsRegion = "europe-north1"
	ScheduleNewParamsRegionEuropeSouthwest1    ScheduleNewParamsRegion = "europe-southwest1"
	ScheduleNewParamsRegionEuropeWest1         ScheduleNewParamsRegion = "europe-west1"
	ScheduleNewParamsRegionEuropeWest2         ScheduleNewParamsRegion = "europe-west2"
	ScheduleNewParamsRegionEuropeWest3         ScheduleNewParamsRegion = "europe-west3"
	ScheduleNewParamsRegionEuropeWest4         ScheduleNewParamsRegion = "europe-west4"
	ScheduleNewParamsRegionEuropeWest8         ScheduleNewParamsRegion = "europe-west8"
	ScheduleNewParamsRegionEuropeWest9         ScheduleNewParamsRegion = "europe-west9"
	ScheduleNewParamsRegionMeWest1             ScheduleNewParamsRegion = "me-west1"
	ScheduleNewParamsRegionSouthamericaEast1   ScheduleNewParamsRegion = "southamerica-east1"
	ScheduleNewParamsRegionUsCentral1          ScheduleNewParamsRegion = "us-central1"
	ScheduleNewParamsRegionUsEast1             ScheduleNewParamsRegion = "us-east1"
	ScheduleNewParamsRegionUsEast4             ScheduleNewParamsRegion = "us-east4"
	ScheduleNewParamsRegionUsSouth1            ScheduleNewParamsRegion = "us-south1"
	ScheduleNewParamsRegionUsWest1             ScheduleNewParamsRegion = "us-west1"
)

func (ScheduleNewParamsRegion) IsKnown 

func (r ScheduleNewParamsRegion) IsKnown() bool

type ScheduleNewResponse 

type ScheduleNewResponse struct {
	// The test schedule.
	Schedule Schedule                `json:"schedule"`
	Test     Test                    `json:"test"`
	JSON     scheduleNewResponseJSON `json:"-"`
}

func (*ScheduleNewResponse) UnmarshalJSON 

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

type ScheduleNewResponseEnvelope 

type ScheduleNewResponseEnvelope struct {
	Errors   interface{}                     `json:"errors,required"`
	Messages interface{}                     `json:"messages,required"`
	Success  interface{}                     `json:"success,required"`
	Result   ScheduleNewResponse             `json:"result"`
	JSON     scheduleNewResponseEnvelopeJSON `json:"-"`
}

func (*ScheduleNewResponseEnvelope) UnmarshalJSON 

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

type ScheduleParam 

type ScheduleParam struct {
	// The frequency of the test.
	Frequency param.Field[ScheduleFrequency] `json:"frequency"`
	// A test region.
	Region param.Field[ScheduleRegion] `json:"region"`
	// A URL.
	URL param.Field[string] `json:"url"`
}

The test schedule.

func (ScheduleParam) MarshalJSON 

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

type ScheduleRegion 

type ScheduleRegion string

A test region. 

const (
	ScheduleRegionAsiaEast1           ScheduleRegion = "asia-east1"
	ScheduleRegionAsiaNortheast1      ScheduleRegion = "asia-northeast1"
	ScheduleRegionAsiaNortheast2      ScheduleRegion = "asia-northeast2"
	ScheduleRegionAsiaSouth1          ScheduleRegion = "asia-south1"
	ScheduleRegionAsiaSoutheast1      ScheduleRegion = "asia-southeast1"
	ScheduleRegionAustraliaSoutheast1 ScheduleRegion = "australia-southeast1"
	ScheduleRegionEuropeNorth1        ScheduleRegion = "europe-north1"
	ScheduleRegionEuropeSouthwest1    ScheduleRegion = "europe-southwest1"
	ScheduleRegionEuropeWest1         ScheduleRegion = "europe-west1"
	ScheduleRegionEuropeWest2         ScheduleRegion = "europe-west2"
	ScheduleRegionEuropeWest3         ScheduleRegion = "europe-west3"
	ScheduleRegionEuropeWest4         ScheduleRegion = "europe-west4"
	ScheduleRegionEuropeWest8         ScheduleRegion = "europe-west8"
	ScheduleRegionEuropeWest9         ScheduleRegion = "europe-west9"
	ScheduleRegionMeWest1             ScheduleRegion = "me-west1"
	ScheduleRegionSouthamericaEast1   ScheduleRegion = "southamerica-east1"
	ScheduleRegionUsCentral1          ScheduleRegion = "us-central1"
	ScheduleRegionUsEast1             ScheduleRegion = "us-east1"
	ScheduleRegionUsEast4             ScheduleRegion = "us-east4"
	ScheduleRegionUsSouth1            ScheduleRegion = "us-south1"
	ScheduleRegionUsWest1             ScheduleRegion = "us-west1"
)

func (ScheduleRegion) IsKnown 

func (r ScheduleRegion) IsKnown() bool

type ScheduleService 

type ScheduleService struct {
	Options []option.RequestOption
}

ScheduleService 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 NewScheduleService method instead.

func NewScheduleService 

func NewScheduleService(opts ...option.RequestOption) (r *ScheduleService)

NewScheduleService 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 (*ScheduleService) New 

func (r *ScheduleService) New(ctx context.Context, url string, params ScheduleNewParams, opts ...option.RequestOption) (res *ScheduleNewResponse, err error)

Creates a scheduled test for a page.

type SpeedDeleteParams 

type SpeedDeleteParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// A test region.
	Region param.Field[SpeedDeleteParamsRegion] `query:"region"`
}

func (SpeedDeleteParams) URLQuery 

func (r SpeedDeleteParams) URLQuery() (v url.Values)

URLQuery serializes SpeedDeleteParams's query parameters as `url.Values`.

type SpeedDeleteParamsRegion 

type SpeedDeleteParamsRegion string

A test region. 

const (
	SpeedDeleteParamsRegionAsiaEast1           SpeedDeleteParamsRegion = "asia-east1"
	SpeedDeleteParamsRegionAsiaNortheast1      SpeedDeleteParamsRegion = "asia-northeast1"
	SpeedDeleteParamsRegionAsiaNortheast2      SpeedDeleteParamsRegion = "asia-northeast2"
	SpeedDeleteParamsRegionAsiaSouth1          SpeedDeleteParamsRegion = "asia-south1"
	SpeedDeleteParamsRegionAsiaSoutheast1      SpeedDeleteParamsRegion = "asia-southeast1"
	SpeedDeleteParamsRegionAustraliaSoutheast1 SpeedDeleteParamsRegion = "australia-southeast1"
	SpeedDeleteParamsRegionEuropeNorth1        SpeedDeleteParamsRegion = "europe-north1"
	SpeedDeleteParamsRegionEuropeSouthwest1    SpeedDeleteParamsRegion = "europe-southwest1"
	SpeedDeleteParamsRegionEuropeWest1         SpeedDeleteParamsRegion = "europe-west1"
	SpeedDeleteParamsRegionEuropeWest2         SpeedDeleteParamsRegion = "europe-west2"
	SpeedDeleteParamsRegionEuropeWest3         SpeedDeleteParamsRegion = "europe-west3"
	SpeedDeleteParamsRegionEuropeWest4         SpeedDeleteParamsRegion = "europe-west4"
	SpeedDeleteParamsRegionEuropeWest8         SpeedDeleteParamsRegion = "europe-west8"
	SpeedDeleteParamsRegionEuropeWest9         SpeedDeleteParamsRegion = "europe-west9"
	SpeedDeleteParamsRegionMeWest1             SpeedDeleteParamsRegion = "me-west1"
	SpeedDeleteParamsRegionSouthamericaEast1   SpeedDeleteParamsRegion = "southamerica-east1"
	SpeedDeleteParamsRegionUsCentral1          SpeedDeleteParamsRegion = "us-central1"
	SpeedDeleteParamsRegionUsEast1             SpeedDeleteParamsRegion = "us-east1"
	SpeedDeleteParamsRegionUsEast4             SpeedDeleteParamsRegion = "us-east4"
	SpeedDeleteParamsRegionUsSouth1            SpeedDeleteParamsRegion = "us-south1"
	SpeedDeleteParamsRegionUsWest1             SpeedDeleteParamsRegion = "us-west1"
)

func (SpeedDeleteParamsRegion) IsKnown 

func (r SpeedDeleteParamsRegion) IsKnown() bool

type SpeedDeleteResponse 

type SpeedDeleteResponse struct {
	// Number of items affected.
	Count float64                 `json:"count"`
	JSON  speedDeleteResponseJSON `json:"-"`
}

func (*SpeedDeleteResponse) UnmarshalJSON 

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

type SpeedDeleteResponseEnvelope 

type SpeedDeleteResponseEnvelope struct {
	Errors   interface{}                     `json:"errors,required"`
	Messages interface{}                     `json:"messages,required"`
	Success  interface{}                     `json:"success,required"`
	Result   SpeedDeleteResponse             `json:"result"`
	JSON     speedDeleteResponseEnvelopeJSON `json:"-"`
}

func (*SpeedDeleteResponseEnvelope) UnmarshalJSON 

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

type SpeedScheduleGetParams 

type SpeedScheduleGetParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// A test region.
	Region param.Field[SpeedScheduleGetParamsRegion] `query:"region"`
}

func (SpeedScheduleGetParams) URLQuery 

func (r SpeedScheduleGetParams) URLQuery() (v url.Values)

URLQuery serializes SpeedScheduleGetParams's query parameters as `url.Values`.

type SpeedScheduleGetParamsRegion 

type SpeedScheduleGetParamsRegion string

A test region. 

const (
	SpeedScheduleGetParamsRegionAsiaEast1           SpeedScheduleGetParamsRegion = "asia-east1"
	SpeedScheduleGetParamsRegionAsiaNortheast1      SpeedScheduleGetParamsRegion = "asia-northeast1"
	SpeedScheduleGetParamsRegionAsiaNortheast2      SpeedScheduleGetParamsRegion = "asia-northeast2"
	SpeedScheduleGetParamsRegionAsiaSouth1          SpeedScheduleGetParamsRegion = "asia-south1"
	SpeedScheduleGetParamsRegionAsiaSoutheast1      SpeedScheduleGetParamsRegion = "asia-southeast1"
	SpeedScheduleGetParamsRegionAustraliaSoutheast1 SpeedScheduleGetParamsRegion = "australia-southeast1"
	SpeedScheduleGetParamsRegionEuropeNorth1        SpeedScheduleGetParamsRegion = "europe-north1"
	SpeedScheduleGetParamsRegionEuropeSouthwest1    SpeedScheduleGetParamsRegion = "europe-southwest1"
	SpeedScheduleGetParamsRegionEuropeWest1         SpeedScheduleGetParamsRegion = "europe-west1"
	SpeedScheduleGetParamsRegionEuropeWest2         SpeedScheduleGetParamsRegion = "europe-west2"
	SpeedScheduleGetParamsRegionEuropeWest3         SpeedScheduleGetParamsRegion = "europe-west3"
	SpeedScheduleGetParamsRegionEuropeWest4         SpeedScheduleGetParamsRegion = "europe-west4"
	SpeedScheduleGetParamsRegionEuropeWest8         SpeedScheduleGetParamsRegion = "europe-west8"
	SpeedScheduleGetParamsRegionEuropeWest9         SpeedScheduleGetParamsRegion = "europe-west9"
	SpeedScheduleGetParamsRegionMeWest1             SpeedScheduleGetParamsRegion = "me-west1"
	SpeedScheduleGetParamsRegionSouthamericaEast1   SpeedScheduleGetParamsRegion = "southamerica-east1"
	SpeedScheduleGetParamsRegionUsCentral1          SpeedScheduleGetParamsRegion = "us-central1"
	SpeedScheduleGetParamsRegionUsEast1             SpeedScheduleGetParamsRegion = "us-east1"
	SpeedScheduleGetParamsRegionUsEast4             SpeedScheduleGetParamsRegion = "us-east4"
	SpeedScheduleGetParamsRegionUsSouth1            SpeedScheduleGetParamsRegion = "us-south1"
	SpeedScheduleGetParamsRegionUsWest1             SpeedScheduleGetParamsRegion = "us-west1"
)

func (SpeedScheduleGetParamsRegion) IsKnown 

func (r SpeedScheduleGetParamsRegion) IsKnown() bool

type SpeedScheduleGetResponseEnvelope 

type SpeedScheduleGetResponseEnvelope struct {
	Errors   interface{} `json:"errors,required"`
	Messages interface{} `json:"messages,required"`
	Success  interface{} `json:"success,required"`
	// The test schedule.
	Result Schedule                             `json:"result"`
	JSON   speedScheduleGetResponseEnvelopeJSON `json:"-"`
}

func (*SpeedScheduleGetResponseEnvelope) UnmarshalJSON 

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

type SpeedService 

type SpeedService struct {
	Options        []option.RequestOption
	Tests          *TestService
	Schedule       *ScheduleService
	Availabilities *AvailabilityService
	Pages          *PageService
}

SpeedService 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 NewSpeedService method instead.

func NewSpeedService 

func NewSpeedService(opts ...option.RequestOption) (r *SpeedService)

NewSpeedService 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 (*SpeedService) Delete 

func (r *SpeedService) Delete(ctx context.Context, url string, params SpeedDeleteParams, opts ...option.RequestOption) (res *SpeedDeleteResponse, err error)

Deletes a scheduled test for a page.

func (*SpeedService) ScheduleGet 

func (r *SpeedService) ScheduleGet(ctx context.Context, url string, params SpeedScheduleGetParams, opts ...option.RequestOption) (res *Schedule, err error)

Retrieves the test schedule for a page in a specific region.

func (*SpeedService) TrendsList 

func (r *SpeedService) TrendsList(ctx context.Context, url string, params SpeedTrendsListParams, opts ...option.RequestOption) (res *Trend, err error)

Lists the core web vital metrics trend over time for a specific page.

type SpeedTrendsListParams 

type SpeedTrendsListParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// The type of device.
	DeviceType param.Field[SpeedTrendsListParamsDeviceType] `query:"deviceType,required"`
	// A comma-separated list of metrics to include in the results.
	Metrics param.Field[string] `query:"metrics,required"`
	// A test region.
	Region param.Field[SpeedTrendsListParamsRegion] `query:"region,required"`
	Start  param.Field[time.Time]                   `query:"start,required" format:"date-time"`
	// The timezone of the start and end timestamps.
	Tz  param.Field[string]    `query:"tz,required"`
	End param.Field[time.Time] `query:"end" format:"date-time"`
}

func (SpeedTrendsListParams) URLQuery 

func (r SpeedTrendsListParams) URLQuery() (v url.Values)

URLQuery serializes SpeedTrendsListParams's query parameters as `url.Values`.

type SpeedTrendsListParamsDeviceType 

type SpeedTrendsListParamsDeviceType string

The type of device. 

const (
	SpeedTrendsListParamsDeviceTypeDesktop SpeedTrendsListParamsDeviceType = "DESKTOP"
	SpeedTrendsListParamsDeviceTypeMobile  SpeedTrendsListParamsDeviceType = "MOBILE"
)

func (SpeedTrendsListParamsDeviceType) IsKnown 

func (r SpeedTrendsListParamsDeviceType) IsKnown() bool

type SpeedTrendsListParamsRegion 

type SpeedTrendsListParamsRegion string

A test region. 

const (
	SpeedTrendsListParamsRegionAsiaEast1           SpeedTrendsListParamsRegion = "asia-east1"
	SpeedTrendsListParamsRegionAsiaNortheast1      SpeedTrendsListParamsRegion = "asia-northeast1"
	SpeedTrendsListParamsRegionAsiaNortheast2      SpeedTrendsListParamsRegion = "asia-northeast2"
	SpeedTrendsListParamsRegionAsiaSouth1          SpeedTrendsListParamsRegion = "asia-south1"
	SpeedTrendsListParamsRegionAsiaSoutheast1      SpeedTrendsListParamsRegion = "asia-southeast1"
	SpeedTrendsListParamsRegionAustraliaSoutheast1 SpeedTrendsListParamsRegion = "australia-southeast1"
	SpeedTrendsListParamsRegionEuropeNorth1        SpeedTrendsListParamsRegion = "europe-north1"
	SpeedTrendsListParamsRegionEuropeSouthwest1    SpeedTrendsListParamsRegion = "europe-southwest1"
	SpeedTrendsListParamsRegionEuropeWest1         SpeedTrendsListParamsRegion = "europe-west1"
	SpeedTrendsListParamsRegionEuropeWest2         SpeedTrendsListParamsRegion = "europe-west2"
	SpeedTrendsListParamsRegionEuropeWest3         SpeedTrendsListParamsRegion = "europe-west3"
	SpeedTrendsListParamsRegionEuropeWest4         SpeedTrendsListParamsRegion = "europe-west4"
	SpeedTrendsListParamsRegionEuropeWest8         SpeedTrendsListParamsRegion = "europe-west8"
	SpeedTrendsListParamsRegionEuropeWest9         SpeedTrendsListParamsRegion = "europe-west9"
	SpeedTrendsListParamsRegionMeWest1             SpeedTrendsListParamsRegion = "me-west1"
	SpeedTrendsListParamsRegionSouthamericaEast1   SpeedTrendsListParamsRegion = "southamerica-east1"
	SpeedTrendsListParamsRegionUsCentral1          SpeedTrendsListParamsRegion = "us-central1"
	SpeedTrendsListParamsRegionUsEast1             SpeedTrendsListParamsRegion = "us-east1"
	SpeedTrendsListParamsRegionUsEast4             SpeedTrendsListParamsRegion = "us-east4"
	SpeedTrendsListParamsRegionUsSouth1            SpeedTrendsListParamsRegion = "us-south1"
	SpeedTrendsListParamsRegionUsWest1             SpeedTrendsListParamsRegion = "us-west1"
)

func (SpeedTrendsListParamsRegion) IsKnown 

func (r SpeedTrendsListParamsRegion) IsKnown() bool

type SpeedTrendsListResponseEnvelope 

type SpeedTrendsListResponseEnvelope struct {
	Errors   interface{}                         `json:"errors,required"`
	Messages interface{}                         `json:"messages,required"`
	Success  interface{}                         `json:"success,required"`
	Result   Trend                               `json:"result"`
	JSON     speedTrendsListResponseEnvelopeJSON `json:"-"`
}

func (*SpeedTrendsListResponseEnvelope) UnmarshalJSON 

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

type Test 

type Test struct {
	// UUID
	ID   string    `json:"id"`
	Date time.Time `json:"date" format:"date-time"`
	// The Lighthouse report.
	DesktopReport LighthouseReport `json:"desktopReport"`
	// The Lighthouse report.
	MobileReport LighthouseReport `json:"mobileReport"`
	// A test region with a label.
	Region LabeledRegion `json:"region"`
	// The frequency of the test.
	ScheduleFrequency TestScheduleFrequency `json:"scheduleFrequency"`
	// A URL.
	URL  string   `json:"url"`
	JSON testJSON `json:"-"`
}

func (*Test) UnmarshalJSON 

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

type TestDeleteParams 

type TestDeleteParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// A test region.
	Region param.Field[TestDeleteParamsRegion] `query:"region"`
}

func (TestDeleteParams) URLQuery 

func (r TestDeleteParams) URLQuery() (v url.Values)

URLQuery serializes TestDeleteParams's query parameters as `url.Values`.

type TestDeleteParamsRegion 

type TestDeleteParamsRegion string

A test region. 

const (
	TestDeleteParamsRegionAsiaEast1           TestDeleteParamsRegion = "asia-east1"
	TestDeleteParamsRegionAsiaNortheast1      TestDeleteParamsRegion = "asia-northeast1"
	TestDeleteParamsRegionAsiaNortheast2      TestDeleteParamsRegion = "asia-northeast2"
	TestDeleteParamsRegionAsiaSouth1          TestDeleteParamsRegion = "asia-south1"
	TestDeleteParamsRegionAsiaSoutheast1      TestDeleteParamsRegion = "asia-southeast1"
	TestDeleteParamsRegionAustraliaSoutheast1 TestDeleteParamsRegion = "australia-southeast1"
	TestDeleteParamsRegionEuropeNorth1        TestDeleteParamsRegion = "europe-north1"
	TestDeleteParamsRegionEuropeSouthwest1    TestDeleteParamsRegion = "europe-southwest1"
	TestDeleteParamsRegionEuropeWest1         TestDeleteParamsRegion = "europe-west1"
	TestDeleteParamsRegionEuropeWest2         TestDeleteParamsRegion = "europe-west2"
	TestDeleteParamsRegionEuropeWest3         TestDeleteParamsRegion = "europe-west3"
	TestDeleteParamsRegionEuropeWest4         TestDeleteParamsRegion = "europe-west4"
	TestDeleteParamsRegionEuropeWest8         TestDeleteParamsRegion = "europe-west8"
	TestDeleteParamsRegionEuropeWest9         TestDeleteParamsRegion = "europe-west9"
	TestDeleteParamsRegionMeWest1             TestDeleteParamsRegion = "me-west1"
	TestDeleteParamsRegionSouthamericaEast1   TestDeleteParamsRegion = "southamerica-east1"
	TestDeleteParamsRegionUsCentral1          TestDeleteParamsRegion = "us-central1"
	TestDeleteParamsRegionUsEast1             TestDeleteParamsRegion = "us-east1"
	TestDeleteParamsRegionUsEast4             TestDeleteParamsRegion = "us-east4"
	TestDeleteParamsRegionUsSouth1            TestDeleteParamsRegion = "us-south1"
	TestDeleteParamsRegionUsWest1             TestDeleteParamsRegion = "us-west1"
)

func (TestDeleteParamsRegion) IsKnown 

func (r TestDeleteParamsRegion) IsKnown() bool

type TestDeleteResponse 

type TestDeleteResponse struct {
	// Number of items affected.
	Count float64                `json:"count"`
	JSON  testDeleteResponseJSON `json:"-"`
}

func (*TestDeleteResponse) UnmarshalJSON 

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

type TestDeleteResponseEnvelope 

type TestDeleteResponseEnvelope struct {
	Errors   interface{}                    `json:"errors,required"`
	Messages interface{}                    `json:"messages,required"`
	Success  interface{}                    `json:"success,required"`
	Result   TestDeleteResponse             `json:"result"`
	JSON     testDeleteResponseEnvelopeJSON `json:"-"`
}

func (*TestDeleteResponseEnvelope) UnmarshalJSON 

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

type TestGetParams 

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

type TestGetResponseEnvelope 

type TestGetResponseEnvelope struct {
	Errors   interface{}                 `json:"errors,required"`
	Messages interface{}                 `json:"messages,required"`
	Success  interface{}                 `json:"success,required"`
	Result   Test                        `json:"result"`
	JSON     testGetResponseEnvelopeJSON `json:"-"`
}

func (*TestGetResponseEnvelope) UnmarshalJSON 

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

type TestListParams 

type TestListParams struct {
	// Identifier
	ZoneID  param.Field[string] `path:"zone_id,required"`
	Page    param.Field[int64]  `query:"page"`
	PerPage param.Field[int64]  `query:"per_page"`
	// A test region.
	Region param.Field[TestListParamsRegion] `query:"region"`
}

func (TestListParams) URLQuery 

func (r TestListParams) URLQuery() (v url.Values)

URLQuery serializes TestListParams's query parameters as `url.Values`.

type TestListParamsRegion 

type TestListParamsRegion string

A test region. 

const (
	TestListParamsRegionAsiaEast1           TestListParamsRegion = "asia-east1"
	TestListParamsRegionAsiaNortheast1      TestListParamsRegion = "asia-northeast1"
	TestListParamsRegionAsiaNortheast2      TestListParamsRegion = "asia-northeast2"
	TestListParamsRegionAsiaSouth1          TestListParamsRegion = "asia-south1"
	TestListParamsRegionAsiaSoutheast1      TestListParamsRegion = "asia-southeast1"
	TestListParamsRegionAustraliaSoutheast1 TestListParamsRegion = "australia-southeast1"
	TestListParamsRegionEuropeNorth1        TestListParamsRegion = "europe-north1"
	TestListParamsRegionEuropeSouthwest1    TestListParamsRegion = "europe-southwest1"
	TestListParamsRegionEuropeWest1         TestListParamsRegion = "europe-west1"
	TestListParamsRegionEuropeWest2         TestListParamsRegion = "europe-west2"
	TestListParamsRegionEuropeWest3         TestListParamsRegion = "europe-west3"
	TestListParamsRegionEuropeWest4         TestListParamsRegion = "europe-west4"
	TestListParamsRegionEuropeWest8         TestListParamsRegion = "europe-west8"
	TestListParamsRegionEuropeWest9         TestListParamsRegion = "europe-west9"
	TestListParamsRegionMeWest1             TestListParamsRegion = "me-west1"
	TestListParamsRegionSouthamericaEast1   TestListParamsRegion = "southamerica-east1"
	TestListParamsRegionUsCentral1          TestListParamsRegion = "us-central1"
	TestListParamsRegionUsEast1             TestListParamsRegion = "us-east1"
	TestListParamsRegionUsEast4             TestListParamsRegion = "us-east4"
	TestListParamsRegionUsSouth1            TestListParamsRegion = "us-south1"
	TestListParamsRegionUsWest1             TestListParamsRegion = "us-west1"
)

func (TestListParamsRegion) IsKnown 

func (r TestListParamsRegion) IsKnown() bool

type TestListResponse 

type TestListResponse struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// Whether the API call was successful.
	Success    bool                       `json:"success,required"`
	ResultInfo TestListResponseResultInfo `json:"result_info"`
	JSON       testListResponseJSON       `json:"-"`
}

func (*TestListResponse) UnmarshalJSON 

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

type TestListResponseResultInfo 

type TestListResponseResultInfo struct {
	Count      int64                          `json:"count"`
	Page       int64                          `json:"page"`
	PerPage    int64                          `json:"per_page"`
	TotalCount int64                          `json:"total_count"`
	JSON       testListResponseResultInfoJSON `json:"-"`
}

func (*TestListResponseResultInfo) UnmarshalJSON 

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

type TestNewParams 

type TestNewParams struct {
	// Identifier
	ZoneID param.Field[string] `path:"zone_id,required"`
	// A test region.
	Region param.Field[TestNewParamsRegion] `json:"region"`
}

func (TestNewParams) MarshalJSON 

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

type TestNewParamsRegion 

type TestNewParamsRegion string

A test region. 

const (
	TestNewParamsRegionAsiaEast1           TestNewParamsRegion = "asia-east1"
	TestNewParamsRegionAsiaNortheast1      TestNewParamsRegion = "asia-northeast1"
	TestNewParamsRegionAsiaNortheast2      TestNewParamsRegion = "asia-northeast2"
	TestNewParamsRegionAsiaSouth1          TestNewParamsRegion = "asia-south1"
	TestNewParamsRegionAsiaSoutheast1      TestNewParamsRegion = "asia-southeast1"
	TestNewParamsRegionAustraliaSoutheast1 TestNewParamsRegion = "australia-southeast1"
	TestNewParamsRegionEuropeNorth1        TestNewParamsRegion = "europe-north1"
	TestNewParamsRegionEuropeSouthwest1    TestNewParamsRegion = "europe-southwest1"
	TestNewParamsRegionEuropeWest1         TestNewParamsRegion = "europe-west1"
	TestNewParamsRegionEuropeWest2         TestNewParamsRegion = "europe-west2"
	TestNewParamsRegionEuropeWest3         TestNewParamsRegion = "europe-west3"
	TestNewParamsRegionEuropeWest4         TestNewParamsRegion = "europe-west4"
	TestNewParamsRegionEuropeWest8         TestNewParamsRegion = "europe-west8"
	TestNewParamsRegionEuropeWest9         TestNewParamsRegion = "europe-west9"
	TestNewParamsRegionMeWest1             TestNewParamsRegion = "me-west1"
	TestNewParamsRegionSouthamericaEast1   TestNewParamsRegion = "southamerica-east1"
	TestNewParamsRegionUsCentral1          TestNewParamsRegion = "us-central1"
	TestNewParamsRegionUsEast1             TestNewParamsRegion = "us-east1"
	TestNewParamsRegionUsEast4             TestNewParamsRegion = "us-east4"
	TestNewParamsRegionUsSouth1            TestNewParamsRegion = "us-south1"
	TestNewParamsRegionUsWest1             TestNewParamsRegion = "us-west1"
)

func (TestNewParamsRegion) IsKnown 

func (r TestNewParamsRegion) IsKnown() bool

type TestNewResponseEnvelope 

type TestNewResponseEnvelope struct {
	Errors   interface{}                 `json:"errors,required"`
	Messages interface{}                 `json:"messages,required"`
	Success  interface{}                 `json:"success,required"`
	Result   Test                        `json:"result"`
	JSON     testNewResponseEnvelopeJSON `json:"-"`
}

func (*TestNewResponseEnvelope) UnmarshalJSON 

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

type TestScheduleFrequency 

type TestScheduleFrequency string

The frequency of the test. 

const (
	TestScheduleFrequencyDaily  TestScheduleFrequency = "DAILY"
	TestScheduleFrequencyWeekly TestScheduleFrequency = "WEEKLY"
)

func (TestScheduleFrequency) IsKnown 

func (r TestScheduleFrequency) IsKnown() bool

type TestService 

type TestService struct {
	Options []option.RequestOption
}

TestService 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 NewTestService method instead.

func NewTestService 

func NewTestService(opts ...option.RequestOption) (r *TestService)

NewTestService 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 (*TestService) Delete 

func (r *TestService) Delete(ctx context.Context, url string, params TestDeleteParams, opts ...option.RequestOption) (res *TestDeleteResponse, err error)

Deletes all tests for a specific webpage from a specific region. Deleted tests are still counted as part of the quota.

func (*TestService) Get 

func (r *TestService) Get(ctx context.Context, url string, testID string, query TestGetParams, opts ...option.RequestOption) (res *Test, err error)

Retrieves the result of a specific test.

func (*TestService) List 

func (r *TestService) List(ctx context.Context, url string, params TestListParams, opts ...option.RequestOption) (res *TestListResponse, err error)

Test history (list of tests) for a specific webpage.

func (*TestService) New 

func (r *TestService) New(ctx context.Context, url string, params TestNewParams, opts ...option.RequestOption) (res *Test, err error)

Starts a test for a specific webpage, in a specific region.

type Trend 

type Trend struct {
	// Cumulative Layout Shift trend.
	Cls []float64 `json:"cls"`
	// First Contentful Paint trend.
	Fcp []float64 `json:"fcp"`
	// Largest Contentful Paint trend.
	Lcp []float64 `json:"lcp"`
	// The Lighthouse score trend.
	PerformanceScore []float64 `json:"performanceScore"`
	// Speed Index trend.
	Si []float64 `json:"si"`
	// Total Blocking Time trend.
	Tbt []float64 `json:"tbt"`
	// Time To First Byte trend.
	Ttfb []float64 `json:"ttfb"`
	// Time To Interactive trend.
	Tti  []float64 `json:"tti"`
	JSON trendJSON `json:"-"`
}

func (*Trend) UnmarshalJSON 

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

type User 

type User = shared.User

This is an alias to an internal type.

type UserParam 

type UserParam = shared.UserParam

This is an alias to an internal type.

type UserRole 

type UserRole = shared.UserRole

This is an alias to an internal type.

type UserRoleParam 

type UserRoleParam = shared.UserRoleParam

This is an alias to an internal type.

type UserRolesPermissions 

type UserRolesPermissions = shared.UserRolesPermissions

This is an alias to an internal type.

type UserRolesPermissionsParam 

type UserRolesPermissionsParam = shared.UserRolesPermissionsParam

This is an alias to an internal type.

type UserUser 

type UserUser = shared.UserUser

This is an alias to an internal type.

type UserUserParam 

type UserUserParam = shared.UserUserParam

This is an alias to an internal type.

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.