/**
 * Cloudflare FIREWALL API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service firewall
 */
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";
interface GetAccessRuleBaseRequest {
    ruleId: string;
}
export interface GetAccessRuleForAccountRequest extends GetAccessRuleBaseRequest {
    /** Path param: The Account ID to use for this endpoint. */
    accountId: string;
}
export interface GetAccessRuleForZoneRequest extends GetAccessRuleBaseRequest {
    /** Path param: The Zone ID to use for this endpoint. */
    zoneId: string;
}
export declare const GetAccessRuleForAccountRequest: Schema.Schema<GetAccessRuleForAccountRequest>;
export declare const GetAccessRuleForZoneRequest: Schema.Schema<GetAccessRuleForZoneRequest>;
export interface GetAccessRuleResponse {
    /** The unique identifier of the IP Access rule. */
    id: string;
    /** The available actions that a rule can apply to a matched request. */
    allowedModes: ("block" | "challenge" | "whitelist" | "js_challenge" | "managed_challenge")[];
    /** The rule configuration. */
    configuration: {
        target?: "ip" | null;
        value?: string | null;
    } | {
        target?: "ip6" | null;
        value?: string | null;
    } | {
        target?: "ip_range" | null;
        value?: string | null;
    } | {
        target?: "asn" | null;
        value?: string | null;
    } | {
        target?: "country" | null;
        value?: string | null;
    };
    /** The action to apply to a matched request. */
    mode: "block" | "challenge" | "whitelist" | "js_challenge" | "managed_challenge";
    /** The timestamp of when the rule was created. */
    createdOn?: string | null;
    /** The timestamp of when the rule was last modified. */
    modifiedOn?: string | null;
    /** An informative summary of the rule, typically used as a reminder or explanation. */
    notes?: string | null;
    /** All zones owned by the user will have the rule applied. */
    scope?: {
        id?: string | null;
        email?: string | null;
        type?: "user" | "organization" | null;
    } | null;
}
export declare const GetAccessRuleResponse: Schema.Schema<GetAccessRuleResponse>;
export type GetAccessRuleError = DefaultErrors;
export declare const getAccessRuleForAccount: API.OperationMethod<GetAccessRuleForAccountRequest, GetAccessRuleResponse, GetAccessRuleError, Credentials | HttpClient.HttpClient>;
export declare const getAccessRuleForZone: API.OperationMethod<GetAccessRuleForZoneRequest, GetAccessRuleResponse, GetAccessRuleError, Credentials | HttpClient.HttpClient>;
interface ListAccessRulesBaseRequest {
}
export interface ListAccessRulesForAccountRequest extends ListAccessRulesBaseRequest {
    /** Path param: The Account ID to use for this endpoint. */
    accountId: string;
}
export interface ListAccessRulesForZoneRequest extends ListAccessRulesBaseRequest {
    /** Path param: The Zone ID to use for this endpoint. */
    zoneId: string;
}
export declare const ListAccessRulesForAccountRequest: Schema.Schema<ListAccessRulesForAccountRequest>;
export declare const ListAccessRulesForZoneRequest: Schema.Schema<ListAccessRulesForZoneRequest>;
export interface ListAccessRulesResponse {
    result: {
        id: string;
        allowedModes: ("block" | "challenge" | "whitelist" | "js_challenge" | "managed_challenge")[];
        configuration: {
            target?: "ip" | null;
            value?: string | null;
        } | {
            target?: "ip6" | null;
            value?: string | null;
        } | {
            target?: "ip_range" | null;
            value?: string | null;
        } | {
            target?: "asn" | null;
            value?: string | null;
        } | {
            target?: "country" | null;
            value?: string | null;
        };
        mode: "block" | "challenge" | "whitelist" | "js_challenge" | "managed_challenge";
        createdOn?: string | null;
        modifiedOn?: string | null;
        notes?: string | null;
        scope?: {
            id?: string | null;
            email?: string | null;
            type?: "user" | "organization" | null;
        } | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListAccessRulesResponse: Schema.Schema<ListAccessRulesResponse>;
export type ListAccessRulesError = DefaultErrors;
export declare const listAccessRulesForAccount: API.PaginatedOperationMethod<ListAccessRulesForAccountRequest, ListAccessRulesResponse, ListAccessRulesError, Credentials | HttpClient.HttpClient>;
export declare const listAccessRulesForZone: API.PaginatedOperationMethod<ListAccessRulesForZoneRequest, ListAccessRulesResponse, ListAccessRulesError, Credentials | HttpClient.HttpClient>;
interface CreateAccessRuleBaseRequest {
    /** Body param: The rule configuration. */
    configuration: {
        target?: "ip";
        value?: string;
    } | {
        target?: "ip6";
        value?: string;
    } | {
        target?: "ip_range";
        value?: string;
    } | {
        target?: "asn";
        value?: string;
    } | {
        target?: "country";
        value?: string;
    };
    /** Body param: The action to apply to a matched request. */
    mode: "block" | "challenge" | "whitelist" | "js_challenge" | "managed_challenge";
    /** Body param: An informative summary of the rule, typically used as a reminder or explanation. */
    notes?: string;
}
export interface CreateAccessRuleForAccountRequest extends CreateAccessRuleBaseRequest {
    /** Path param: The Account ID to use for this endpoint. */
    accountId: string;
}
export interface CreateAccessRuleForZoneRequest extends CreateAccessRuleBaseRequest {
    /** Path param: The Zone ID to use for this endpoint. */
    zoneId: string;
}
export declare const CreateAccessRuleForAccountRequest: Schema.Schema<CreateAccessRuleForAccountRequest>;
export declare const CreateAccessRuleForZoneRequest: Schema.Schema<CreateAccessRuleForZoneRequest>;
export interface CreateAccessRuleResponse {
    /** The unique identifier of the IP Access rule. */
    id: string;
    /** The available actions that a rule can apply to a matched request. */
    allowedModes: ("block" | "challenge" | "whitelist" | "js_challenge" | "managed_challenge")[];
    /** The rule configuration. */
    configuration: {
        target?: "ip" | null;
        value?: string | null;
    } | {
        target?: "ip6" | null;
        value?: string | null;
    } | {
        target?: "ip_range" | null;
        value?: string | null;
    } | {
        target?: "asn" | null;
        value?: string | null;
    } | {
        target?: "country" | null;
        value?: string | null;
    };
    /** The action to apply to a matched request. */
    mode: "block" | "challenge" | "whitelist" | "js_challenge" | "managed_challenge";
    /** The timestamp of when the rule was created. */
    createdOn?: string | null;
    /** The timestamp of when the rule was last modified. */
    modifiedOn?: string | null;
    /** An informative summary of the rule, typically used as a reminder or explanation. */
    notes?: string | null;
    /** All zones owned by the user will have the rule applied. */
    scope?: {
        id?: string | null;
        email?: string | null;
        type?: "user" | "organization" | null;
    } | null;
}
export declare const CreateAccessRuleResponse: Schema.Schema<CreateAccessRuleResponse>;
export type CreateAccessRuleError = DefaultErrors;
export declare const createAccessRuleForAccount: API.OperationMethod<CreateAccessRuleForAccountRequest, CreateAccessRuleResponse, CreateAccessRuleError, Credentials | HttpClient.HttpClient>;
export declare const createAccessRuleForZone: API.OperationMethod<CreateAccessRuleForZoneRequest, CreateAccessRuleResponse, CreateAccessRuleError, Credentials | HttpClient.HttpClient>;
interface PatchAccessRuleBaseRequest {
    ruleId: string;
    /** Body param: The rule configuration. */
    configuration: {
        target?: "ip";
        value?: string;
    } | {
        target?: "ip6";
        value?: string;
    } | {
        target?: "ip_range";
        value?: string;
    } | {
        target?: "asn";
        value?: string;
    } | {
        target?: "country";
        value?: string;
    };
    /** Body param: The action to apply to a matched request. */
    mode: "block" | "challenge" | "whitelist" | "js_challenge" | "managed_challenge";
    /** Body param: An informative summary of the rule, typically used as a reminder or explanation. */
    notes?: string;
}
export interface PatchAccessRuleForAccountRequest extends PatchAccessRuleBaseRequest {
    /** Path param: The Account ID to use for this endpoint. */
    accountId: string;
}
export interface PatchAccessRuleForZoneRequest extends PatchAccessRuleBaseRequest {
    /** Path param: The Zone ID to use for this endpoint. */
    zoneId: string;
}
export declare const PatchAccessRuleForAccountRequest: Schema.Schema<PatchAccessRuleForAccountRequest>;
export declare const PatchAccessRuleForZoneRequest: Schema.Schema<PatchAccessRuleForZoneRequest>;
export interface PatchAccessRuleResponse {
    /** The unique identifier of the IP Access rule. */
    id: string;
    /** The available actions that a rule can apply to a matched request. */
    allowedModes: ("block" | "challenge" | "whitelist" | "js_challenge" | "managed_challenge")[];
    /** The rule configuration. */
    configuration: {
        target?: "ip" | null;
        value?: string | null;
    } | {
        target?: "ip6" | null;
        value?: string | null;
    } | {
        target?: "ip_range" | null;
        value?: string | null;
    } | {
        target?: "asn" | null;
        value?: string | null;
    } | {
        target?: "country" | null;
        value?: string | null;
    };
    /** The action to apply to a matched request. */
    mode: "block" | "challenge" | "whitelist" | "js_challenge" | "managed_challenge";
    /** The timestamp of when the rule was created. */
    createdOn?: string | null;
    /** The timestamp of when the rule was last modified. */
    modifiedOn?: string | null;
    /** An informative summary of the rule, typically used as a reminder or explanation. */
    notes?: string | null;
    /** All zones owned by the user will have the rule applied. */
    scope?: {
        id?: string | null;
        email?: string | null;
        type?: "user" | "organization" | null;
    } | null;
}
export declare const PatchAccessRuleResponse: Schema.Schema<PatchAccessRuleResponse>;
export type PatchAccessRuleError = DefaultErrors;
export declare const patchAccessRuleForAccount: API.OperationMethod<PatchAccessRuleForAccountRequest, PatchAccessRuleResponse, PatchAccessRuleError, Credentials | HttpClient.HttpClient>;
export declare const patchAccessRuleForZone: API.OperationMethod<PatchAccessRuleForZoneRequest, PatchAccessRuleResponse, PatchAccessRuleError, Credentials | HttpClient.HttpClient>;
interface DeleteAccessRuleBaseRequest {
    ruleId: string;
}
export interface DeleteAccessRuleForAccountRequest extends DeleteAccessRuleBaseRequest {
    /** Path param: The Account ID to use for this endpoint. */
    accountId: string;
}
export interface DeleteAccessRuleForZoneRequest extends DeleteAccessRuleBaseRequest {
    /** Path param: The Zone ID to use for this endpoint. */
    zoneId: string;
}
export declare const DeleteAccessRuleForAccountRequest: Schema.Schema<DeleteAccessRuleForAccountRequest>;
export declare const DeleteAccessRuleForZoneRequest: Schema.Schema<DeleteAccessRuleForZoneRequest>;
export interface DeleteAccessRuleResponse {
    /** Defines an identifier. */
    id: string;
}
export declare const DeleteAccessRuleResponse: Schema.Schema<DeleteAccessRuleResponse>;
export type DeleteAccessRuleError = DefaultErrors;
export declare const deleteAccessRuleForAccount: API.OperationMethod<DeleteAccessRuleForAccountRequest, DeleteAccessRuleResponse, DeleteAccessRuleError, Credentials | HttpClient.HttpClient>;
export declare const deleteAccessRuleForZone: API.OperationMethod<DeleteAccessRuleForZoneRequest, DeleteAccessRuleResponse, DeleteAccessRuleError, Credentials | HttpClient.HttpClient>;
export interface GetLockdownRequest {
    lockDownsId: string;
    /** Defines an identifier. */
    zoneId: string;
}
export declare const GetLockdownRequest: Schema.Schema<GetLockdownRequest>;
export interface GetLockdownResponse {
    /** The unique identifier of the Zone Lockdown rule. */
    id: string;
    /** A list of IP addresses or CIDR ranges that will be allowed to access the URLs specified in the Zone Lockdown rule. You can include any number of `ip` or `ip_range` configurations. */
    configurations: ({
        target?: "ip" | null;
        value?: string | null;
    } | {
        target?: "ip_range" | null;
        value?: string | null;
    })[];
    /** The timestamp of when the rule was created. */
    createdOn: string;
    /** An informative summary of the rule. */
    description: string;
    /** The timestamp of when the rule was last modified. */
    modifiedOn: string;
    /** When true, indicates that the rule is currently paused. */
    paused: boolean;
    /** The URLs to include in the rule definition. You can use wildcards. Each entered URL will be escaped before use, which means you can only use simple wildcard patterns. */
    urls: string[];
}
export declare const GetLockdownResponse: Schema.Schema<GetLockdownResponse>;
export type GetLockdownError = DefaultErrors;
export declare const getLockdown: API.OperationMethod<GetLockdownRequest, GetLockdownResponse, GetLockdownError, Credentials | HttpClient.HttpClient>;
export interface ListLockdownsRequest {
    /** Path param: Defines an identifier. */
    zoneId: string;
    page?: number;
    perPage?: number;
    /** Query param: The timestamp of when the rule was created. */
    createdOn?: string;
    /** Query param: A string to search for in the description of existing rules. */
    description?: string;
    /** Query param: A string to search for in the description of existing rules. */
    descriptionSearch?: string;
    /** Query param: A single IP address to search for in existing rules. */
    ip?: string;
    /** Query param: A single IP address range to search for in existing rules. */
    ipRangeSearch?: string;
    /** Query param: A single IP address to search for in existing rules. */
    ipSearch?: string;
    /** Query param: The timestamp of when the rule was last modified. */
    modifiedOn?: string;
    /** Query param: The priority of the rule to control the processing order. A lower number indicates higher priority. If not provided, any rules with a configured priority will be processed before rules wi */
    priority?: number;
    /** Query param: A single URI to search for in the list of URLs of existing rules. */
    uriSearch?: string;
}
export declare const ListLockdownsRequest: Schema.Schema<ListLockdownsRequest>;
export interface ListLockdownsResponse {
    result: {
        id: string;
        configurations: ({
            target?: "ip" | null;
            value?: string | null;
        } | {
            target?: "ip_range" | null;
            value?: string | null;
        })[];
        createdOn: string;
        description: string;
        modifiedOn: string;
        paused: boolean;
        urls: string[];
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListLockdownsResponse: Schema.Schema<ListLockdownsResponse>;
export type ListLockdownsError = DefaultErrors;
export declare const listLockdowns: API.PaginatedOperationMethod<ListLockdownsRequest, ListLockdownsResponse, ListLockdownsError, Credentials | HttpClient.HttpClient>;
export interface CreateLockdownRequest {
    /** Path param: Defines an identifier. */
    zoneId: string;
    /** Body param: A list of IP addresses or CIDR ranges that will be allowed to access the URLs specified in the Zone Lockdown rule. You can include any number of `ip` or `ip_range` configurations. */
    configurations: ({
        target?: "ip";
        value?: string;
    } | {
        target?: "ip_range";
        value?: string;
    })[];
    /** Body param: The URLs to include in the current WAF override. You can use wildcards. Each entered URL will be escaped before use, which means you can only use simple wildcard patterns. */
    urls: string[];
    /** Body param: An informative summary of the rule. This value is sanitized and any tags will be removed. */
    description?: string;
    /** Body param: When true, indicates that the rule is currently paused. */
    paused?: boolean;
    /** Body param: The priority of the rule to control the processing order. A lower number indicates higher priority. If not provided, any rules with a configured priority will be processed before rules wit */
    priority?: number;
}
export declare const CreateLockdownRequest: Schema.Schema<CreateLockdownRequest>;
export interface CreateLockdownResponse {
    /** The unique identifier of the Zone Lockdown rule. */
    id: string;
    /** A list of IP addresses or CIDR ranges that will be allowed to access the URLs specified in the Zone Lockdown rule. You can include any number of `ip` or `ip_range` configurations. */
    configurations: ({
        target?: "ip" | null;
        value?: string | null;
    } | {
        target?: "ip_range" | null;
        value?: string | null;
    })[];
    /** The timestamp of when the rule was created. */
    createdOn: string;
    /** An informative summary of the rule. */
    description: string;
    /** The timestamp of when the rule was last modified. */
    modifiedOn: string;
    /** When true, indicates that the rule is currently paused. */
    paused: boolean;
    /** The URLs to include in the rule definition. You can use wildcards. Each entered URL will be escaped before use, which means you can only use simple wildcard patterns. */
    urls: string[];
}
export declare const CreateLockdownResponse: Schema.Schema<CreateLockdownResponse>;
export type CreateLockdownError = DefaultErrors;
export declare const createLockdown: API.OperationMethod<CreateLockdownRequest, CreateLockdownResponse, CreateLockdownError, Credentials | HttpClient.HttpClient>;
export interface UpdateLockdownRequest {
    lockDownsId: string;
    /** Path param: Defines an identifier. */
    zoneId: string;
    /** Body param: A list of IP addresses or CIDR ranges that will be allowed to access the URLs specified in the Zone Lockdown rule. You can include any number of `ip` or `ip_range` configurations. */
    configurations: ({
        target?: "ip";
        value?: string;
    } | {
        target?: "ip_range";
        value?: string;
    })[];
    /** Body param: The URLs to include in the current WAF override. You can use wildcards. Each entered URL will be escaped before use, which means you can only use simple wildcard patterns. */
    urls: string[];
}
export declare const UpdateLockdownRequest: Schema.Schema<UpdateLockdownRequest>;
export interface UpdateLockdownResponse {
    /** The unique identifier of the Zone Lockdown rule. */
    id: string;
    /** A list of IP addresses or CIDR ranges that will be allowed to access the URLs specified in the Zone Lockdown rule. You can include any number of `ip` or `ip_range` configurations. */
    configurations: ({
        target?: "ip" | null;
        value?: string | null;
    } | {
        target?: "ip_range" | null;
        value?: string | null;
    })[];
    /** The timestamp of when the rule was created. */
    createdOn: string;
    /** An informative summary of the rule. */
    description: string;
    /** The timestamp of when the rule was last modified. */
    modifiedOn: string;
    /** When true, indicates that the rule is currently paused. */
    paused: boolean;
    /** The URLs to include in the rule definition. You can use wildcards. Each entered URL will be escaped before use, which means you can only use simple wildcard patterns. */
    urls: string[];
}
export declare const UpdateLockdownResponse: Schema.Schema<UpdateLockdownResponse>;
export type UpdateLockdownError = DefaultErrors;
export declare const updateLockdown: API.OperationMethod<UpdateLockdownRequest, UpdateLockdownResponse, UpdateLockdownError, Credentials | HttpClient.HttpClient>;
export interface DeleteLockdownRequest {
    lockDownsId: string;
    /** Defines an identifier. */
    zoneId: string;
}
export declare const DeleteLockdownRequest: Schema.Schema<DeleteLockdownRequest>;
export interface DeleteLockdownResponse {
    /** The unique identifier of the Zone Lockdown rule. */
    id?: string | null;
}
export declare const DeleteLockdownResponse: Schema.Schema<DeleteLockdownResponse>;
export type DeleteLockdownError = DefaultErrors;
export declare const deleteLockdown: API.OperationMethod<DeleteLockdownRequest, DeleteLockdownResponse, DeleteLockdownError, Credentials | HttpClient.HttpClient>;
export interface BulkPutRulesRequest {
    /** Path param: Defines an identifier. */
    zoneId: string;
    /** Body param: */
    body: unknown;
}
export declare const BulkPutRulesRequest: Schema.Schema<BulkPutRulesRequest>;
export interface BulkPutRulesResponse {
    result: {
        id?: string | null;
        action?: "block" | "challenge" | "js_challenge" | "managed_challenge" | "allow" | "log" | "bypass" | null;
        description?: string | null;
        filter?: {
            id?: string | null;
            description?: string | null;
            expression?: string | null;
            paused?: boolean | null;
            ref?: string | null;
        } | {
            id: string;
            deleted: boolean;
        } | null;
        paused?: boolean | null;
        priority?: number | null;
        products?: ("zoneLockdown" | "uaBlock" | "bic" | "hot" | "securityLevel" | "rateLimit" | "waf")[] | null;
        ref?: string | null;
    }[];
}
export declare const BulkPutRulesResponse: Schema.Schema<BulkPutRulesResponse>;
export type BulkPutRulesError = DefaultErrors;
export declare const bulkPutRules: API.PaginatedOperationMethod<BulkPutRulesRequest, BulkPutRulesResponse, BulkPutRulesError, Credentials | HttpClient.HttpClient>;
export interface GetRuleRequest {
    ruleId: string;
    /** Defines an identifier. */
    zoneId: string;
}
export declare const GetRuleRequest: Schema.Schema<GetRuleRequest>;
export interface GetRuleResponse {
    /** The unique identifier of the firewall rule. */
    id?: string | null;
    /** The action to apply to a matched request. The `log` action is only available on an Enterprise plan. */
    action?: "block" | "challenge" | "js_challenge" | "managed_challenge" | "allow" | "log" | "bypass" | null;
    /** An informative summary of the firewall rule. */
    description?: string | null;
    filter?: {
        id?: string | null;
        description?: string | null;
        expression?: string | null;
        paused?: boolean | null;
        ref?: string | null;
    } | {
        id: string;
        deleted: boolean;
    } | null;
    /** When true, indicates that the firewall rule is currently paused. */
    paused?: boolean | null;
    /** The priority of the rule. Optional value used to define the processing order. A lower number indicates a higher priority. If not provided, rules with a defined priority will be processed before rules  */
    priority?: number | null;
    products?: ("zoneLockdown" | "uaBlock" | "bic" | "hot" | "securityLevel" | "rateLimit" | "waf")[] | null;
    /** A short reference tag. Allows you to select related firewall rules. */
    ref?: string | null;
}
export declare const GetRuleResponse: Schema.Schema<GetRuleResponse>;
export type GetRuleError = DefaultErrors;
export declare const getRule: API.OperationMethod<GetRuleRequest, GetRuleResponse, GetRuleError, Credentials | HttpClient.HttpClient>;
export interface ListRulesRequest {
    /** Path param: Defines an identifier. */
    zoneId: string;
    page?: number;
    perPage?: number;
    /** Query param: The unique identifier of the firewall rule. */
    id?: string;
    /** Query param: The action to search for. Must be an exact match. */
    action?: string;
    /** Query param: A case-insensitive string to find in the description. */
    description?: string;
    /** Query param: When true, indicates that the firewall rule is currently paused. */
    paused?: boolean;
}
export declare const ListRulesRequest: Schema.Schema<ListRulesRequest>;
export interface ListRulesResponse {
    result: {
        id?: string | null;
        action?: "block" | "challenge" | "js_challenge" | "managed_challenge" | "allow" | "log" | "bypass" | null;
        description?: string | null;
        filter?: {
            id?: string | null;
            description?: string | null;
            expression?: string | null;
            paused?: boolean | null;
            ref?: string | null;
        } | {
            id: string;
            deleted: boolean;
        } | null;
        paused?: boolean | null;
        priority?: number | null;
        products?: ("zoneLockdown" | "uaBlock" | "bic" | "hot" | "securityLevel" | "rateLimit" | "waf")[] | null;
        ref?: string | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListRulesResponse: Schema.Schema<ListRulesResponse>;
export type ListRulesError = DefaultErrors;
export declare const listRules: API.PaginatedOperationMethod<ListRulesRequest, ListRulesResponse, ListRulesError, Credentials | HttpClient.HttpClient>;
export interface CreateRuleRequest {
    /** Path param: Defines an identifier. */
    zoneId: string;
    /** Body param: The action to perform when the threshold of matched traffic within the configured period is exceeded. */
    action: {
        mode?: "simulate" | "ban" | "challenge" | "js_challenge" | "managed_challenge";
        response?: {
            body?: string;
            contentType?: string;
        };
        timeout?: number;
    };
    /** Body param: */
    filter: {
        description?: string;
        expression?: string;
        paused?: boolean;
        ref?: string;
    };
}
export declare const CreateRuleRequest: Schema.Schema<CreateRuleRequest>;
export interface CreateRuleResponse {
    result: {
        id?: string | null;
        action?: "block" | "challenge" | "js_challenge" | "managed_challenge" | "allow" | "log" | "bypass" | null;
        description?: string | null;
        filter?: {
            id?: string | null;
            description?: string | null;
            expression?: string | null;
            paused?: boolean | null;
            ref?: string | null;
        } | {
            id: string;
            deleted: boolean;
        } | null;
        paused?: boolean | null;
        priority?: number | null;
        products?: ("zoneLockdown" | "uaBlock" | "bic" | "hot" | "securityLevel" | "rateLimit" | "waf")[] | null;
        ref?: string | null;
    }[];
}
export declare const CreateRuleResponse: Schema.Schema<CreateRuleResponse>;
export type CreateRuleError = DefaultErrors;
export declare const createRule: API.PaginatedOperationMethod<CreateRuleRequest, CreateRuleResponse, CreateRuleError, Credentials | HttpClient.HttpClient>;
export interface UpdateRuleRequest {
    ruleId: string;
    /** Path param: Defines an identifier. */
    zoneId: string;
    /** Body param: The action to perform when the threshold of matched traffic within the configured period is exceeded. */
    action: {
        mode?: "simulate" | "ban" | "challenge" | "js_challenge" | "managed_challenge";
        response?: {
            body?: string;
            contentType?: string;
        };
        timeout?: number;
    };
    /** Body param: */
    filter: {
        description?: string;
        expression?: string;
        paused?: boolean;
        ref?: string;
    };
}
export declare const UpdateRuleRequest: Schema.Schema<UpdateRuleRequest>;
export interface UpdateRuleResponse {
    /** The unique identifier of the firewall rule. */
    id?: string | null;
    /** The action to apply to a matched request. The `log` action is only available on an Enterprise plan. */
    action?: "block" | "challenge" | "js_challenge" | "managed_challenge" | "allow" | "log" | "bypass" | null;
    /** An informative summary of the firewall rule. */
    description?: string | null;
    filter?: {
        id?: string | null;
        description?: string | null;
        expression?: string | null;
        paused?: boolean | null;
        ref?: string | null;
    } | {
        id: string;
        deleted: boolean;
    } | null;
    /** When true, indicates that the firewall rule is currently paused. */
    paused?: boolean | null;
    /** The priority of the rule. Optional value used to define the processing order. A lower number indicates a higher priority. If not provided, rules with a defined priority will be processed before rules  */
    priority?: number | null;
    products?: ("zoneLockdown" | "uaBlock" | "bic" | "hot" | "securityLevel" | "rateLimit" | "waf")[] | null;
    /** A short reference tag. Allows you to select related firewall rules. */
    ref?: string | null;
}
export declare const UpdateRuleResponse: Schema.Schema<UpdateRuleResponse>;
export type UpdateRuleError = DefaultErrors;
export declare const updateRule: API.OperationMethod<UpdateRuleRequest, UpdateRuleResponse, UpdateRuleError, Credentials | HttpClient.HttpClient>;
export interface PatchRuleRequest {
    ruleId: string;
    /** Defines an identifier. */
    zoneId: string;
}
export declare const PatchRuleRequest: Schema.Schema<PatchRuleRequest>;
export interface PatchRuleResponse {
    result: {
        id?: string | null;
        action?: "block" | "challenge" | "js_challenge" | "managed_challenge" | "allow" | "log" | "bypass" | null;
        description?: string | null;
        filter?: {
            id?: string | null;
            description?: string | null;
            expression?: string | null;
            paused?: boolean | null;
            ref?: string | null;
        } | {
            id: string;
            deleted: boolean;
        } | null;
        paused?: boolean | null;
        priority?: number | null;
        products?: ("zoneLockdown" | "uaBlock" | "bic" | "hot" | "securityLevel" | "rateLimit" | "waf")[] | null;
        ref?: string | null;
    }[];
}
export declare const PatchRuleResponse: Schema.Schema<PatchRuleResponse>;
export type PatchRuleError = DefaultErrors;
export declare const patchRule: API.PaginatedOperationMethod<PatchRuleRequest, PatchRuleResponse, PatchRuleError, Credentials | HttpClient.HttpClient>;
export interface DeleteRuleRequest {
    ruleId: string;
    /** Defines an identifier. */
    zoneId: string;
}
export declare const DeleteRuleRequest: Schema.Schema<DeleteRuleRequest>;
export interface DeleteRuleResponse {
    /** The unique identifier of the firewall rule. */
    id?: string | null;
    /** The action to apply to a matched request. The `log` action is only available on an Enterprise plan. */
    action?: "block" | "challenge" | "js_challenge" | "managed_challenge" | "allow" | "log" | "bypass" | null;
    /** An informative summary of the firewall rule. */
    description?: string | null;
    filter?: {
        id?: string | null;
        description?: string | null;
        expression?: string | null;
        paused?: boolean | null;
        ref?: string | null;
    } | {
        id: string;
        deleted: boolean;
    } | null;
    /** When true, indicates that the firewall rule is currently paused. */
    paused?: boolean | null;
    /** The priority of the rule. Optional value used to define the processing order. A lower number indicates a higher priority. If not provided, rules with a defined priority will be processed before rules  */
    priority?: number | null;
    products?: ("zoneLockdown" | "uaBlock" | "bic" | "hot" | "securityLevel" | "rateLimit" | "waf")[] | null;
    /** A short reference tag. Allows you to select related firewall rules. */
    ref?: string | null;
}
export declare const DeleteRuleResponse: Schema.Schema<DeleteRuleResponse>;
export type DeleteRuleError = DefaultErrors;
export declare const deleteRule: API.OperationMethod<DeleteRuleRequest, DeleteRuleResponse, DeleteRuleError, Credentials | HttpClient.HttpClient>;
export interface BulkPatchRulesRequest {
    /** Path param: Defines an identifier. */
    zoneId: string;
    /** Body param: */
    body: unknown;
}
export declare const BulkPatchRulesRequest: Schema.Schema<BulkPatchRulesRequest>;
export interface BulkPatchRulesResponse {
    result: {
        id?: string | null;
        action?: "block" | "challenge" | "js_challenge" | "managed_challenge" | "allow" | "log" | "bypass" | null;
        description?: string | null;
        filter?: {
            id?: string | null;
            description?: string | null;
            expression?: string | null;
            paused?: boolean | null;
            ref?: string | null;
        } | {
            id: string;
            deleted: boolean;
        } | null;
        paused?: boolean | null;
        priority?: number | null;
        products?: ("zoneLockdown" | "uaBlock" | "bic" | "hot" | "securityLevel" | "rateLimit" | "waf")[] | null;
        ref?: string | null;
    }[];
}
export declare const BulkPatchRulesResponse: Schema.Schema<BulkPatchRulesResponse>;
export type BulkPatchRulesError = DefaultErrors;
export declare const bulkPatchRules: API.PaginatedOperationMethod<BulkPatchRulesRequest, BulkPatchRulesResponse, BulkPatchRulesError, Credentials | HttpClient.HttpClient>;
export interface BulkDeleteRulesRequest {
    /** Defines an identifier. */
    zoneId: string;
}
export declare const BulkDeleteRulesRequest: Schema.Schema<BulkDeleteRulesRequest>;
export interface BulkDeleteRulesResponse {
    result: {
        id?: string | null;
        action?: "block" | "challenge" | "js_challenge" | "managed_challenge" | "allow" | "log" | "bypass" | null;
        description?: string | null;
        filter?: {
            id?: string | null;
            description?: string | null;
            expression?: string | null;
            paused?: boolean | null;
            ref?: string | null;
        } | {
            id: string;
            deleted: boolean;
        } | null;
        paused?: boolean | null;
        priority?: number | null;
        products?: ("zoneLockdown" | "uaBlock" | "bic" | "hot" | "securityLevel" | "rateLimit" | "waf")[] | null;
        ref?: string | null;
    }[];
}
export declare const BulkDeleteRulesResponse: Schema.Schema<BulkDeleteRulesResponse>;
export type BulkDeleteRulesError = DefaultErrors;
export declare const bulkDeleteRules: API.PaginatedOperationMethod<BulkDeleteRulesRequest, BulkDeleteRulesResponse, BulkDeleteRulesError, Credentials | HttpClient.HttpClient>;
export interface GetUaRuleRequest {
    uaRuleId: string;
    /** Defines an identifier. */
    zoneId: string;
}
export declare const GetUaRuleRequest: Schema.Schema<GetUaRuleRequest>;
export interface GetUaRuleResponse {
    /** The unique identifier of the User Agent Blocking rule. */
    id?: string | null;
    /** The configuration object for the current rule. */
    configuration?: {
        target?: string | null;
        value?: string | null;
    } | null;
    /** An informative summary of the rule. */
    description?: string | null;
    /** The action to apply to a matched request. */
    mode?: "block" | "challenge" | "js_challenge" | "managed_challenge" | null;
    /** When true, indicates that the rule is currently paused. */
    paused?: boolean | null;
}
export declare const GetUaRuleResponse: Schema.Schema<GetUaRuleResponse>;
export type GetUaRuleError = DefaultErrors;
export declare const getUaRule: API.OperationMethod<GetUaRuleRequest, GetUaRuleResponse, GetUaRuleError, Credentials | HttpClient.HttpClient>;
export interface ListUaRulesRequest {
    /** Path param: Defines an identifier. */
    zoneId: string;
    page?: number;
    perPage?: number;
    /** Query param: A string to search for in the description of existing rules. */
    description?: string;
    /** Query param: When true, indicates that the rule is currently paused. */
    paused?: boolean;
    /** Query param: A string to search for in the user agent values of existing rules. */
    userAgent?: string;
}
export declare const ListUaRulesRequest: Schema.Schema<ListUaRulesRequest>;
export interface ListUaRulesResponse {
    result: {
        id?: string | null;
        configuration?: {
            target?: string | null;
            value?: string | null;
        } | null;
        description?: string | null;
        mode?: "block" | "challenge" | "js_challenge" | "managed_challenge" | null;
        paused?: boolean | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListUaRulesResponse: Schema.Schema<ListUaRulesResponse>;
export type ListUaRulesError = DefaultErrors;
export declare const listUaRules: API.PaginatedOperationMethod<ListUaRulesRequest, ListUaRulesResponse, ListUaRulesError, Credentials | HttpClient.HttpClient>;
export interface CreateUaRuleRequest {
    /** Path param: Defines an identifier. */
    zoneId: string;
    /** Body param: */
    configuration: {
        target?: "ua";
        value?: string;
    };
    /** Body param: The action to apply to a matched request. */
    mode: "block" | "challenge" | "whitelist" | "js_challenge" | "managed_challenge";
    /** Body param: An informative summary of the rule. This value is sanitized and any tags will be removed. */
    description?: string;
    /** Body param: When true, indicates that the rule is currently paused. */
    paused?: boolean;
}
export declare const CreateUaRuleRequest: Schema.Schema<CreateUaRuleRequest>;
export interface CreateUaRuleResponse {
    /** The unique identifier of the User Agent Blocking rule. */
    id?: string | null;
    /** The configuration object for the current rule. */
    configuration?: {
        target?: string | null;
        value?: string | null;
    } | null;
    /** An informative summary of the rule. */
    description?: string | null;
    /** The action to apply to a matched request. */
    mode?: "block" | "challenge" | "js_challenge" | "managed_challenge" | null;
    /** When true, indicates that the rule is currently paused. */
    paused?: boolean | null;
}
export declare const CreateUaRuleResponse: Schema.Schema<CreateUaRuleResponse>;
export type CreateUaRuleError = DefaultErrors;
export declare const createUaRule: API.OperationMethod<CreateUaRuleRequest, CreateUaRuleResponse, CreateUaRuleError, Credentials | HttpClient.HttpClient>;
export interface UpdateUaRuleRequest {
    uaRuleId: string;
    /** Path param: Defines an identifier. */
    zoneId: string;
    /** Body param: The rule configuration. */
    configuration: {
        target?: "ip";
        value?: string;
    } | {
        target?: "ip6";
        value?: string;
    } | {
        target?: "ip_range";
        value?: string;
    } | {
        target?: "asn";
        value?: string;
    } | {
        target?: "country";
        value?: string;
    };
    /** Body param: The action to apply to a matched request. */
    mode: "block" | "challenge" | "whitelist" | "js_challenge" | "managed_challenge";
    /** Body param: An informative summary of the rule. This value is sanitized and any tags will be removed. */
    description?: string;
    /** Body param: When true, indicates that the rule is currently paused. */
    paused?: boolean;
}
export declare const UpdateUaRuleRequest: Schema.Schema<UpdateUaRuleRequest>;
export interface UpdateUaRuleResponse {
    /** The unique identifier of the User Agent Blocking rule. */
    id?: string | null;
    /** The configuration object for the current rule. */
    configuration?: {
        target?: string | null;
        value?: string | null;
    } | null;
    /** An informative summary of the rule. */
    description?: string | null;
    /** The action to apply to a matched request. */
    mode?: "block" | "challenge" | "js_challenge" | "managed_challenge" | null;
    /** When true, indicates that the rule is currently paused. */
    paused?: boolean | null;
}
export declare const UpdateUaRuleResponse: Schema.Schema<UpdateUaRuleResponse>;
export type UpdateUaRuleError = DefaultErrors;
export declare const updateUaRule: API.OperationMethod<UpdateUaRuleRequest, UpdateUaRuleResponse, UpdateUaRuleError, Credentials | HttpClient.HttpClient>;
export interface DeleteUaRuleRequest {
    uaRuleId: string;
    /** Defines an identifier. */
    zoneId: string;
}
export declare const DeleteUaRuleRequest: Schema.Schema<DeleteUaRuleRequest>;
export interface DeleteUaRuleResponse {
    /** The unique identifier of the User Agent Blocking rule. */
    id?: string | null;
    /** The configuration object for the current rule. */
    configuration?: {
        target?: string | null;
        value?: string | null;
    } | null;
    /** An informative summary of the rule. */
    description?: string | null;
    /** The action to apply to a matched request. */
    mode?: "block" | "challenge" | "js_challenge" | "managed_challenge" | null;
    /** When true, indicates that the rule is currently paused. */
    paused?: boolean | null;
}
export declare const DeleteUaRuleResponse: Schema.Schema<DeleteUaRuleResponse>;
export type DeleteUaRuleError = DefaultErrors;
export declare const deleteUaRule: API.OperationMethod<DeleteUaRuleRequest, DeleteUaRuleResponse, DeleteUaRuleError, Credentials | HttpClient.HttpClient>;
export interface GetWafOverrideRequest {
    overridesId: string;
    /** Defines an identifier. */
    zoneId: string;
}
export declare const GetWafOverrideRequest: Schema.Schema<GetWafOverrideRequest>;
export interface GetWafOverrideResponse {
    /** The unique identifier of the WAF override. */
    id?: string | null;
    /** An informative summary of the current URI-based WAF override. */
    description?: string | null;
    /** An object that allows you to enable or disable WAF rule groups for the current WAF override. Each key of this object must be the ID of a WAF rule group, and each value must be a valid WAF action (usua */
    groups?: Record<string, unknown> | null;
    /** When true, indicates that the rule is currently paused. */
    paused?: boolean | null;
    /** The relative priority of the current URI-based WAF override when multiple overrides match a single URL. A lower number indicates higher priority. Higher priority overrides may overwrite values set by  */
    priority?: number | null;
    /** Specifies that, when a WAF rule matches, its configured action will be replaced by the action configured in this object. */
    rewriteAction?: {
        block?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
        challenge?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
        default?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
        disable?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
        simulate?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
    } | null;
    /** An object that allows you to override the action of specific WAF rules. Each key of this object must be the ID of a WAF rule, and each value must be a valid WAF action. Unless you are disabling a rule */
    rules?: Record<string, unknown> | null;
    /** The URLs to include in the current WAF override. You can use wildcards. Each entered URL will be escaped before use, which means you can only use simple wildcard patterns. */
    urls?: string[] | null;
}
export declare const GetWafOverrideResponse: Schema.Schema<GetWafOverrideResponse>;
export type GetWafOverrideError = DefaultErrors;
export declare const getWafOverride: API.OperationMethod<GetWafOverrideRequest, GetWafOverrideResponse, GetWafOverrideError, Credentials | HttpClient.HttpClient>;
export interface ListWafOverridesRequest {
    /** Path param: Defines an identifier. */
    zoneId: string;
    page?: number;
    perPage?: number;
}
export declare const ListWafOverridesRequest: Schema.Schema<ListWafOverridesRequest>;
export interface ListWafOverridesResponse {
    result: {
        id?: string | null;
        description?: string | null;
        groups?: Record<string, unknown> | null;
        paused?: boolean | null;
        priority?: number | null;
        rewriteAction?: {
            block?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
            challenge?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
            default?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
            disable?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
            simulate?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
        } | null;
        rules?: Record<string, unknown> | null;
        urls?: string[] | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListWafOverridesResponse: Schema.Schema<ListWafOverridesResponse>;
export type ListWafOverridesError = DefaultErrors;
export declare const listWafOverrides: API.PaginatedOperationMethod<ListWafOverridesRequest, ListWafOverridesResponse, ListWafOverridesError, Credentials | HttpClient.HttpClient>;
export interface CreateWafOverrideRequest {
    /** Path param: Defines an identifier. */
    zoneId: string;
    /** Body param: The URLs to include in the current WAF override. You can use wildcards. Each entered URL will be escaped before use, which means you can only use simple wildcard patterns. */
    urls: string[];
}
export declare const CreateWafOverrideRequest: Schema.Schema<CreateWafOverrideRequest>;
export interface CreateWafOverrideResponse {
    /** The unique identifier of the WAF override. */
    id?: string | null;
    /** An informative summary of the current URI-based WAF override. */
    description?: string | null;
    /** An object that allows you to enable or disable WAF rule groups for the current WAF override. Each key of this object must be the ID of a WAF rule group, and each value must be a valid WAF action (usua */
    groups?: Record<string, unknown> | null;
    /** When true, indicates that the rule is currently paused. */
    paused?: boolean | null;
    /** The relative priority of the current URI-based WAF override when multiple overrides match a single URL. A lower number indicates higher priority. Higher priority overrides may overwrite values set by  */
    priority?: number | null;
    /** Specifies that, when a WAF rule matches, its configured action will be replaced by the action configured in this object. */
    rewriteAction?: {
        block?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
        challenge?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
        default?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
        disable?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
        simulate?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
    } | null;
    /** An object that allows you to override the action of specific WAF rules. Each key of this object must be the ID of a WAF rule, and each value must be a valid WAF action. Unless you are disabling a rule */
    rules?: Record<string, unknown> | null;
    /** The URLs to include in the current WAF override. You can use wildcards. Each entered URL will be escaped before use, which means you can only use simple wildcard patterns. */
    urls?: string[] | null;
}
export declare const CreateWafOverrideResponse: Schema.Schema<CreateWafOverrideResponse>;
export type CreateWafOverrideError = DefaultErrors;
export declare const createWafOverride: API.OperationMethod<CreateWafOverrideRequest, CreateWafOverrideResponse, CreateWafOverrideError, Credentials | HttpClient.HttpClient>;
export interface UpdateWafOverrideRequest {
    overridesId: string;
    /** Path param: Defines an identifier. */
    zoneId: string;
    /** Body param: Defines an identifier. */
    id: string;
    /** Body param: Specifies that, when a WAF rule matches, its configured action will be replaced by the action configured in this object. */
    rewriteAction: {
        block?: "challenge" | "block" | "simulate" | "disable" | "default";
        challenge?: "challenge" | "block" | "simulate" | "disable" | "default";
        default?: "challenge" | "block" | "simulate" | "disable" | "default";
        disable?: "challenge" | "block" | "simulate" | "disable" | "default";
        simulate?: "challenge" | "block" | "simulate" | "disable" | "default";
    };
    /** Body param: An object that allows you to override the action of specific WAF rules. Each key of this object must be the ID of a WAF rule, and each value must be a valid WAF action. Unless you are disa */
    rules: Record<string, unknown>;
    /** Body param: The URLs to include in the current WAF override. You can use wildcards. Each entered URL will be escaped before use, which means you can only use simple wildcard patterns. */
    urls: string[];
}
export declare const UpdateWafOverrideRequest: Schema.Schema<UpdateWafOverrideRequest>;
export interface UpdateWafOverrideResponse {
    /** The unique identifier of the WAF override. */
    id?: string | null;
    /** An informative summary of the current URI-based WAF override. */
    description?: string | null;
    /** An object that allows you to enable or disable WAF rule groups for the current WAF override. Each key of this object must be the ID of a WAF rule group, and each value must be a valid WAF action (usua */
    groups?: Record<string, unknown> | null;
    /** When true, indicates that the rule is currently paused. */
    paused?: boolean | null;
    /** The relative priority of the current URI-based WAF override when multiple overrides match a single URL. A lower number indicates higher priority. Higher priority overrides may overwrite values set by  */
    priority?: number | null;
    /** Specifies that, when a WAF rule matches, its configured action will be replaced by the action configured in this object. */
    rewriteAction?: {
        block?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
        challenge?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
        default?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
        disable?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
        simulate?: "challenge" | "block" | "simulate" | "disable" | "default" | null;
    } | null;
    /** An object that allows you to override the action of specific WAF rules. Each key of this object must be the ID of a WAF rule, and each value must be a valid WAF action. Unless you are disabling a rule */
    rules?: Record<string, unknown> | null;
    /** The URLs to include in the current WAF override. You can use wildcards. Each entered URL will be escaped before use, which means you can only use simple wildcard patterns. */
    urls?: string[] | null;
}
export declare const UpdateWafOverrideResponse: Schema.Schema<UpdateWafOverrideResponse>;
export type UpdateWafOverrideError = DefaultErrors;
export declare const updateWafOverride: API.OperationMethod<UpdateWafOverrideRequest, UpdateWafOverrideResponse, UpdateWafOverrideError, Credentials | HttpClient.HttpClient>;
export interface DeleteWafOverrideRequest {
    overridesId: string;
    /** Defines an identifier. */
    zoneId: string;
}
export declare const DeleteWafOverrideRequest: Schema.Schema<DeleteWafOverrideRequest>;
export interface DeleteWafOverrideResponse {
    /** The unique identifier of the WAF override. */
    id?: string | null;
}
export declare const DeleteWafOverrideResponse: Schema.Schema<DeleteWafOverrideResponse>;
export type DeleteWafOverrideError = DefaultErrors;
export declare const deleteWafOverride: API.OperationMethod<DeleteWafOverrideRequest, DeleteWafOverrideResponse, DeleteWafOverrideError, Credentials | HttpClient.HttpClient>;
export interface GetWafPackageRequest {
    packageId: string;
    /** Defines an identifier. */
    zoneId: string;
}
export declare const GetWafPackageRequest: Schema.Schema<GetWafPackageRequest>;
export type GetWafPackageResponse = {
    errors: {
        code: number;
        message: string;
        documentationUrl?: string | null;
        source?: {
            pointer?: string | null;
        } | null;
    }[];
    messages: {
        code: number;
        message: string;
        documentationUrl?: string | null;
        source?: {
            pointer?: string | null;
        } | null;
    }[];
    result: string | null;
    success: true;
} | {
    result?: unknown | null;
};
export declare const GetWafPackageResponse: Schema.Schema<GetWafPackageResponse>;
export type GetWafPackageError = DefaultErrors;
export declare const getWafPackage: API.OperationMethod<GetWafPackageRequest, GetWafPackageResponse, GetWafPackageError, Credentials | HttpClient.HttpClient>;
export interface ListWafPackagesRequest {
    /** Path param: Defines an identifier. */
    zoneId: string;
    page?: number;
    perPage?: number;
    /** Query param: The direction used to sort returned packages. */
    direction?: "asc" | "desc";
    /** Query param: When set to `all`, all the search requirements must match. When set to `any`, only one of the search requirements has to match. */
    match?: "any" | "all";
    /** Query param: The name of the WAF package. */
    name?: string;
    /** Query param: The field used to sort returned packages. */
    order?: "name";
}
export declare const ListWafPackagesRequest: Schema.Schema<ListWafPackagesRequest>;
export interface ListWafPackagesResponse {
    result: unknown[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListWafPackagesResponse: Schema.Schema<ListWafPackagesResponse>;
export type ListWafPackagesError = DefaultErrors;
export declare const listWafPackages: API.PaginatedOperationMethod<ListWafPackagesRequest, ListWafPackagesResponse, ListWafPackagesError, Credentials | HttpClient.HttpClient>;
export interface GetWafPackageGroupRequest {
    packageId: string;
    groupId: string;
    /** Defines an identifier of a schema. */
    zoneId: string;
}
export declare const GetWafPackageGroupRequest: Schema.Schema<GetWafPackageGroupRequest>;
export type GetWafPackageGroupResponse = string | null;
export declare const GetWafPackageGroupResponse: Schema.Schema<GetWafPackageGroupResponse>;
export type GetWafPackageGroupError = DefaultErrors;
export declare const getWafPackageGroup: API.OperationMethod<GetWafPackageGroupRequest, GetWafPackageGroupResponse, GetWafPackageGroupError, Credentials | HttpClient.HttpClient>;
export interface ListWafPackageGroupsRequest {
    packageId: string;
    /** Path param: Defines an identifier of a schema. */
    zoneId: string;
    page?: number;
    perPage?: number;
    /** Query param: Defines the direction used to sort returned rule groups. */
    direction?: "asc" | "desc";
    /** Query param: Defines the condition for search requirements. When set to `all`, all the search requirements must match. When set to `any`, only one of the search requirements has to match. */
    match?: "any" | "all";
    /** Query param: Defines the state of the rules contained in the rule group. When `on`, the rules in the group are configurable/usable. */
    mode?: "on" | "off";
    /** Query param: Defines the name of the rule group. */
    name?: string;
    /** Query param: Defines the field used to sort returned rule groups. */
    order?: "mode" | "rules_count";
    /** Query param: Defines the number of rules in the current rule group. */
    rulesCount?: number;
}
export declare const ListWafPackageGroupsRequest: Schema.Schema<ListWafPackageGroupsRequest>;
export interface ListWafPackageGroupsResponse {
    result: {
        id: string;
        description: string | null;
        mode: "on" | "off";
        name: string;
        rulesCount: number;
        allowedModes?: ("on" | "off")[] | null;
        modifiedRulesCount?: number | null;
        packageId?: string | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListWafPackageGroupsResponse: Schema.Schema<ListWafPackageGroupsResponse>;
export type ListWafPackageGroupsError = DefaultErrors;
export declare const listWafPackageGroups: API.PaginatedOperationMethod<ListWafPackageGroupsRequest, ListWafPackageGroupsResponse, ListWafPackageGroupsError, Credentials | HttpClient.HttpClient>;
export interface PatchWafPackageGroupRequest {
    packageId: string;
    groupId: string;
    /** Path param: Defines an identifier of a schema. */
    zoneId: string;
    /** Body param: Defines the state of the rules contained in the rule group. When `on`, the rules in the group are configurable/usable. */
    mode?: "on" | "off";
}
export declare const PatchWafPackageGroupRequest: Schema.Schema<PatchWafPackageGroupRequest>;
export type PatchWafPackageGroupResponse = string | null;
export declare const PatchWafPackageGroupResponse: Schema.Schema<PatchWafPackageGroupResponse>;
export type PatchWafPackageGroupError = DefaultErrors;
export declare const patchWafPackageGroup: API.OperationMethod<PatchWafPackageGroupRequest, PatchWafPackageGroupResponse, PatchWafPackageGroupError, Credentials | HttpClient.HttpClient>;
export interface GetWafPackageRuleRequest {
    packageId: string;
    ruleId: string;
    /** Defines an identifier of a schema. */
    zoneId: string;
}
export declare const GetWafPackageRuleRequest: Schema.Schema<GetWafPackageRuleRequest>;
export type GetWafPackageRuleResponse = string | null;
export declare const GetWafPackageRuleResponse: Schema.Schema<GetWafPackageRuleResponse>;
export type GetWafPackageRuleError = DefaultErrors;
export declare const getWafPackageRule: API.OperationMethod<GetWafPackageRuleRequest, GetWafPackageRuleResponse, GetWafPackageRuleError, Credentials | HttpClient.HttpClient>;
export interface ListWafPackageRulesRequest {
    packageId: string;
    /** Path param: Defines an identifier of a schema. */
    zoneId: string;
    page?: number;
    perPage?: number;
    /** Query param: Defines the public description of the WAF rule. */
    description?: string;
    /** Query param: Defines the direction used to sort returned rules. */
    direction?: "asc" | "desc";
    /** Query param: Defines the unique identifier of the rule group. */
    groupId?: string;
    /** Query param: Defines the search requirements. When set to `all`, all the search requirements must match. When set to `any`, only one of the search requirements has to match. */
    match?: "any" | "all";
    /** Query param: Defines the action/mode a rule has been overridden to perform. */
    mode?: "DIS" | "CHL" | "BLK" | "SIM";
    /** Query param: Defines the field used to sort returned rules. */
    order?: "priority" | "group_id" | "description";
    /** Query param: Defines the order in which the individual WAF rule is executed within its rule group. */
    priority?: string;
}
export declare const ListWafPackageRulesRequest: Schema.Schema<ListWafPackageRulesRequest>;
export interface ListWafPackageRulesResponse {
    result: ({
        id: string;
        allowedModes: ("on" | "off")[];
        description: string;
        group: {
            id?: string | null;
            name?: string | null;
        };
        mode: "on" | "off";
        packageId: string;
        priority: string;
    } | {
        id: string;
        allowedModes: ("default" | "disable" | "simulate" | "block" | "challenge")[];
        defaultMode: "disable" | "simulate" | "block" | "challenge";
        description: string;
        group: {
            id?: string | null;
            name?: string | null;
        };
        mode: "default" | "disable" | "simulate" | "block" | "challenge";
        packageId: string;
        priority: string;
    })[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListWafPackageRulesResponse: Schema.Schema<ListWafPackageRulesResponse>;
export type ListWafPackageRulesError = DefaultErrors;
export declare const listWafPackageRules: API.PaginatedOperationMethod<ListWafPackageRulesRequest, ListWafPackageRulesResponse, ListWafPackageRulesError, Credentials | HttpClient.HttpClient>;
export interface PatchWafPackageRuleRequest {
    packageId: string;
    ruleId: string;
    /** Path param: Defines an identifier of a schema. */
    zoneId: string;
    /** Body param: Defines the mode/action of the rule when triggered. You must use a value from the `allowed_modes` array of the current rule. */
    mode?: "default" | "disable" | "simulate" | "block" | "challenge" | "on" | "off";
}
export declare const PatchWafPackageRuleRequest: Schema.Schema<PatchWafPackageRuleRequest>;
export type PatchWafPackageRuleResponse = {
    id: string;
    allowedModes: ("on" | "off")[];
    description: string;
    group: {
        id?: string | null;
        name?: string | null;
    };
    mode: "on" | "off";
    packageId: string;
    priority: string;
} | {
    id: string;
    allowedModes: ("default" | "disable" | "simulate" | "block" | "challenge")[];
    defaultMode: "disable" | "simulate" | "block" | "challenge";
    description: string;
    group: {
        id?: string | null;
        name?: string | null;
    };
    mode: "default" | "disable" | "simulate" | "block" | "challenge";
    packageId: string;
    priority: string;
};
export declare const PatchWafPackageRuleResponse: Schema.Schema<PatchWafPackageRuleResponse>;
export type PatchWafPackageRuleError = DefaultErrors;
export declare const patchWafPackageRule: API.OperationMethod<PatchWafPackageRuleRequest, PatchWafPackageRuleResponse, PatchWafPackageRuleError, Credentials | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=firewall.d.ts.map