import * as Core from 'cloudflaredev/core';
import { APIResource } from 'cloudflaredev/resource';
import * as RulesAPI from 'cloudflaredev/resources/waiting-rooms/rules';
import { SinglePage } from 'cloudflaredev/pagination';
export declare class Rules extends APIResource {
    /**
     * Only available for the Waiting Room Advanced subscription. Creates a rule for a
     * waiting room.
     */
    create(waitingRoomId: string, params: RuleCreateParams, options?: Core.RequestOptions): Core.APIPromise<RuleCreateResponse | null>;
    /**
     * Only available for the Waiting Room Advanced subscription. Replaces all rules
     * for a waiting room.
     */
    update(waitingRoomId: string, params: RuleUpdateParams, options?: Core.RequestOptions): Core.APIPromise<RuleUpdateResponse | null>;
    /**
     * Lists rules for a waiting room.
     */
    list(waitingRoomId: string, params: RuleListParams, options?: Core.RequestOptions): Core.PagePromise<WaitingRoomRulesSinglePage, WaitingRoomRule>;
    /**
     * Deletes a rule for a waiting room.
     */
    delete(waitingRoomId: string, ruleId: string, params: RuleDeleteParams, options?: Core.RequestOptions): Core.APIPromise<RuleDeleteResponse | null>;
    /**
     * Patches a rule for a waiting room.
     */
    edit(waitingRoomId: string, ruleId: string, params: RuleEditParams, options?: Core.RequestOptions): Core.APIPromise<RuleEditResponse | null>;
}
export declare class WaitingRoomRulesSinglePage extends SinglePage<WaitingRoomRule> {
}
export interface WaitingRoomRule {
    /**
     * The ID of the rule.
     */
    id?: string;
    /**
     * The action to take when the expression matches.
     */
    action?: 'bypass_waiting_room';
    /**
     * The description of the rule.
     */
    description?: string;
    /**
     * When set to true, the rule is enabled.
     */
    enabled?: boolean;
    /**
     * Criteria defining when there is a match for the current rule.
     */
    expression?: string;
    last_updated?: string;
    /**
     * The version of the rule.
     */
    version?: string;
}
export type RuleCreateResponse = Array<WaitingRoomRule>;
export type RuleUpdateResponse = Array<WaitingRoomRule>;
export type RuleDeleteResponse = Array<WaitingRoomRule>;
export type RuleEditResponse = Array<WaitingRoomRule>;
export interface RuleCreateParams {
    /**
     * Path param: Identifier
     */
    zone_id: string;
    /**
     * Body param: The action to take when the expression matches.
     */
    action: 'bypass_waiting_room';
    /**
     * Body param: Criteria defining when there is a match for the current rule.
     */
    expression: string;
    /**
     * Body param: The description of the rule.
     */
    description?: string;
    /**
     * Body param: When set to true, the rule is enabled.
     */
    enabled?: boolean;
}
export interface RuleUpdateParams {
    /**
     * Path param: Identifier
     */
    zone_id: string;
    /**
     * Body param:
     */
    body: Array<RuleUpdateParams.Body>;
}
export declare namespace RuleUpdateParams {
    interface Body {
        /**
         * The action to take when the expression matches.
         */
        action: 'bypass_waiting_room';
        /**
         * Criteria defining when there is a match for the current rule.
         */
        expression: string;
        /**
         * The description of the rule.
         */
        description?: string;
        /**
         * When set to true, the rule is enabled.
         */
        enabled?: boolean;
    }
}
export interface RuleListParams {
    /**
     * Identifier
     */
    zone_id: string;
}
export interface RuleDeleteParams {
    /**
     * Identifier
     */
    zone_id: string;
}
export interface RuleEditParams {
    /**
     * Path param: Identifier
     */
    zone_id: string;
    /**
     * Body param: The action to take when the expression matches.
     */
    action: 'bypass_waiting_room';
    /**
     * Body param: Criteria defining when there is a match for the current rule.
     */
    expression: string;
    /**
     * Body param: The description of the rule.
     */
    description?: string;
    /**
     * Body param: When set to true, the rule is enabled.
     */
    enabled?: boolean;
    /**
     * Body param: Reorder the position of a rule
     */
    position?: RuleEditParams.Index | RuleEditParams.Before | RuleEditParams.After;
}
export declare namespace RuleEditParams {
    interface Index {
        /**
         * Places the rule in the exact position specified by the integer number
         * <POSITION_NUMBER>. Position numbers start with 1. Existing rules in the ruleset
         * from the specified position number onward are shifted one position (no rule is
         * overwritten).
         */
        index?: number;
    }
    interface Before {
        /**
         * Places the rule before rule <RULE_ID>. Use this argument with an empty rule ID
         * value ("") to set the rule as the first rule in the ruleset.
         */
        before?: string;
    }
    interface After {
        /**
         * Places the rule after rule <RULE_ID>. Use this argument with an empty rule ID
         * value ("") to set the rule as the last rule in the ruleset.
         */
        after?: string;
    }
}
export declare namespace Rules {
    export import WaitingRoomRule = RulesAPI.WaitingRoomRule;
    export import RuleCreateResponse = RulesAPI.RuleCreateResponse;
    export import RuleUpdateResponse = RulesAPI.RuleUpdateResponse;
    export import RuleDeleteResponse = RulesAPI.RuleDeleteResponse;
    export import RuleEditResponse = RulesAPI.RuleEditResponse;
    export import WaitingRoomRulesSinglePage = RulesAPI.WaitingRoomRulesSinglePage;
    export import RuleCreateParams = RulesAPI.RuleCreateParams;
    export import RuleUpdateParams = RulesAPI.RuleUpdateParams;
    export import RuleListParams = RulesAPI.RuleListParams;
    export import RuleDeleteParams = RulesAPI.RuleDeleteParams;
    export import RuleEditParams = RulesAPI.RuleEditParams;
}
//# sourceMappingURL=rules.d.ts.map