/**
 * Cloudflare PAGE-SHIELD API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service page-shield
 */
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 GetConnectionRequest {
    connectionId: string;
    /** Identifier */
    zoneId: string;
}
export declare const GetConnectionRequest: Schema.Schema<GetConnectionRequest>;
export interface GetConnectionResponse {
    /** Identifier */
    id: string;
    addedAt: string;
    firstSeenAt: string;
    host: string;
    lastSeenAt: string;
    url: string;
    urlContainsCdnCgiPath: boolean;
    domainReportedMalicious?: boolean | null;
    firstPageUrl?: string | null;
    maliciousDomainCategories?: string[] | null;
    maliciousUrlCategories?: string[] | null;
    pageUrls?: string[] | null;
    urlReportedMalicious?: boolean | null;
}
export declare const GetConnectionResponse: Schema.Schema<GetConnectionResponse>;
export type GetConnectionError = DefaultErrors;
export declare const getConnection: API.OperationMethod<GetConnectionRequest, GetConnectionResponse, GetConnectionError, Credentials | HttpClient.HttpClient>;
export interface ListConnectionsRequest {
    /** Path param: Identifier */
    zoneId: string;
    /** Query param: The direction used to sort returned connections. */
    direction?: "asc" | "desc";
    /** Query param: When true, excludes connections seen in a `/cdn-cgi` path from the returned connections. The default value is true. */
    excludeCdnCgi?: boolean;
    /** Query param: Excludes connections whose URL contains one of the URL-encoded URLs separated by commas. */
    excludeUrls?: string;
    /** Query param: Export the list of connections as a file, limited to 50000 entries. */
    export?: "csv";
    /** Query param: Includes connections that match one or more URL-encoded hostnames separated by commas.  Wildcards are supported at the start and end of each hostname to support starts with, ends with and */
    hosts?: string;
    /** Query param: The field used to sort returned connections. */
    orderBy?: "first_seen_at" | "last_seen_at";
    /** Query param: The current page number of the paginated results.  We additionally support a special value "all". When "all" is used, the API will return all the connections with the applied filters in a */
    page?: string;
    /** Query param: Includes connections that match one or more page URLs (separated by commas) where they were last seen  Wildcards are supported at the start and end of each page URL to support starts with */
    pageUrl?: string;
    /** Query param: The number of results per page. */
    perPage?: number;
    /** Query param: When true, malicious connections appear first in the returned connections. */
    prioritizeMalicious?: boolean;
    /** Query param: Filters the returned connections using a comma-separated list of connection statuses. Accepted values: `active`, `infrequent`, and `inactive`. The default value is `active`. */
    status?: string;
    /** Query param: Includes connections whose URL contain one or more URL-encoded URLs separated by commas. */
    urls?: string;
}
export declare const ListConnectionsRequest: Schema.Schema<ListConnectionsRequest>;
export interface ListConnectionsResponse {
    result: {
        id: string;
        addedAt: string;
        firstSeenAt: string;
        host: string;
        lastSeenAt: string;
        url: string;
        urlContainsCdnCgiPath: boolean;
        domainReportedMalicious?: boolean | null;
        firstPageUrl?: string | null;
        maliciousDomainCategories?: string[] | null;
        maliciousUrlCategories?: string[] | null;
        pageUrls?: string[] | null;
        urlReportedMalicious?: boolean | null;
    }[];
}
export declare const ListConnectionsResponse: Schema.Schema<ListConnectionsResponse>;
export type ListConnectionsError = DefaultErrors;
export declare const listConnections: API.PaginatedOperationMethod<ListConnectionsRequest, ListConnectionsResponse, ListConnectionsError, Credentials | HttpClient.HttpClient>;
export interface GetCookyRequest {
    cookieId: string;
    /** Identifier */
    zoneId: string;
}
export declare const GetCookyRequest: Schema.Schema<GetCookyRequest>;
export interface GetCookyResponse {
    /** Identifier */
    id: string;
    firstSeenAt: string;
    host: string;
    lastSeenAt: string;
    name: string;
    type: "first_party" | "unknown";
    domainAttribute?: string | null;
    expiresAttribute?: string | null;
    httpOnlyAttribute?: boolean | null;
    maxAgeAttribute?: number | null;
    pageUrls?: string[] | null;
    pathAttribute?: string | null;
    sameSiteAttribute?: "lax" | "strict" | "none" | null;
    secureAttribute?: boolean | null;
}
export declare const GetCookyResponse: Schema.Schema<GetCookyResponse>;
export type GetCookyError = DefaultErrors;
export declare const getCooky: API.OperationMethod<GetCookyRequest, GetCookyResponse, GetCookyError, Credentials | HttpClient.HttpClient>;
export interface ListCookiesRequest {
    /** Path param: Identifier */
    zoneId: string;
    /** Query param: The direction used to sort returned cookies.' */
    direction?: "asc" | "desc";
    /** Query param: Filters the returned cookies that match the specified domain attribute */
    domain?: string;
    /** Query param: Export the list of cookies as a file, limited to 50000 entries. */
    export?: "csv";
    /** Query param: Includes cookies that match one or more URL-encoded hostnames separated by commas.  Wildcards are supported at the start and end of each hostname to support starts with, ends with and con */
    hosts?: string;
    /** Query param: Filters the returned cookies that are set with HttpOnly */
    httpOnly?: boolean;
    /** Query param: Filters the returned cookies that match the specified name. Wildcards are supported at the start and end to support starts with, ends with and contains. e.g. session\ */
    name?: string;
    /** Query param: The field used to sort returned cookies. */
    orderBy?: "first_seen_at" | "last_seen_at";
    /** Query param: The current page number of the paginated results.  We additionally support a special value "all". When "all" is used, the API will return all the cookies with the applied filters in a sin */
    page?: string;
    /** Query param: Includes connections that match one or more page URLs (separated by commas) where they were last seen  Wildcards are supported at the start and end of each page URL to support starts with */
    pageUrl?: string;
    /** Query param: Filters the returned cookies that match the specified path attribute */
    path?: string;
    /** Query param: The number of results per page. */
    perPage?: number;
    /** Query param: Filters the returned cookies that match the specified same_site attribute */
    sameSite?: "lax" | "strict" | "none";
    /** Query param: Filters the returned cookies that are set with Secure */
    secure?: boolean;
    /** Query param: Filters the returned cookies that match the specified type attribute */
    type?: "first_party" | "unknown";
}
export declare const ListCookiesRequest: Schema.Schema<ListCookiesRequest>;
export interface ListCookiesResponse {
    result: {
        id: string;
        firstSeenAt: string;
        host: string;
        lastSeenAt: string;
        name: string;
        type: "first_party" | "unknown";
        domainAttribute?: string | null;
        expiresAttribute?: string | null;
        httpOnlyAttribute?: boolean | null;
        maxAgeAttribute?: number | null;
        pageUrls?: string[] | null;
        pathAttribute?: string | null;
        sameSiteAttribute?: "lax" | "strict" | "none" | null;
        secureAttribute?: boolean | null;
    }[];
}
export declare const ListCookiesResponse: Schema.Schema<ListCookiesResponse>;
export type ListCookiesError = DefaultErrors;
export declare const listCookies: API.PaginatedOperationMethod<ListCookiesRequest, ListCookiesResponse, ListCookiesError, Credentials | HttpClient.HttpClient>;
export interface GetPageShieldRequest {
    /** Identifier */
    zoneId: string;
}
export declare const GetPageShieldRequest: Schema.Schema<GetPageShieldRequest>;
export interface GetPageShieldResponse {
    /** When true, indicates that Page Shield is enabled. */
    enabled: boolean;
    /** The timestamp of when Page Shield was last updated. */
    updatedAt: string;
    /** When true, CSP reports will be sent to https://csp-reporting.cloudflare.com/cdn-cgi/script_monitor/report */
    useCloudflareReportingEndpoint: boolean;
    /** When true, the paths associated with connections URLs will also be analyzed. */
    useConnectionUrlPath: boolean;
}
export declare const GetPageShieldResponse: Schema.Schema<GetPageShieldResponse>;
export type GetPageShieldError = DefaultErrors;
export declare const getPageShield: API.OperationMethod<GetPageShieldRequest, GetPageShieldResponse, GetPageShieldError, Credentials | HttpClient.HttpClient>;
export interface PutPageShieldRequest {
    /** Path param: Identifier */
    zoneId: string;
    /** Body param: When true, indicates that Page Shield is enabled. */
    enabled?: boolean;
    /** Body param: When true, CSP reports will be sent to https://csp-reporting.cloudflare.com/cdn-cgi/script_monitor/report */
    useCloudflareReportingEndpoint?: boolean;
    /** Body param: When true, the paths associated with connections URLs will also be analyzed. */
    useConnectionUrlPath?: boolean;
}
export declare const PutPageShieldRequest: Schema.Schema<PutPageShieldRequest>;
export interface PutPageShieldResponse {
    /** When true, indicates that Page Shield is enabled. */
    enabled: boolean;
    /** The timestamp of when Page Shield was last updated. */
    updatedAt: string;
    /** When true, CSP reports will be sent to https://csp-reporting.cloudflare.com/cdn-cgi/script_monitor/report */
    useCloudflareReportingEndpoint: boolean;
    /** When true, the paths associated with connections URLs will also be analyzed. */
    useConnectionUrlPath: boolean;
}
export declare const PutPageShieldResponse: Schema.Schema<PutPageShieldResponse>;
export type PutPageShieldError = DefaultErrors;
export declare const putPageShield: API.OperationMethod<PutPageShieldRequest, PutPageShieldResponse, PutPageShieldError, Credentials | HttpClient.HttpClient>;
export interface GetPolicyRequest {
    policyId: string;
    /** Identifier */
    zoneId: string;
}
export declare const GetPolicyRequest: Schema.Schema<GetPolicyRequest>;
export interface GetPolicyResponse {
    /** Identifier */
    id: string;
    /** The action to take if the expression matches */
    action: "allow" | "log";
    /** A description for the policy */
    description: string;
    /** Whether the policy is enabled */
    enabled: boolean;
    /** The expression which must match for the policy to be applied, using the Cloudflare Firewall rule expression syntax */
    expression: string;
    /** The policy which will be applied */
    value: string;
}
export declare const GetPolicyResponse: Schema.Schema<GetPolicyResponse>;
export type GetPolicyError = DefaultErrors;
export declare const getPolicy: API.OperationMethod<GetPolicyRequest, GetPolicyResponse, GetPolicyError, Credentials | HttpClient.HttpClient>;
export interface ListPoliciesRequest {
    /** Identifier */
    zoneId: string;
}
export declare const ListPoliciesRequest: Schema.Schema<ListPoliciesRequest>;
export interface ListPoliciesResponse {
    result: {
        id: string;
        action: "allow" | "log";
        description: string;
        enabled: boolean;
        expression: string;
        value: string;
    }[];
}
export declare const ListPoliciesResponse: Schema.Schema<ListPoliciesResponse>;
export type ListPoliciesError = DefaultErrors;
export declare const listPolicies: API.PaginatedOperationMethod<ListPoliciesRequest, ListPoliciesResponse, ListPoliciesError, Credentials | HttpClient.HttpClient>;
export interface CreatePolicyRequest {
    /** Path param: Identifier */
    zoneId: string;
    /** Body param: The action to take if the expression matches */
    action: "allow" | "log";
    /** Body param: A description for the policy */
    description: string;
    /** Body param: Whether the policy is enabled */
    enabled: boolean;
    /** Body param: The expression which must match for the policy to be applied, using the Cloudflare Firewall rule expression syntax */
    expression: string;
    /** Body param: The policy which will be applied */
    value: string;
}
export declare const CreatePolicyRequest: Schema.Schema<CreatePolicyRequest>;
export interface CreatePolicyResponse {
    /** Identifier */
    id: string;
    /** The action to take if the expression matches */
    action: "allow" | "log";
    /** A description for the policy */
    description: string;
    /** Whether the policy is enabled */
    enabled: boolean;
    /** The expression which must match for the policy to be applied, using the Cloudflare Firewall rule expression syntax */
    expression: string;
    /** The policy which will be applied */
    value: string;
}
export declare const CreatePolicyResponse: Schema.Schema<CreatePolicyResponse>;
export type CreatePolicyError = DefaultErrors;
export declare const createPolicy: API.OperationMethod<CreatePolicyRequest, CreatePolicyResponse, CreatePolicyError, Credentials | HttpClient.HttpClient>;
export interface UpdatePolicyRequest {
    policyId: string;
    /** Path param: Identifier */
    zoneId: string;
    /** Body param: The action to take if the expression matches */
    action?: "allow" | "log";
    /** Body param: A description for the policy */
    description?: string;
    /** Body param: Whether the policy is enabled */
    enabled?: boolean;
    /** Body param: The expression which must match for the policy to be applied, using the Cloudflare Firewall rule expression syntax */
    expression?: string;
    /** Body param: The policy which will be applied */
    value?: string;
}
export declare const UpdatePolicyRequest: Schema.Schema<UpdatePolicyRequest>;
export interface UpdatePolicyResponse {
    /** Identifier */
    id: string;
    /** The action to take if the expression matches */
    action: "allow" | "log";
    /** A description for the policy */
    description: string;
    /** Whether the policy is enabled */
    enabled: boolean;
    /** The expression which must match for the policy to be applied, using the Cloudflare Firewall rule expression syntax */
    expression: string;
    /** The policy which will be applied */
    value: string;
}
export declare const UpdatePolicyResponse: Schema.Schema<UpdatePolicyResponse>;
export type UpdatePolicyError = DefaultErrors;
export declare const updatePolicy: API.OperationMethod<UpdatePolicyRequest, UpdatePolicyResponse, UpdatePolicyError, Credentials | HttpClient.HttpClient>;
export interface DeletePolicyRequest {
    policyId: string;
    /** Identifier */
    zoneId: string;
}
export declare const DeletePolicyRequest: Schema.Schema<DeletePolicyRequest>;
export type DeletePolicyResponse = unknown;
export declare const DeletePolicyResponse: Schema.Schema<DeletePolicyResponse>;
export type DeletePolicyError = DefaultErrors;
export declare const deletePolicy: API.OperationMethod<DeletePolicyRequest, DeletePolicyResponse, DeletePolicyError, Credentials | HttpClient.HttpClient>;
export interface GetScriptRequest {
    scriptId: string;
    /** Identifier */
    zoneId: string;
}
export declare const GetScriptRequest: Schema.Schema<GetScriptRequest>;
export interface GetScriptResponse {
    /** Identifier */
    id: string;
    addedAt: string;
    firstSeenAt: string;
    host: string;
    lastSeenAt: string;
    url: string;
    urlContainsCdnCgiPath: boolean;
    /** The cryptomining score of the JavaScript content. */
    cryptominingScore?: number | null;
    /** The dataflow score of the JavaScript content. */
    dataflowScore?: number | null;
    domainReportedMalicious?: boolean | null;
    /** The timestamp of when the script was last fetched. */
    fetchedAt?: string | null;
    firstPageUrl?: string | null;
    /** The computed hash of the analyzed script. */
    hash?: string | null;
    /** The integrity score of the JavaScript content. */
    jsIntegrityScore?: number | null;
    /** The magecart score of the JavaScript content. */
    magecartScore?: number | null;
    maliciousDomainCategories?: string[] | null;
    maliciousUrlCategories?: string[] | null;
    /** The malware score of the JavaScript content. */
    malwareScore?: number | null;
    /** The obfuscation score of the JavaScript content. */
    obfuscationScore?: number | null;
    pageUrls?: string[] | null;
    urlReportedMalicious?: boolean | null;
    versions?: {
        cryptominingScore?: number | null;
        dataflowScore?: number | null;
        fetchedAt?: string | null;
        hash?: string | null;
        jsIntegrityScore?: number | null;
        magecartScore?: number | null;
        malwareScore?: number | null;
        obfuscationScore?: number | null;
    }[] | null;
}
export declare const GetScriptResponse: Schema.Schema<GetScriptResponse>;
export type GetScriptError = DefaultErrors;
export declare const getScript: API.OperationMethod<GetScriptRequest, GetScriptResponse, GetScriptError, Credentials | HttpClient.HttpClient>;
export interface ListScriptsRequest {
    /** Path param: Identifier */
    zoneId: string;
    /** Query param: The direction used to sort returned scripts. */
    direction?: "asc" | "desc";
    /** Query param: When true, excludes scripts seen in a `/cdn-cgi` path from the returned scripts. The default value is true. */
    excludeCdnCgi?: boolean;
    /** Query param: When true, excludes duplicate scripts. We consider a script duplicate of another if their javascript content matches and they share the same url host and zone hostname. In such case, we r */
    excludeDuplicates?: boolean;
    /** Query param: Excludes scripts whose URL contains one of the URL-encoded URLs separated by commas. */
    excludeUrls?: string;
    /** Query param: Export the list of scripts as a file, limited to 50000 entries. */
    export?: "csv";
    /** Query param: Includes scripts that match one or more URL-encoded hostnames separated by commas.  Wildcards are supported at the start and end of each hostname to support starts with, ends with and con */
    hosts?: string;
    /** Query param: The field used to sort returned scripts. */
    orderBy?: "first_seen_at" | "last_seen_at";
    /** Query param: The current page number of the paginated results.  We additionally support a special value "all". When "all" is used, the API will return all the scripts with the applied filters in a sin */
    page?: string;
    /** Query param: Includes scripts that match one or more page URLs (separated by commas) where they were last seen  Wildcards are supported at the start and end of each page URL to support starts with, en */
    pageUrl?: string;
    /** Query param: The number of results per page. */
    perPage?: number;
    /** Query param: When true, malicious scripts appear first in the returned scripts. */
    prioritizeMalicious?: boolean;
    /** Query param: Filters the returned scripts using a comma-separated list of scripts statuses. Accepted values: `active`, `infrequent`, and `inactive`. The default value is `active`. */
    status?: string;
    /** Query param: Includes scripts whose URL contain one or more URL-encoded URLs separated by commas. */
    urls?: string;
}
export declare const ListScriptsRequest: Schema.Schema<ListScriptsRequest>;
export interface ListScriptsResponse {
    result: {
        id: string;
        addedAt: string;
        firstSeenAt: string;
        host: string;
        lastSeenAt: string;
        url: string;
        urlContainsCdnCgiPath: boolean;
        cryptominingScore?: number | null;
        dataflowScore?: number | null;
        domainReportedMalicious?: boolean | null;
        fetchedAt?: string | null;
        firstPageUrl?: string | null;
        hash?: string | null;
        jsIntegrityScore?: number | null;
        magecartScore?: number | null;
        maliciousDomainCategories?: string[] | null;
        maliciousUrlCategories?: string[] | null;
        malwareScore?: number | null;
        obfuscationScore?: number | null;
        pageUrls?: string[] | null;
        urlReportedMalicious?: boolean | null;
    }[];
}
export declare const ListScriptsResponse: Schema.Schema<ListScriptsResponse>;
export type ListScriptsError = DefaultErrors;
export declare const listScripts: API.PaginatedOperationMethod<ListScriptsRequest, ListScriptsResponse, ListScriptsError, Credentials | HttpClient.HttpClient>;
//# sourceMappingURL=page-shield.d.ts.map