/**
 * Cloudflare BRAND-PROTECTION API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service brand-protection
 */
import * as Schema from "effect/Schema";
import type * as HttpClient from "effect/unstable/http/HttpClient";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import { type DefaultErrors } from "../errors.ts";
export interface SubmitBrandProtectionRequest {
    accountId: string;
}
export declare const SubmitBrandProtectionRequest: Schema.Schema<SubmitBrandProtectionRequest>;
export interface SubmitBrandProtectionResponse {
    skippedUrls?: Record<string, unknown>[] | null;
    submittedUrls?: Record<string, unknown>[] | null;
}
export declare const SubmitBrandProtectionResponse: Schema.Schema<SubmitBrandProtectionResponse>;
export type SubmitBrandProtectionError = DefaultErrors;
export declare const submitBrandProtection: API.OperationMethod<SubmitBrandProtectionRequest, SubmitBrandProtectionResponse, SubmitBrandProtectionError, Credentials | HttpClient.HttpClient>;
export interface UrlInfoBrandProtectionRequest {
    accountId: string;
}
export declare const UrlInfoBrandProtectionRequest: Schema.Schema<UrlInfoBrandProtectionRequest>;
export interface UrlInfoBrandProtectionResponse {
    result: Record<string, unknown>[];
}
export declare const UrlInfoBrandProtectionResponse: Schema.Schema<UrlInfoBrandProtectionResponse>;
export type UrlInfoBrandProtectionError = DefaultErrors;
export declare const urlInfoBrandProtection: API.PaginatedOperationMethod<UrlInfoBrandProtectionRequest, UrlInfoBrandProtectionResponse, UrlInfoBrandProtectionError, Credentials | HttpClient.HttpClient>;
export interface CreateLogoRequest {
    /** Path param */
    accountId: string;
    /** Query param */
    matchType?: string;
    /** Query param */
    tag?: string;
    /** Query param */
    threshold?: number;
    /** Body param */
    image?: File | Blob;
}
export declare const CreateLogoRequest: Schema.Schema<CreateLogoRequest>;
export interface CreateLogoResponse {
    id?: number | null;
    tag?: string | null;
    uploadPath?: string | null;
}
export declare const CreateLogoResponse: Schema.Schema<CreateLogoResponse>;
export type CreateLogoError = DefaultErrors;
export declare const createLogo: API.OperationMethod<CreateLogoRequest, CreateLogoResponse, CreateLogoError, Credentials | HttpClient.HttpClient>;
export interface DeleteLogoRequest {
    logoId: string;
    accountId: string;
}
export declare const DeleteLogoRequest: Schema.Schema<DeleteLogoRequest>;
export type DeleteLogoResponse = unknown;
export declare const DeleteLogoResponse: Schema.Schema<DeleteLogoResponse>;
export type DeleteLogoError = DefaultErrors;
export declare const deleteLogo: API.OperationMethod<DeleteLogoRequest, DeleteLogoResponse, DeleteLogoError, Credentials | HttpClient.HttpClient>;
export interface GetLogoMatchRequest {
    /** Path param */
    accountId: string;
    /** Query param */
    limit?: string;
    /** Query param */
    logoId?: string[];
    /** Query param */
    offset?: string;
}
export declare const GetLogoMatchRequest: Schema.Schema<GetLogoMatchRequest>;
export interface GetLogoMatchResponse {
    matches?: Record<string, unknown>[] | null;
    total?: number | null;
}
export declare const GetLogoMatchResponse: Schema.Schema<GetLogoMatchResponse>;
export type GetLogoMatchError = DefaultErrors;
export declare const getLogoMatch: API.OperationMethod<GetLogoMatchRequest, GetLogoMatchResponse, GetLogoMatchError, Credentials | HttpClient.HttpClient>;
export interface DownloadLogoMatchRequest {
    /** Path param */
    accountId: string;
    /** Query param */
    limit?: string;
    /** Query param */
    logoId?: string[];
    /** Query param */
    offset?: string;
}
export declare const DownloadLogoMatchRequest: Schema.Schema<DownloadLogoMatchRequest>;
export interface DownloadLogoMatchResponse {
    matches?: Record<string, unknown>[] | null;
    total?: number | null;
}
export declare const DownloadLogoMatchResponse: Schema.Schema<DownloadLogoMatchResponse>;
export type DownloadLogoMatchError = DefaultErrors;
export declare const downloadLogoMatch: API.OperationMethod<DownloadLogoMatchRequest, DownloadLogoMatchResponse, DownloadLogoMatchError, Credentials | HttpClient.HttpClient>;
export interface GetMatchRequest {
    /** Path param */
    accountId: string;
    /** Query param */
    id?: string;
    /** Query param */
    includeDomainId?: boolean;
    /** Query param */
    limit?: number;
    /** Query param */
    offset?: number;
}
export declare const GetMatchRequest: Schema.Schema<GetMatchRequest>;
export interface GetMatchResponse {
    matches?: Record<string, unknown>[] | null;
    total?: number | null;
}
export declare const GetMatchResponse: Schema.Schema<GetMatchResponse>;
export type GetMatchError = DefaultErrors;
export declare const getMatch: API.OperationMethod<GetMatchRequest, GetMatchResponse, GetMatchError, Credentials | HttpClient.HttpClient>;
export interface DownloadMatchRequest {
    /** Path param */
    accountId: string;
    /** Query param */
    id?: string;
    /** Query param */
    includeDomainId?: boolean;
    /** Query param */
    limit?: number;
    /** Query param */
    offset?: number;
}
export declare const DownloadMatchRequest: Schema.Schema<DownloadMatchRequest>;
export interface DownloadMatchResponse {
    matches?: Record<string, unknown>[] | null;
    total?: number | null;
}
export declare const DownloadMatchResponse: Schema.Schema<DownloadMatchResponse>;
export type DownloadMatchError = DefaultErrors;
export declare const downloadMatch: API.OperationMethod<DownloadMatchRequest, DownloadMatchResponse, DownloadMatchError, Credentials | HttpClient.HttpClient>;
export interface CreateQueryRequest {
    /** Path param */
    accountId: string;
    /** Query param */
    id?: string;
    /** Query param */
    queryScan?: boolean;
    /** Query param */
    queryTag?: string;
    /** Body param */
    maxTime?: string | null;
    /** Body param */
    minTime?: string | null;
    /** Body param */
    bodyScan?: boolean;
    /** Body param */
    stringMatches?: unknown;
    /** Body param */
    bodyTag?: string;
}
export declare const CreateQueryRequest: Schema.Schema<CreateQueryRequest>;
export type CreateQueryResponse = unknown;
export declare const CreateQueryResponse: Schema.Schema<CreateQueryResponse>;
export type CreateQueryError = DefaultErrors;
export declare const createQuery: API.OperationMethod<CreateQueryRequest, CreateQueryResponse, CreateQueryError, Credentials | HttpClient.HttpClient>;
export interface DeleteQueryRequest {
    /** Path param */
    accountId: string;
    /** Query param */
    id?: string;
    /** Query param */
    scan?: boolean;
    /** Query param */
    tag?: string;
}
export declare const DeleteQueryRequest: Schema.Schema<DeleteQueryRequest>;
export type DeleteQueryResponse = unknown;
export declare const DeleteQueryResponse: Schema.Schema<DeleteQueryResponse>;
export type DeleteQueryError = DefaultErrors;
export declare const deleteQuery: API.OperationMethod<DeleteQueryRequest, DeleteQueryResponse, DeleteQueryError, Credentials | HttpClient.HttpClient>;
export interface BulkQueryRequest {
    /** Path param */
    accountId: string;
    /** Body param */
    queries?: Record<string, unknown>[];
}
export declare const BulkQueryRequest: Schema.Schema<BulkQueryRequest>;
export type BulkQueryResponse = unknown;
export declare const BulkQueryResponse: Schema.Schema<BulkQueryResponse>;
export type BulkQueryError = DefaultErrors;
export declare const bulkQuery: API.OperationMethod<BulkQueryRequest, BulkQueryResponse, BulkQueryError, Credentials | HttpClient.HttpClient>;
export interface GetV2LogoRequest {
    /** Path param */
    accountId: string;
    /** Query param: Optional query ID to retrieve a specific logo query */
    id?: string;
    /** Query param: If true, include base64-encoded image data in the response */
    download?: string;
}
export declare const GetV2LogoRequest: Schema.Schema<GetV2LogoRequest>;
export type GetV2LogoResponse = {
    id: number;
    r2Path: string;
    similarityThreshold: number;
    tag: string;
    uploadedAt: string | null;
    contentType?: string | null;
    imageData?: string | null;
}[];
export declare const GetV2LogoResponse: Schema.Schema<GetV2LogoResponse>;
export type GetV2LogoError = DefaultErrors;
export declare const getV2Logo: API.OperationMethod<GetV2LogoRequest, GetV2LogoResponse, GetV2LogoError, Credentials | HttpClient.HttpClient>;
export interface CreateV2LogoRequest {
    /** Path param */
    accountId: string;
    /** Body param: Base64 encoded image data. Can include data URI prefix (e.g., 'data:image/png;base64,...') or just the base64 string. */
    imageData: string;
    /** Body param: Minimum similarity score (0-1) required for visual matches */
    similarityThreshold: number;
    /** Body param: Unique identifier for the logo query */
    tag: string;
    /** Body param: If true, search historic scanned images for matches above the similarity threshold */
    searchLookback?: boolean;
}
export declare const CreateV2LogoRequest: Schema.Schema<CreateV2LogoRequest>;
export interface CreateV2LogoResponse {
    message: string;
    success: boolean;
    queryId?: number | null;
}
export declare const CreateV2LogoResponse: Schema.Schema<CreateV2LogoResponse>;
export type CreateV2LogoError = DefaultErrors;
export declare const createV2Logo: API.OperationMethod<CreateV2LogoRequest, CreateV2LogoResponse, CreateV2LogoError, Credentials | HttpClient.HttpClient>;
export interface DeleteV2LogoRequest {
    queryId: string;
    accountId: string;
}
export declare const DeleteV2LogoRequest: Schema.Schema<DeleteV2LogoRequest>;
export interface DeleteV2LogoResponse {
    message: string;
    success: boolean;
}
export declare const DeleteV2LogoResponse: Schema.Schema<DeleteV2LogoResponse>;
export type DeleteV2LogoError = DefaultErrors;
export declare const deleteV2Logo: API.OperationMethod<DeleteV2LogoRequest, DeleteV2LogoResponse, DeleteV2LogoError, Credentials | HttpClient.HttpClient>;
export interface GetV2LogoMatchRequest {
    /** Path param */
    accountId: string;
    /** Query param */
    queryId: string;
    /** Query param */
    download?: string;
    /** Query param */
    limit?: string;
    /** Query param */
    offset?: string;
    /** Query param: Sort order. Options: 'asc' (ascending) or 'desc' (descending) */
    order?: "asc" | "desc" | (string & {});
    /** Query param: Column to sort by. Options: 'matchedAt', 'domain', 'similarityScore', or 'registrar' */
    orderBy?: "matchedAt" | "domain" | "similarityScore" | "registrar" | (string & {});
}
export declare const GetV2LogoMatchRequest: Schema.Schema<GetV2LogoMatchRequest>;
export interface GetV2LogoMatchResponse {
    matches: {
        id: number;
        domain: string | null;
        matchedAt: string | null;
        queryId: number;
        registrar: string | null;
        similarityScore: number;
        urlScanId: string | null;
        contentType?: string | null;
        imageData?: string | null;
    }[];
    total: number;
}
export declare const GetV2LogoMatchResponse: Schema.Schema<GetV2LogoMatchResponse>;
export type GetV2LogoMatchError = DefaultErrors;
export declare const getV2LogoMatch: API.OperationMethod<GetV2LogoMatchRequest, GetV2LogoMatchResponse, GetV2LogoMatchError, Credentials | HttpClient.HttpClient>;
export interface GetV2MatchRequest {
    /** Path param */
    accountId: string;
    /** Query param: Query ID or comma-separated list of Query IDs. When multiple IDs are provided, matches are deduplicated across queries and each match includes a match_details array with per-match query m */
    queryId: string[];
    /** Query param: Filter matches by domain name (substring match) */
    domainSearch?: string;
    /** Query param */
    includeDismissed?: string;
    /** Query param */
    includeDomainId?: string;
    /** Query param */
    limit?: string;
    /** Query param */
    offset?: string;
    /** Query param: Sort order. Options: 'asc' (ascending) or 'desc' (descending) */
    order?: "asc" | "desc" | (string & {});
    /** Query param: Column to sort by. Options: 'domain', 'first_seen', or 'registrar' */
    orderBy?: "domain" | "first_seen" | "registrar" | (string & {});
}
export declare const GetV2MatchRequest: Schema.Schema<GetV2MatchRequest>;
export interface GetV2MatchResponse {
    matches: {
        domain: string;
        firstSeen: string;
        publicScans: {
            submissionId: string;
        } | null;
        registrar: string | null;
        scanStatus: string;
        scanSubmissionId: number | null;
        source: string | null;
        dismissed?: boolean | null;
        matchDetails?: {
            dismissed: boolean;
            matchId: number;
            queryId: number;
            queryTag: string | null;
        }[] | null;
    }[];
    total: number;
}
export declare const GetV2MatchResponse: Schema.Schema<GetV2MatchResponse>;
export type GetV2MatchError = DefaultErrors;
export declare const getV2Match: API.OperationMethod<GetV2MatchRequest, GetV2MatchResponse, GetV2MatchError, Credentials | HttpClient.HttpClient>;
export interface GetV2QueryRequest {
    /** Path param */
    accountId: string;
    /** Query param */
    id?: string;
}
export declare const GetV2QueryRequest: Schema.Schema<GetV2QueryRequest>;
export type GetV2QueryResponse = {
    created: string;
    parameters: {
        stringMatches: {
            maxEditDistance: number;
            pattern: string;
        }[];
        maxTime?: string | null;
        minTime?: string | null;
    } | null;
    queryId: number;
    queryTag: string;
    scan: boolean;
    updated: string;
}[];
export declare const GetV2QueryResponse: Schema.Schema<GetV2QueryResponse>;
export type GetV2QueryError = DefaultErrors;
export declare const getV2Query: API.OperationMethod<GetV2QueryRequest, GetV2QueryResponse, GetV2QueryError, Credentials | HttpClient.HttpClient>;
//# sourceMappingURL=brand-protection.d.ts.map