import * as Core from 'cloudflaredev/core';
import { APIResource } from 'cloudflaredev/resource';
import { type Response } from 'cloudflaredev/_shims/index';
import * as ScansAPI from 'cloudflaredev/resources/url-scanner/scans';
import * as TopAPI from 'cloudflaredev/resources/radar/http/top';
export declare class Scans extends APIResource {
    /**
     * Submit a URL to scan. You can also set some options, like the visibility level
     * and custom headers. Accounts are limited to 1 new scan every 10 seconds and 8000
     * per month. If you need more, please reach out.
     */
    create(accountId: string, body: ScanCreateParams, options?: Core.RequestOptions): Core.APIPromise<ScanCreateResponse>;
    /**
     * Get URL scan by uuid
     */
    get(accountId: string, scanId: string, options?: Core.RequestOptions): Core.APIPromise<ScanGetResponse>;
    /**
     * Get a URL scan's HAR file. See HAR spec at
     * http://www.softwareishard.com/blog/har-12-spec/.
     */
    har(accountId: string, scanId: string, options?: Core.RequestOptions): Core.APIPromise<ScanHarResponse>;
    /**
     * Get scan's screenshot by resolution (desktop/mobile/tablet).
     */
    screenshot(accountId: string, scanId: string, query?: ScanScreenshotParams, options?: Core.RequestOptions): Core.APIPromise<Response>;
    screenshot(accountId: string, scanId: string, options?: Core.RequestOptions): Core.APIPromise<Response>;
}
export interface URLScannerDomain {
    id: number;
    name: string;
    super_category_id?: number;
}
export interface URLScannerTask {
    effectiveUrl: string;
    errors: Array<URLScannerTask.Error>;
    location: string;
    region: string;
    status: string;
    success: boolean;
    time: string;
    url: string;
    uuid: string;
    visibility: string;
}
export declare namespace URLScannerTask {
    interface Error {
        message: string;
    }
}
export interface ScanCreateResponse {
    /**
     * Time when url was submitted for scanning.
     */
    time: string;
    /**
     * Canonical form of submitted URL. Use this if you want to later search by URL.
     */
    url: string;
    /**
     * Scan ID.
     */
    uuid: string;
    /**
     * Submitted visibility status.
     */
    visibility: string;
}
export interface ScanGetResponse {
    scan: ScanGetResponse.Scan;
}
export declare namespace ScanGetResponse {
    interface Scan {
        certificates: Array<Scan.Certificate>;
        geo: Scan.Geo;
        meta: Scan.Meta;
        page: Scan.Page;
        performance: Array<Scan.Performance>;
        task: Scan.Task;
        verdicts: Scan.Verdicts;
        /**
         * Dictionary of Autonomous System Numbers where ASN's are the keys
         */
        asns?: Scan.ASNs;
        domains?: Scan.Domains;
        ips?: Scan.IPs;
        links?: Scan.Links;
    }
    namespace Scan {
        interface Certificate {
            issuer: string;
            subjectName: string;
            validFrom: number;
            validTo: number;
        }
        interface Geo {
            /**
             * GeoIP continent location
             */
            continents: Array<string>;
            /**
             * GeoIP country location
             */
            locations: Array<string>;
        }
        interface Meta {
            processors: Meta.Processors;
        }
        namespace Meta {
            interface Processors {
                categories: Processors.Categories;
                phishing: Array<string>;
                rank: Processors.Rank;
                tech: Array<Processors.Tech>;
            }
            namespace Processors {
                interface Categories {
                    content: Array<ScansAPI.URLScannerDomain>;
                    risks: Array<Categories.Risk>;
                }
                namespace Categories {
                    interface Risk {
                        id: number;
                        name: string;
                        super_category_id: number;
                    }
                }
                interface Rank {
                    bucket: string;
                    name: string;
                    /**
                     * Rank in the Global Radar Rank, if set. See more at
                     * https://blog.cloudflare.com/radar-domain-rankings/
                     */
                    rank?: number;
                }
                interface Tech {
                    categories: Array<Tech.Category>;
                    confidence: number;
                    evidence: Tech.Evidence;
                    icon: string;
                    name: string;
                    slug: string;
                    website: string;
                    description?: string;
                }
                namespace Tech {
                    interface Category {
                        id: number;
                        groups: Array<number>;
                        name: string;
                        priority: number;
                        slug: string;
                    }
                    interface Evidence {
                        impliedBy: Array<string>;
                        patterns: Array<Evidence.Pattern>;
                    }
                    namespace Evidence {
                        interface Pattern {
                            confidence: number;
                            excludes: Array<string>;
                            implies: Array<string>;
                            match: string;
                            /**
                             * Header or Cookie name when set
                             */
                            name: string;
                            regex: string;
                            type: string;
                            value: string;
                            version: string;
                        }
                    }
                }
            }
        }
        interface Page {
            asn: string;
            asnLocationAlpha2: string;
            asnname: string;
            console: Array<Page.Console>;
            cookies: Array<Page.Cookie>;
            country: string;
            countryLocationAlpha2: string;
            domain: string;
            headers: Array<TopAPI.Browser>;
            ip: string;
            js: Page.JS;
            securityViolations: Array<Page.SecurityViolation>;
            status: number;
            subdivision1Name: string;
            subdivision2name: string;
            url: string;
        }
        namespace Page {
            interface Console {
                category: string;
                text: string;
                type: string;
                url?: string;
            }
            interface Cookie {
                domain: string;
                expires: number;
                httpOnly: boolean;
                name: string;
                path: string;
                sameParty: boolean;
                secure: boolean;
                session: boolean;
                size: number;
                sourcePort: number;
                sourceScheme: string;
                value: string;
                priority?: string;
            }
            interface JS {
                variables: Array<JS.Variable>;
            }
            namespace JS {
                interface Variable {
                    name: string;
                    type: string;
                }
            }
            interface SecurityViolation {
                category: string;
                text: string;
                url: string;
            }
        }
        interface Performance {
            connectEnd: number;
            connectStart: number;
            decodedBodySize: number;
            domainLookupEnd: number;
            domainLookupStart: number;
            domComplete: number;
            domContentLoadedEventEnd: number;
            domContentLoadedEventStart: number;
            domInteractive: number;
            duration: number;
            encodedBodySize: number;
            entryType: string;
            fetchStart: number;
            initiatorType: string;
            loadEventEnd: number;
            loadEventStart: number;
            name: string;
            nextHopProtocol: string;
            redirectCount: number;
            redirectEnd: number;
            redirectStart: number;
            requestStart: number;
            responseEnd: number;
            responseStart: number;
            secureConnectionStart: number;
            startTime: number;
            transferSize: number;
            type: string;
            unloadEventEnd: number;
            unloadEventStart: number;
            workerStart: number;
        }
        interface Task {
            /**
             * Submitter location
             */
            clientLocation: string;
            clientType: 'Site' | 'Automatic' | 'Api';
            /**
             * URL of the primary request, after all HTTP redirects
             */
            effectiveUrl: string;
            errors: Array<Task.Error>;
            scannedFrom: Task.ScannedFrom;
            status: 'Queued' | 'InProgress' | 'InPostProcessing' | 'Finished';
            success: boolean;
            time: string;
            timeEnd: string;
            /**
             * Submitted URL
             */
            url: string;
            /**
             * Scan ID
             */
            uuid: string;
            visibility: 'Public' | 'Unlisted';
        }
        namespace Task {
            interface Error {
                message: string;
            }
            interface ScannedFrom {
                /**
                 * IATA code of Cloudflare datacenter
                 */
                colo: string;
            }
        }
        interface Verdicts {
            overall: Verdicts.Overall;
        }
        namespace Verdicts {
            interface Overall {
                categories: Array<Overall.Category>;
                /**
                 * At least one of our subsystems marked the site as potentially malicious at the
                 * time of the scan.
                 */
                malicious: boolean;
                phishing: Array<string>;
            }
            namespace Overall {
                interface Category {
                    id: number;
                    name: string;
                    super_category_id: number;
                }
            }
        }
        /**
         * Dictionary of Autonomous System Numbers where ASN's are the keys
         */
        interface ASNs {
            /**
             * ASN's contacted
             */
            asn?: ASNs.ASN;
        }
        namespace ASNs {
            /**
             * ASN's contacted
             */
            interface ASN {
                asn: string;
                description: string;
                location_alpha2: string;
                name: string;
                org_name: string;
            }
        }
        interface Domains {
            'example.com'?: Domains.ExampleCom;
        }
        namespace Domains {
            interface ExampleCom {
                categories: ExampleCom.Categories;
                dns: Array<ExampleCom.DNS>;
                name: string;
                rank: ExampleCom.Rank;
                type: string;
            }
            namespace ExampleCom {
                interface Categories {
                    inherited: Categories.Inherited;
                    content?: Array<ScansAPI.URLScannerDomain>;
                    risks?: Array<ScansAPI.URLScannerDomain>;
                }
                namespace Categories {
                    interface Inherited {
                        content?: Array<ScansAPI.URLScannerDomain>;
                        from?: string;
                        risks?: Array<ScansAPI.URLScannerDomain>;
                    }
                }
                interface DNS {
                    address: string;
                    dnssec_valid: boolean;
                    name: string;
                    type: string;
                }
                interface Rank {
                    bucket: string;
                    name: string;
                    /**
                     * Rank in the Global Radar Rank, if set. See more at
                     * https://blog.cloudflare.com/radar-domain-rankings/
                     */
                    rank?: number;
                }
            }
        }
        interface IPs {
            ip?: IPs.IP;
        }
        namespace IPs {
            interface IP {
                asn: string;
                asnDescription: string;
                asnLocationAlpha2: string;
                asnName: string;
                asnOrgName: string;
                continent: string;
                geonameId: string;
                ip: string;
                ipVersion: string;
                latitude: string;
                locationAlpha2: string;
                locationName: string;
                longitude: string;
                subdivision1Name: string;
                subdivision2Name: string;
            }
        }
        interface Links {
            link?: Links.Link;
        }
        namespace Links {
            interface Link {
                /**
                 * Outgoing link detected in the DOM
                 */
                href: string;
                text: string;
            }
        }
    }
}
export interface ScanHarResponse {
    har: ScanHarResponse.Har;
}
export declare namespace ScanHarResponse {
    interface Har {
        log: Har.Log;
    }
    namespace Har {
        interface Log {
            creator: Log.Creator;
            entries: Array<Log.Entry>;
            pages: Array<Log.Page>;
            version: string;
        }
        namespace Log {
            interface Creator {
                comment: string;
                name: string;
                version: string;
            }
            interface Entry {
                _initialPriority: string;
                _initiator_type: string;
                _priority: string;
                _requestId: string;
                _requestTime: number;
                _resourceType: string;
                cache: unknown;
                connection: string;
                pageref: string;
                request: Entry.Request;
                response: Entry.Response;
                serverIPAddress: string;
                startedDateTime: string;
                time: number;
            }
            namespace Entry {
                interface Request {
                    bodySize: number;
                    headers: Array<TopAPI.Browser>;
                    headersSize: number;
                    httpVersion: string;
                    method: string;
                    url: string;
                }
                interface Response {
                    _transferSize: number;
                    bodySize: number;
                    content: Response.Content;
                    headers: Array<TopAPI.Browser>;
                    headersSize: number;
                    httpVersion: string;
                    redirectURL: string;
                    status: number;
                    statusText: string;
                }
                namespace Response {
                    interface Content {
                        mimeType: string;
                        size: number;
                        compression?: number;
                    }
                }
            }
            interface Page {
                id: string;
                pageTimings: Page.PageTimings;
                startedDateTime: string;
                title: string;
            }
            namespace Page {
                interface PageTimings {
                    onContentLoad: number;
                    onLoad: number;
                }
            }
        }
    }
}
export interface ScanCreateParams {
    url: string;
    /**
     * Set custom headers
     */
    customHeaders?: Record<string, string>;
    /**
     * Take multiple screenshots targeting different device types
     */
    screenshotsResolutions?: Array<'desktop' | 'mobile' | 'tablet'>;
    /**
     * 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?: 'Public' | 'Unlisted';
}
export interface ScanScreenshotParams {
    /**
     * Target device type
     */
    resolution?: 'desktop' | 'mobile' | 'tablet';
}
export declare namespace Scans {
    export import URLScannerDomain = ScansAPI.URLScannerDomain;
    export import URLScannerTask = ScansAPI.URLScannerTask;
    export import ScanCreateResponse = ScansAPI.ScanCreateResponse;
    export import ScanGetResponse = ScansAPI.ScanGetResponse;
    export import ScanHarResponse = ScansAPI.ScanHarResponse;
    export import ScanCreateParams = ScansAPI.ScanCreateParams;
    export import ScanScreenshotParams = ScansAPI.ScanScreenshotParams;
}
//# sourceMappingURL=scans.d.ts.map