cloudflare/resources/brand-protection/brand-protection.d.mts

The official TypeScript library for the Cloudflare API

import { APIResource } from "../../core/resource.mjs";
import * as LogoMatchesAPI from "./logo-matches.mjs";
import { BaseLogoMatches, LogoMatchDownloadParams, LogoMatchDownloadResponse, LogoMatchGetParams, LogoMatchGetResponse, LogoMatches } from "./logo-matches.mjs";
import * as LogosAPI from "./logos.mjs";
import { BaseLogos, LogoCreateParams, LogoCreateResponse, LogoDeleteParams, Logos } from "./logos.mjs";
import * as MatchesAPI from "./matches.mjs";
import { BaseMatches, MatchDownloadParams, MatchDownloadResponse, MatchGetParams, MatchGetResponse, Matches } from "./matches.mjs";
import * as QueriesAPI from "./queries.mjs";
import { BaseQueries, Queries, QueryBulkParams, QueryCreateParams, QueryDeleteParams } from "./queries.mjs";
import * as V2API from "./v2/v2.mjs";
import { BaseV2, V2 } from "./v2/v2.mjs";
import { APIPromise } from "../../core/api-promise.mjs";
import { PagePromise, SinglePage } from "../../core/pagination.mjs";
import { RequestOptions } from "../../internal/request-options.mjs";
export declare class BaseBrandProtection extends APIResource {
    static readonly _key: readonly ['brandProtection'];
    /**
     * Return new URL submissions
     */
    submit(params: BrandProtectionSubmitParams, options?: RequestOptions): APIPromise<BrandProtectionSubmitResponse>;
    /**
     * Return submitted URLs based on ID
     */
    urlInfo(params: BrandProtectionURLInfoParams, options?: RequestOptions): PagePromise<BrandProtectionURLInfoResponsesSinglePage, BrandProtectionURLInfoResponse>;
}
export declare class BrandProtection extends BaseBrandProtection {
    queries: QueriesAPI.Queries;
    matches: MatchesAPI.Matches;
    logos: LogosAPI.Logos;
    logoMatches: LogoMatchesAPI.LogoMatches;
    v2: V2API.V2;
}
export type BrandProtectionURLInfoResponsesSinglePage = SinglePage<BrandProtectionURLInfoResponse>;
export interface Info {
    /**
     * List of categorizations applied to this submission.
     */
    categorizations?: Array<Info.Categorization>;
    /**
     * List of model results for completed scans.
     */
    model_results?: Array<Info.ModelResult>;
    /**
     * List of signatures that matched against site content found when crawling the
     * URL.
     */
    rule_matches?: Array<Info.RuleMatch>;
    /**
     * Status of the most recent scan found.
     */
    scan_status?: Info.ScanStatus;
    /**
     * For internal use.
     */
    screenshot_download_signature?: string;
    /**
     * For internal use.
     */
    screenshot_path?: string;
    /**
     * URL that was submitted.
     */
    url?: string;
}
export declare namespace Info {
    interface Categorization {
        /**
         * Name of the category applied.
         */
        category?: string;
        /**
         * Result of human review for this categorization.
         */
        verification_status?: string;
    }
    interface ModelResult {
        /**
         * Name of the model.
         */
        model_name?: string;
        /**
         * This is the score that is outputted by the model for this submission.
         */
        model_score?: number;
    }
    interface RuleMatch {
        /**
         * For internal use.
         */
        banning?: boolean;
        /**
         * For internal use.
         */
        blocking?: boolean;
        /**
         * Description of the signature that matched.
         */
        description?: string;
        /**
         * Name of the signature that matched.
         */
        name?: string;
    }
    /**
     * Status of the most recent scan found.
     */
    interface ScanStatus {
        /**
         * Timestamp of when the submission was processed.
         */
        last_processed?: string;
        /**
         * For internal use.
         */
        scan_complete?: boolean;
        /**
         * Status code that the crawler received when loading the submitted URL.
         */
        status_code?: number;
        /**
         * ID of the most recent submission.
         */
        submission_id?: number;
    }
}
export interface Submit {
    /**
     * URLs that were excluded from scanning because their domain is in our no-scan
     * list.
     */
    excluded_urls?: Array<Submit.ExcludedURL>;
    /**
     * URLs that were skipped because the same URL is currently being scanned.
     */
    skipped_urls?: Array<Submit.SkippedURL>;
    /**
     * URLs that were successfully submitted for scanning.
     */
    submitted_urls?: Array<Submit.SubmittedURL>;
}
export declare namespace Submit {
    interface ExcludedURL {
        /**
         * URL that was excluded.
         */
        url?: string;
    }
    interface SkippedURL {
        /**
         * URL that was skipped.
         */
        url?: string;
        /**
         * ID of the submission of that URL that is currently scanning.
         */
        url_id?: number;
    }
    interface SubmittedURL {
        /**
         * URL that was submitted.
         */
        url?: string;
        /**
         * ID assigned to this URL submission. Used to retrieve scanning results.
         */
        url_id?: number;
    }
}
export interface BrandProtectionSubmitResponse {
    skipped_urls?: Array<{
        [key: string]: unknown;
    }>;
    submitted_urls?: Array<{
        [key: string]: unknown;
    }>;
}
export type BrandProtectionURLInfoResponse = {
    [key: string]: unknown;
};
export interface BrandProtectionSubmitParams {
    account_id: string;
}
export interface BrandProtectionURLInfoParams {
    account_id: string;
}
export declare namespace BrandProtection {
    export { type Info as Info, type Submit as Submit, type BrandProtectionSubmitResponse as BrandProtectionSubmitResponse, type BrandProtectionURLInfoResponse as BrandProtectionURLInfoResponse, type BrandProtectionURLInfoResponsesSinglePage as BrandProtectionURLInfoResponsesSinglePage, type BrandProtectionSubmitParams as BrandProtectionSubmitParams, type BrandProtectionURLInfoParams as BrandProtectionURLInfoParams, };
    export { Queries as Queries, BaseQueries as BaseQueries, type QueryCreateParams as QueryCreateParams, type QueryDeleteParams as QueryDeleteParams, type QueryBulkParams as QueryBulkParams, };
    export { Matches as Matches, BaseMatches as BaseMatches, type MatchDownloadResponse as MatchDownloadResponse, type MatchGetResponse as MatchGetResponse, type MatchDownloadParams as MatchDownloadParams, type MatchGetParams as MatchGetParams, };
    export { Logos as Logos, BaseLogos as BaseLogos, type LogoCreateResponse as LogoCreateResponse, type LogoCreateParams as LogoCreateParams, type LogoDeleteParams as LogoDeleteParams, };
    export { LogoMatches as LogoMatches, BaseLogoMatches as BaseLogoMatches, type LogoMatchDownloadResponse as LogoMatchDownloadResponse, type LogoMatchGetResponse as LogoMatchGetResponse, type LogoMatchDownloadParams as LogoMatchDownloadParams, type LogoMatchGetParams as LogoMatchGetParams, };
    export { V2 as V2, BaseV2 as BaseV2 };
}
//# sourceMappingURL=brand-protection.d.mts.map