url_scanner

type ASN = shared.ASN

type ASNParam = shared.ASNParam

type AuditLog = shared.AuditLog

type AuditLogAction = shared.AuditLogAction

type AuditLogActor = shared.AuditLogActor

type AuditLogActorType = shared.AuditLogActorType

type AuditLogOwner = shared.AuditLogOwner

type AuditLogResource = shared.AuditLogResource

type CertificateCA = shared.CertificateCA

type CertificateRequestType = shared.CertificateRequestType

type CloudflareTunnel = shared.CloudflareTunnel

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

type Error = apierror.Error

type ErrorData = shared.ErrorData

type Member = shared.Member

type MemberParam = shared.MemberParam

type MemberRole = shared.MemberRole

type MemberRoleParam = shared.MemberRoleParam

type MemberRolesPermissions = shared.MemberRolesPermissions

type MemberRolesPermissionsParam = shared.MemberRolesPermissionsParam

type MemberUser = shared.MemberUser

type MemberUserParam = shared.MemberUserParam

type Permission = shared.Permission

type PermissionGrant = shared.PermissionGrant

type PermissionGrantParam = shared.PermissionGrantParam

type ResponseInfo = shared.ResponseInfo

type Role = shared.Role

type ScanGetResponse struct {
	Scan ScanGetResponseScan `json:"scan,required"`
	JSON scanGetResponseJSON `json:"-"`
}

type ScanGetResponseEnvelope struct {
	Errors   []ScanGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ScanGetResponseEnvelopeMessages `json:"messages,required"`
	Result   ScanGetResponse                   `json:"result,required"`
	// Whether request was successful or not
	Success bool                        `json:"success,required"`
	JSON    scanGetResponseEnvelopeJSON `json:"-"`
}

type ScanGetResponseEnvelopeErrors struct {
	Message string                            `json:"message,required"`
	JSON    scanGetResponseEnvelopeErrorsJSON `json:"-"`
}

type ScanGetResponseEnvelopeMessages struct {
	Message string                              `json:"message,required"`
	JSON    scanGetResponseEnvelopeMessagesJSON `json:"-"`
}

type ScanGetResponseScan struct {
	Certificates []ScanGetResponseScanCertificate `json:"certificates,required"`
	Geo          ScanGetResponseScanGeo           `json:"geo,required"`
	Meta         ScanGetResponseScanMeta          `json:"meta,required"`
	Page         ScanGetResponseScanPage          `json:"page,required"`
	Performance  []ScanGetResponseScanPerformance `json:"performance,required"`
	Task         ScanGetResponseScanTask          `json:"task,required"`
	Verdicts     ScanGetResponseScanVerdicts      `json:"verdicts,required"`
	// Dictionary of Autonomous System Numbers where ASN's are the keys
	ASNs    ScanGetResponseScanASNs    `json:"asns"`
	Domains ScanGetResponseScanDomains `json:"domains"`
	IPs     ScanGetResponseScanIPs     `json:"ips"`
	Links   ScanGetResponseScanLinks   `json:"links"`
	JSON    scanGetResponseScanJSON    `json:"-"`
}

type ScanGetResponseScanASNs struct {
	// ASN's contacted
	ASN  ScanGetResponseScanASNsASN  `json:"asn"`
	JSON scanGetResponseScanASNsJSON `json:"-"`
}

type ScanGetResponseScanASNsASN struct {
	ASN            string                         `json:"asn,required"`
	Description    string                         `json:"description,required"`
	LocationAlpha2 string                         `json:"location_alpha2,required"`
	Name           string                         `json:"name,required"`
	OrgName        string                         `json:"org_name,required"`
	JSON           scanGetResponseScanASNsASNJSON `json:"-"`
}

type ScanGetResponseScanCertificate struct {
	Issuer      string                             `json:"issuer,required"`
	SubjectName string                             `json:"subjectName,required"`
	ValidFrom   float64                            `json:"validFrom,required"`
	ValidTo     float64                            `json:"validTo,required"`
	JSON        scanGetResponseScanCertificateJSON `json:"-"`
}

type ScanGetResponseScanDomains struct {
	ExampleCom ScanGetResponseScanDomainsExampleCom `json:"example.com"`
	JSON       scanGetResponseScanDomainsJSON       `json:"-"`
}

type ScanGetResponseScanDomainsExampleCom struct {
	Categories ScanGetResponseScanDomainsExampleComCategories `json:"categories,required"`
	DNS        []ScanGetResponseScanDomainsExampleComDNS      `json:"dns,required"`
	Name       string                                         `json:"name,required"`
	Rank       ScanGetResponseScanDomainsExampleComRank       `json:"rank,required"`
	Type       string                                         `json:"type,required"`
	JSON       scanGetResponseScanDomainsExampleComJSON       `json:"-"`
}

type ScanGetResponseScanDomainsExampleComCategories struct {
	Inherited ScanGetResponseScanDomainsExampleComCategoriesInherited `json:"inherited,required"`
	Content   []URLScannerDomain                                      `json:"content"`
	Risks     []URLScannerDomain                                      `json:"risks"`
	JSON      scanGetResponseScanDomainsExampleComCategoriesJSON      `json:"-"`
}

type ScanGetResponseScanDomainsExampleComCategoriesInherited struct {
	Content []URLScannerDomain                                          `json:"content"`
	From    string                                                      `json:"from"`
	Risks   []URLScannerDomain                                          `json:"risks"`
	JSON    scanGetResponseScanDomainsExampleComCategoriesInheritedJSON `json:"-"`
}

type ScanGetResponseScanDomainsExampleComDNS struct {
	Address     string                                      `json:"address,required"`
	DNSSECValid bool                                        `json:"dnssec_valid,required"`
	Name        string                                      `json:"name,required"`
	Type        string                                      `json:"type,required"`
	JSON        scanGetResponseScanDomainsExampleComDNSJSON `json:"-"`
}

type ScanGetResponseScanDomainsExampleComRank struct {
	Bucket string `json:"bucket,required"`
	Name   string `json:"name,required"`
	// Rank in the Global Radar Rank, if set. See more at
	// https://blog.cloudflare.com/radar-domain-rankings/
	Rank int64                                        `json:"rank"`
	JSON scanGetResponseScanDomainsExampleComRankJSON `json:"-"`
}

type ScanGetResponseScanGeo struct {
	// GeoIP continent location
	Continents []string `json:"continents,required"`
	// GeoIP country location
	Locations []string                   `json:"locations,required"`
	JSON      scanGetResponseScanGeoJSON `json:"-"`
}

type ScanGetResponseScanIPs struct {
	IP   ScanGetResponseScanIPsIP   `json:"ip"`
	JSON scanGetResponseScanIPsJSON `json:"-"`
}

type ScanGetResponseScanIPsIP struct {
	ASN               string                       `json:"asn,required"`
	ASNDescription    string                       `json:"asnDescription,required"`
	ASNLocationAlpha2 string                       `json:"asnLocationAlpha2,required"`
	ASNName           string                       `json:"asnName,required"`
	ASNOrgName        string                       `json:"asnOrgName,required"`
	Continent         string                       `json:"continent,required"`
	GeonameID         string                       `json:"geonameId,required"`
	IP                string                       `json:"ip,required"`
	IPVersion         string                       `json:"ipVersion,required"`
	Latitude          string                       `json:"latitude,required"`
	LocationAlpha2    string                       `json:"locationAlpha2,required"`
	LocationName      string                       `json:"locationName,required"`
	Longitude         string                       `json:"longitude,required"`
	Subdivision1Name  string                       `json:"subdivision1Name,required"`
	Subdivision2Name  string                       `json:"subdivision2Name,required"`
	JSON              scanGetResponseScanIPsIPJSON `json:"-"`
}

type ScanGetResponseScanLinks struct {
	Link ScanGetResponseScanLinksLink `json:"link"`
	JSON scanGetResponseScanLinksJSON `json:"-"`
}

type ScanGetResponseScanLinksLink struct {
	// Outgoing link detected in the DOM
	Href string                           `json:"href,required"`
	Text string                           `json:"text,required"`
	JSON scanGetResponseScanLinksLinkJSON `json:"-"`
}

type ScanGetResponseScanMeta struct {
	Processors ScanGetResponseScanMetaProcessors `json:"processors,required"`
	JSON       scanGetResponseScanMetaJSON       `json:"-"`
}

type ScanGetResponseScanMetaProcessors struct {
	Categories ScanGetResponseScanMetaProcessorsCategories `json:"categories,required"`
	Phishing   []string                                    `json:"phishing,required"`
	Rank       ScanGetResponseScanMetaProcessorsRank       `json:"rank,required"`
	Tech       []ScanGetResponseScanMetaProcessorsTech     `json:"tech,required"`
	JSON       scanGetResponseScanMetaProcessorsJSON       `json:"-"`
}

type ScanGetResponseScanMetaProcessorsCategories struct {
	Content []URLScannerDomain                                `json:"content,required"`
	Risks   []ScanGetResponseScanMetaProcessorsCategoriesRisk `json:"risks,required"`
	JSON    scanGetResponseScanMetaProcessorsCategoriesJSON   `json:"-"`
}

type ScanGetResponseScanMetaProcessorsCategoriesRisk struct {
	ID              int64                                               `json:"id,required"`
	Name            string                                              `json:"name,required"`
	SuperCategoryID int64                                               `json:"super_category_id,required"`
	JSON            scanGetResponseScanMetaProcessorsCategoriesRiskJSON `json:"-"`
}

type ScanGetResponseScanMetaProcessorsRank struct {
	Bucket string `json:"bucket,required"`
	Name   string `json:"name,required"`
	// Rank in the Global Radar Rank, if set. See more at
	// https://blog.cloudflare.com/radar-domain-rankings/
	Rank int64                                     `json:"rank"`
	JSON scanGetResponseScanMetaProcessorsRankJSON `json:"-"`
}

type ScanGetResponseScanMetaProcessorsTech struct {
	Categories  []ScanGetResponseScanMetaProcessorsTechCategory `json:"categories,required"`
	Confidence  int64                                           `json:"confidence,required"`
	Evidence    ScanGetResponseScanMetaProcessorsTechEvidence   `json:"evidence,required"`
	Icon        string                                          `json:"icon,required"`
	Name        string                                          `json:"name,required"`
	Slug        string                                          `json:"slug,required"`
	Website     string                                          `json:"website,required"`
	Description string                                          `json:"description"`
	JSON        scanGetResponseScanMetaProcessorsTechJSON       `json:"-"`
}

type ScanGetResponseScanMetaProcessorsTechCategory struct {
	ID       int64                                             `json:"id,required"`
	Groups   []int64                                           `json:"groups,required"`
	Name     string                                            `json:"name,required"`
	Priority int64                                             `json:"priority,required"`
	Slug     string                                            `json:"slug,required"`
	JSON     scanGetResponseScanMetaProcessorsTechCategoryJSON `json:"-"`
}

type ScanGetResponseScanMetaProcessorsTechEvidence struct {
	ImpliedBy []string                                               `json:"impliedBy,required"`
	Patterns  []ScanGetResponseScanMetaProcessorsTechEvidencePattern `json:"patterns,required"`
	JSON      scanGetResponseScanMetaProcessorsTechEvidenceJSON      `json:"-"`
}

type ScanGetResponseScanMetaProcessorsTechEvidencePattern struct {
	Confidence int64    `json:"confidence,required"`
	Excludes   []string `json:"excludes,required"`
	Implies    []string `json:"implies,required"`
	Match      string   `json:"match,required"`
	// Header or Cookie name when set
	Name    string                                                   `json:"name,required"`
	Regex   string                                                   `json:"regex,required"`
	Type    string                                                   `json:"type,required"`
	Value   string                                                   `json:"value,required"`
	Version string                                                   `json:"version,required"`
	JSON    scanGetResponseScanMetaProcessorsTechEvidencePatternJSON `json:"-"`
}

type ScanGetResponseScanPage struct {
	ASN                   string                                     `json:"asn,required"`
	ASNLocationAlpha2     string                                     `json:"asnLocationAlpha2,required"`
	Asnname               string                                     `json:"asnname,required"`
	Console               []ScanGetResponseScanPageConsole           `json:"console,required"`
	Cookies               []ScanGetResponseScanPageCookie            `json:"cookies,required"`
	Country               string                                     `json:"country,required"`
	CountryLocationAlpha2 string                                     `json:"countryLocationAlpha2,required"`
	Domain                string                                     `json:"domain,required"`
	Headers               []radar.Browser                            `json:"headers,required"`
	IP                    string                                     `json:"ip,required"`
	JS                    ScanGetResponseScanPageJS                  `json:"js,required"`
	SecurityViolations    []ScanGetResponseScanPageSecurityViolation `json:"securityViolations,required"`
	Status                float64                                    `json:"status,required"`
	Subdivision1Name      string                                     `json:"subdivision1Name,required"`
	Subdivision2name      string                                     `json:"subdivision2name,required"`
	URL                   string                                     `json:"url,required"`
	JSON                  scanGetResponseScanPageJSON                `json:"-"`
}

type ScanGetResponseScanPageConsole struct {
	Category string                             `json:"category,required"`
	Text     string                             `json:"text,required"`
	Type     string                             `json:"type,required"`
	URL      string                             `json:"url"`
	JSON     scanGetResponseScanPageConsoleJSON `json:"-"`
}

type ScanGetResponseScanPageCookie struct {
	Domain       string                            `json:"domain,required"`
	Expires      float64                           `json:"expires,required"`
	HTTPOnly     bool                              `json:"httpOnly,required"`
	Name         string                            `json:"name,required"`
	Path         string                            `json:"path,required"`
	SameParty    bool                              `json:"sameParty,required"`
	Secure       bool                              `json:"secure,required"`
	Session      bool                              `json:"session,required"`
	Size         float64                           `json:"size,required"`
	SourcePort   float64                           `json:"sourcePort,required"`
	SourceScheme string                            `json:"sourceScheme,required"`
	Value        string                            `json:"value,required"`
	Priority     string                            `json:"priority"`
	JSON         scanGetResponseScanPageCookieJSON `json:"-"`
}

type ScanGetResponseScanPageJS struct {
	Variables []ScanGetResponseScanPageJSVariable `json:"variables,required"`
	JSON      scanGetResponseScanPageJSJSON       `json:"-"`
}

type ScanGetResponseScanPageJSVariable struct {
	Name string                                `json:"name,required"`
	Type string                                `json:"type,required"`
	JSON scanGetResponseScanPageJSVariableJSON `json:"-"`
}

type ScanGetResponseScanPageSecurityViolation struct {
	Category string                                       `json:"category,required"`
	Text     string                                       `json:"text,required"`
	URL      string                                       `json:"url,required"`
	JSON     scanGetResponseScanPageSecurityViolationJSON `json:"-"`
}

type ScanGetResponseScanPerformance struct {
	ConnectEnd                 float64                            `json:"connectEnd,required"`
	ConnectStart               float64                            `json:"connectStart,required"`
	DecodedBodySize            float64                            `json:"decodedBodySize,required"`
	DomainLookupEnd            float64                            `json:"domainLookupEnd,required"`
	DomainLookupStart          float64                            `json:"domainLookupStart,required"`
	DomComplete                float64                            `json:"domComplete,required"`
	DomContentLoadedEventEnd   float64                            `json:"domContentLoadedEventEnd,required"`
	DomContentLoadedEventStart float64                            `json:"domContentLoadedEventStart,required"`
	DomInteractive             float64                            `json:"domInteractive,required"`
	Duration                   float64                            `json:"duration,required"`
	EncodedBodySize            float64                            `json:"encodedBodySize,required"`
	EntryType                  string                             `json:"entryType,required"`
	FetchStart                 float64                            `json:"fetchStart,required"`
	InitiatorType              string                             `json:"initiatorType,required"`
	LoadEventEnd               float64                            `json:"loadEventEnd,required"`
	LoadEventStart             float64                            `json:"loadEventStart,required"`
	Name                       string                             `json:"name,required"`
	NextHopProtocol            string                             `json:"nextHopProtocol,required"`
	RedirectCount              float64                            `json:"redirectCount,required"`
	RedirectEnd                float64                            `json:"redirectEnd,required"`
	RedirectStart              float64                            `json:"redirectStart,required"`
	RequestStart               float64                            `json:"requestStart,required"`
	ResponseEnd                float64                            `json:"responseEnd,required"`
	ResponseStart              float64                            `json:"responseStart,required"`
	SecureConnectionStart      float64                            `json:"secureConnectionStart,required"`
	StartTime                  float64                            `json:"startTime,required"`
	TransferSize               float64                            `json:"transferSize,required"`
	Type                       string                             `json:"type,required"`
	UnloadEventEnd             float64                            `json:"unloadEventEnd,required"`
	UnloadEventStart           float64                            `json:"unloadEventStart,required"`
	WorkerStart                float64                            `json:"workerStart,required"`
	JSON                       scanGetResponseScanPerformanceJSON `json:"-"`
}

type ScanGetResponseScanTask struct {
	// Submitter location
	ClientLocation string                            `json:"clientLocation,required"`
	ClientType     ScanGetResponseScanTaskClientType `json:"clientType,required"`
	// URL of the primary request, after all HTTP redirects
	EffectiveURL string                             `json:"effectiveUrl,required"`
	Errors       []ScanGetResponseScanTaskError     `json:"errors,required"`
	ScannedFrom  ScanGetResponseScanTaskScannedFrom `json:"scannedFrom,required"`
	Status       ScanGetResponseScanTaskStatus      `json:"status,required"`
	Success      bool                               `json:"success,required"`
	Time         string                             `json:"time,required"`
	TimeEnd      string                             `json:"timeEnd,required"`
	// Submitted URL
	URL string `json:"url,required"`
	// Scan ID
	UUID       string                            `json:"uuid,required"`
	Visibility ScanGetResponseScanTaskVisibility `json:"visibility,required"`
	JSON       scanGetResponseScanTaskJSON       `json:"-"`
}

type ScanGetResponseScanTaskClientType string

type ScanGetResponseScanTaskError struct {
	Message string                           `json:"message,required"`
	JSON    scanGetResponseScanTaskErrorJSON `json:"-"`
}

type ScanGetResponseScanTaskScannedFrom struct {
	// IATA code of Cloudflare datacenter
	Colo string                                 `json:"colo,required"`
	JSON scanGetResponseScanTaskScannedFromJSON `json:"-"`
}

type ScanGetResponseScanTaskStatus string

type ScanGetResponseScanTaskVisibility string

type ScanGetResponseScanVerdicts struct {
	Overall ScanGetResponseScanVerdictsOverall `json:"overall,required"`
	JSON    scanGetResponseScanVerdictsJSON    `json:"-"`
}

type ScanGetResponseScanVerdictsOverall struct {
	Categories []ScanGetResponseScanVerdictsOverallCategory `json:"categories,required"`
	// At least one of our subsystems marked the site as potentially malicious at the
	// time of the scan.
	Malicious bool                                   `json:"malicious,required"`
	Phishing  []string                               `json:"phishing,required"`
	JSON      scanGetResponseScanVerdictsOverallJSON `json:"-"`
}

type ScanGetResponseScanVerdictsOverallCategory struct {
	ID              float64                                        `json:"id,required"`
	Name            string                                         `json:"name,required"`
	SuperCategoryID float64                                        `json:"super_category_id,required"`
	JSON            scanGetResponseScanVerdictsOverallCategoryJSON `json:"-"`
}

type ScanHarResponse struct {
	Har  ScanHarResponseHar  `json:"har,required"`
	JSON scanHarResponseJSON `json:"-"`
}

type ScanHarResponseEnvelope struct {
	Errors   []ScanHarResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ScanHarResponseEnvelopeMessages `json:"messages,required"`
	Result   ScanHarResponse                   `json:"result,required"`
	// Whether search request was successful or not
	Success bool                        `json:"success,required"`
	JSON    scanHarResponseEnvelopeJSON `json:"-"`
}

type ScanHarResponseEnvelopeErrors struct {
	Message string                            `json:"message,required"`
	JSON    scanHarResponseEnvelopeErrorsJSON `json:"-"`
}

type ScanHarResponseEnvelopeMessages struct {
	Message string                              `json:"message,required"`
	JSON    scanHarResponseEnvelopeMessagesJSON `json:"-"`
}

type ScanHarResponseHar struct {
	Log  ScanHarResponseHarLog  `json:"log,required"`
	JSON scanHarResponseHarJSON `json:"-"`
}

type ScanHarResponseHarLog struct {
	Creator ScanHarResponseHarLogCreator `json:"creator,required"`
	Entries []ScanHarResponseHarLogEntry `json:"entries,required"`
	Pages   []ScanHarResponseHarLogPage  `json:"pages,required"`
	Version string                       `json:"version,required"`
	JSON    scanHarResponseHarLogJSON    `json:"-"`
}

type ScanHarResponseHarLogCreator struct {
	Comment string                           `json:"comment,required"`
	Name    string                           `json:"name,required"`
	Version string                           `json:"version,required"`
	JSON    scanHarResponseHarLogCreatorJSON `json:"-"`
}

type ScanHarResponseHarLogEntriesRequest struct {
	BodySize    float64                                 `json:"bodySize,required"`
	Headers     []radar.Browser                         `json:"headers,required"`
	HeadersSize float64                                 `json:"headersSize,required"`
	HTTPVersion string                                  `json:"httpVersion,required"`
	Method      string                                  `json:"method,required"`
	URL         string                                  `json:"url,required"`
	JSON        scanHarResponseHarLogEntriesRequestJSON `json:"-"`
}

type ScanHarResponseHarLogEntriesResponse struct {
	TransferSize float64                                     `json:"_transferSize,required"`
	BodySize     float64                                     `json:"bodySize,required"`
	Content      ScanHarResponseHarLogEntriesResponseContent `json:"content,required"`
	Headers      []radar.Browser                             `json:"headers,required"`
	HeadersSize  float64                                     `json:"headersSize,required"`
	HTTPVersion  string                                      `json:"httpVersion,required"`
	RedirectURL  string                                      `json:"redirectURL,required"`
	Status       float64                                     `json:"status,required"`
	StatusText   string                                      `json:"statusText,required"`
	JSON         scanHarResponseHarLogEntriesResponseJSON    `json:"-"`
}

type ScanHarResponseHarLogEntriesResponseContent struct {
	MimeType    string                                          `json:"mimeType,required"`
	Size        float64                                         `json:"size,required"`
	Compression int64                                           `json:"compression"`
	JSON        scanHarResponseHarLogEntriesResponseContentJSON `json:"-"`
}

type ScanHarResponseHarLogEntry struct {
	InitialPriority string                               `json:"_initialPriority,required"`
	InitiatorType   string                               `json:"_initiator_type,required"`
	Priority        string                               `json:"_priority,required"`
	RequestID       string                               `json:"_requestId,required"`
	RequestTime     float64                              `json:"_requestTime,required"`
	ResourceType    string                               `json:"_resourceType,required"`
	Cache           interface{}                          `json:"cache,required"`
	Connection      string                               `json:"connection,required"`
	Pageref         string                               `json:"pageref,required"`
	Request         ScanHarResponseHarLogEntriesRequest  `json:"request,required"`
	Response        ScanHarResponseHarLogEntriesResponse `json:"response,required"`
	ServerIPAddress string                               `json:"serverIPAddress,required"`
	StartedDateTime string                               `json:"startedDateTime,required"`
	Time            float64                              `json:"time,required"`
	JSON            scanHarResponseHarLogEntryJSON       `json:"-"`
}

type ScanHarResponseHarLogPage struct {
	ID              string                                `json:"id,required"`
	PageTimings     ScanHarResponseHarLogPagesPageTimings `json:"pageTimings,required"`
	StartedDateTime string                                `json:"startedDateTime,required"`
	Title           string                                `json:"title,required"`
	JSON            scanHarResponseHarLogPageJSON         `json:"-"`
}

type ScanHarResponseHarLogPagesPageTimings struct {
	OnContentLoad float64                                   `json:"onContentLoad,required"`
	OnLoad        float64                                   `json:"onLoad,required"`
	JSON          scanHarResponseHarLogPagesPageTimingsJSON `json:"-"`
}

type ScanNewParams struct {
	URL param.Field[string] `json:"url,required"`
	// Set custom headers
	CustomHeaders param.Field[map[string]string] `json:"customHeaders"`
	// Take multiple screenshots targeting different device types
	ScreenshotsResolutions param.Field[[]ScanNewParamsScreenshotsResolution] `json:"screenshotsResolutions"`
	// The option `Public` means it will be included in listings like recent scans and
	// search results. `Unlisted` means it will not be included in the aforementioned
	// listings, users will need to have the scan's ID to access it. A a scan will be
	// automatically marked as unlisted if it fails, if it contains potential PII or
	// other sensitive material.
	Visibility param.Field[ScanNewParamsVisibility] `json:"visibility"`
}

type ScanNewParamsScreenshotsResolution string

type ScanNewParamsVisibility string

type ScanNewResponse struct {
	// Time when url was submitted for scanning.
	Time time.Time `json:"time,required" format:"date-time"`
	// Canonical form of submitted URL. Use this if you want to later search by URL.
	URL string `json:"url,required"`
	// Scan ID.
	UUID string `json:"uuid,required" format:"uuid"`
	// Submitted visibility status.
	Visibility string              `json:"visibility,required"`
	JSON       scanNewResponseJSON `json:"-"`
}

type ScanNewResponseEnvelope struct {
	Errors   []ScanNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []ScanNewResponseEnvelopeMessages `json:"messages,required"`
	Result   ScanNewResponse                   `json:"result,required"`
	Success  bool                              `json:"success,required"`
	JSON     scanNewResponseEnvelopeJSON       `json:"-"`
}

type ScanNewResponseEnvelopeErrors struct {
	Message string                            `json:"message,required"`
	JSON    scanNewResponseEnvelopeErrorsJSON `json:"-"`
}

type ScanNewResponseEnvelopeMessages struct {
	Message string                              `json:"message,required"`
	JSON    scanNewResponseEnvelopeMessagesJSON `json:"-"`
}

type ScanScreenshotParams struct {
	// Target device type
	Resolution param.Field[ScanScreenshotParamsResolution] `query:"resolution"`
}

type ScanScreenshotParamsResolution string

type ScanService struct {
	Options []option.RequestOption
}

type SortDirection = shared.SortDirection

type URLScannerDomain struct {
	ID              int64                `json:"id,required"`
	Name            string               `json:"name,required"`
	SuperCategoryID int64                `json:"super_category_id"`
	JSON            urlScannerDomainJSON `json:"-"`
}

type URLScannerScanParams struct {
	// Return only scans created by account.
	AccountScans param.Field[bool] `query:"account_scans"`
	// Filter scans by Autonomous System Number (ASN) of _any_ request made by the
	// webpage.
	ASN param.Field[string] `query:"asn"`
	// Filter scans requested before date (inclusive).
	DateEnd param.Field[time.Time] `query:"date_end" format:"date-time"`
	// Filter scans requested after date (inclusive).
	DateStart param.Field[time.Time] `query:"date_start" format:"date-time"`
	// Filter scans by hash of any html/js/css request made by the webpage.
	Hash param.Field[string] `query:"hash"`
	// Filter scans by hostname of _any_ request made by the webpage.
	Hostname param.Field[string] `query:"hostname"`
	// Filter scans by IP address (IPv4 or IPv6) of _any_ request made by the webpage.
	IP param.Field[string] `query:"ip"`
	// Filter scans by malicious verdict.
	IsMalicious param.Field[bool] `query:"is_malicious"`
	// Limit the number of objects in the response.
	Limit param.Field[int64] `query:"limit"`
	// Pagination cursor to get the next set of results.
	NextCursor param.Field[string] `query:"next_cursor"`
	// Filter scans by main page Autonomous System Number (ASN).
	PageASN param.Field[string] `query:"page_asn"`
	// Filter scans by main page hostname (domain of effective URL).
	PageHostname param.Field[string] `query:"page_hostname"`
	// Filter scans by main page IP address (IPv4 or IPv6).
	PageIP param.Field[string] `query:"page_ip"`
	// Filter scans by exact match of effective URL path (also supports suffix search).
	PagePath param.Field[string] `query:"page_path"`
	// Filter scans by submitted or scanned URL
	PageURL param.Field[string] `query:"page_url"`
	// Filter scans by url path of _any_ request made by the webpage.
	Path param.Field[string] `query:"path"`
	// Scan uuid
	ScanID param.Field[string] `query:"scanId" format:"uuid"`
	// Filter scans by URL of _any_ request made by the webpage
	URL param.Field[string] `query:"url"`
}

type URLScannerScanResponse struct {
	Tasks []URLScannerScanResponseTask `json:"tasks,required"`
	JSON  urlScannerScanResponseJSON   `json:"-"`
}

type URLScannerScanResponseEnvelope struct {
	Errors   []URLScannerScanResponseEnvelopeErrors   `json:"errors,required"`
	Messages []URLScannerScanResponseEnvelopeMessages `json:"messages,required"`
	Result   URLScannerScanResponse                   `json:"result,required"`
	// Whether search request was successful or not
	Success bool                               `json:"success,required"`
	JSON    urlScannerScanResponseEnvelopeJSON `json:"-"`
}

type URLScannerScanResponseEnvelopeErrors struct {
	Message string                                   `json:"message,required"`
	JSON    urlScannerScanResponseEnvelopeErrorsJSON `json:"-"`
}

type URLScannerScanResponseEnvelopeMessages struct {
	Message string                                     `json:"message,required"`
	JSON    urlScannerScanResponseEnvelopeMessagesJSON `json:"-"`
}

type URLScannerScanResponseTask struct {
	// Alpha-2 country code
	Country string `json:"country,required"`
	// Whether scan was successful or not
	Success bool `json:"success,required"`
	// When scan was submitted (UTC)
	Time time.Time `json:"time,required" format:"date-time"`
	// Scan url (after redirects)
	URL string `json:"url,required"`
	// Scan id
	UUID string `json:"uuid,required" format:"uuid"`
	// Visibility status.
	Visibility string                         `json:"visibility,required"`
	JSON       urlScannerScanResponseTaskJSON `json:"-"`
}

type URLScannerService struct {
	Options []option.RequestOption
	Scans   *ScanService
}