/**
 * Cloudflare API-GATEWAY API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service api-gateway
 */
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";
declare const InvalidObjectIdentifier_base: Schema.Class<InvalidObjectIdentifier, Schema.TaggedStruct<"InvalidObjectIdentifier", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class InvalidObjectIdentifier extends InvalidObjectIdentifier_base {
}
declare const NotEntitled_base: Schema.Class<NotEntitled, Schema.TaggedStruct<"NotEntitled", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class NotEntitled extends NotEntitled_base {
}
declare const OperationNotFound_base: Schema.Class<OperationNotFound, Schema.TaggedStruct<"OperationNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class OperationNotFound extends OperationNotFound_base {
}
declare const SchemaNotFound_base: Schema.Class<SchemaNotFound, Schema.TaggedStruct<"SchemaNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class SchemaNotFound extends SchemaNotFound_base {
}
export interface GetConfigurationRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Query param: Ensures that the configuration is written or retrieved in normalized fashion */
    normalize?: boolean;
}
export declare const GetConfigurationRequest: Schema.Schema<GetConfigurationRequest>;
export interface GetConfigurationResponse {
    authIdCharacteristics: ({
        name: string;
        type: "header" | "cookie";
    } | {
        name: string;
        type: "jwt";
    })[];
}
export declare const GetConfigurationResponse: Schema.Schema<GetConfigurationResponse>;
export type GetConfigurationError = DefaultErrors | InvalidObjectIdentifier | NotEntitled;
export declare const getConfiguration: API.OperationMethod<GetConfigurationRequest, GetConfigurationResponse, GetConfigurationError, Credentials | HttpClient.HttpClient>;
export interface PutConfigurationRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Query param: Ensures that the configuration is written or retrieved in normalized fashion */
    normalize?: boolean;
    /** Body param: */
    authIdCharacteristics: ({
        name: string;
        type: "header" | "cookie";
    } | {
        name: string;
        type: "jwt";
    })[];
}
export declare const PutConfigurationRequest: Schema.Schema<PutConfigurationRequest>;
export interface PutConfigurationResponse {
    authIdCharacteristics: ({
        name: string;
        type: "header" | "cookie";
    } | {
        name: string;
        type: "jwt";
    })[];
}
export declare const PutConfigurationResponse: Schema.Schema<PutConfigurationResponse>;
export type PutConfigurationError = DefaultErrors | InvalidObjectIdentifier | NotEntitled;
export declare const putConfiguration: API.OperationMethod<PutConfigurationRequest, PutConfigurationResponse, PutConfigurationError, Credentials | HttpClient.HttpClient>;
export interface GetDiscoveryRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const GetDiscoveryRequest: Schema.Schema<GetDiscoveryRequest>;
export interface GetDiscoveryResponse {
    schemas: unknown[];
    timestamp: string;
}
export declare const GetDiscoveryResponse: Schema.Schema<GetDiscoveryResponse>;
export type GetDiscoveryError = DefaultErrors | InvalidObjectIdentifier | NotEntitled;
export declare const getDiscovery: API.OperationMethod<GetDiscoveryRequest, GetDiscoveryResponse, GetDiscoveryError, Credentials | HttpClient.HttpClient>;
export interface ListDiscoveryOperationsRequest {
    /** Path param: Identifier. */
    zoneId: string;
    page?: number;
    perPage?: number;
    /** Query param: When `true`, only return API Discovery results that are not saved into API Shield Endpoint Management */
    diff?: boolean;
    /** Query param: Direction to order results. */
    direction?: "asc" | "desc";
    /** Query param: Filter results to only include endpoints containing this pattern. */
    endpoint?: string;
    /** Query param: Filter results to only include the specified hosts. */
    host?: string[];
    /** Query param: Filter results to only include the specified HTTP methods. */
    method?: string[];
    /** Query param: Field to order by */
    order?: "host" | "method" | "endpoint" | "traffic_stats.requests" | "traffic_stats.last_updated";
    /** Query param: Filter results to only include discovery results sourced from a particular discovery engine  - `ML` - Discovered operations that were sourced using ML API Discovery - `SessionIdentifier`  */
    origin?: "ML" | "SessionIdentifier" | "LabelDiscovery";
    /** Query param: Filter results to only include discovery results in a particular state. States are as follows  - `review` - Discovered operations that are not saved into API Shield Endpoint Management -  */
    state?: "review" | "saved" | "ignored";
}
export declare const ListDiscoveryOperationsRequest: Schema.Schema<ListDiscoveryOperationsRequest>;
export interface ListDiscoveryOperationsResponse {
    result: {
        id: string;
        endpoint: string;
        host: string;
        lastUpdated: string;
        method: "GET" | "POST" | "HEAD" | "OPTIONS" | "PUT" | "DELETE" | "CONNECT" | "PATCH" | "TRACE";
        origin: ("ML" | "SessionIdentifier" | "LabelDiscovery")[];
        state: "review" | "saved" | "ignored";
        features?: {
            trafficStats?: {
                lastUpdated: string;
                periodSeconds: number;
                requests: number;
            } | null;
        } | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListDiscoveryOperationsResponse: Schema.Schema<ListDiscoveryOperationsResponse>;
export type ListDiscoveryOperationsError = DefaultErrors;
export declare const listDiscoveryOperations: API.PaginatedOperationMethod<ListDiscoveryOperationsRequest, ListDiscoveryOperationsResponse, ListDiscoveryOperationsError, Credentials | HttpClient.HttpClient>;
export interface PatchDiscoveryOperationRequest {
    operationId: string;
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: Mark state of operation in API Discovery  - `review` - Mark operation as for review - `ignored` - Mark operation as ignored */
    state?: "review" | "ignored";
}
export declare const PatchDiscoveryOperationRequest: Schema.Schema<PatchDiscoveryOperationRequest>;
export interface PatchDiscoveryOperationResponse {
    /** State of operation in API Discovery  - `review` - Operation is not saved into API Shield Endpoint Management - `saved` - Operation is saved into API Shield Endpoint Management - `ignored` - Operation  */
    state?: "review" | "saved" | "ignored" | null;
}
export declare const PatchDiscoveryOperationResponse: Schema.Schema<PatchDiscoveryOperationResponse>;
export type PatchDiscoveryOperationError = DefaultErrors | InvalidObjectIdentifier | NotEntitled;
export declare const patchDiscoveryOperation: API.OperationMethod<PatchDiscoveryOperationRequest, PatchDiscoveryOperationResponse, PatchDiscoveryOperationError, Credentials | HttpClient.HttpClient>;
export interface BulkPatchDiscoveryOperationsRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: */
    body: Record<string, unknown>;
}
export declare const BulkPatchDiscoveryOperationsRequest: Schema.Schema<BulkPatchDiscoveryOperationsRequest>;
export type BulkPatchDiscoveryOperationsResponse = Record<string, unknown>;
export declare const BulkPatchDiscoveryOperationsResponse: Schema.Schema<BulkPatchDiscoveryOperationsResponse>;
export type BulkPatchDiscoveryOperationsError = DefaultErrors | InvalidObjectIdentifier | NotEntitled;
export declare const bulkPatchDiscoveryOperations: API.OperationMethod<BulkPatchDiscoveryOperationsRequest, BulkPatchDiscoveryOperationsResponse, BulkPatchDiscoveryOperationsError, Credentials | HttpClient.HttpClient>;
export interface CreateExpressionTemplateFallthroughRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: List of hosts to be targeted in the expression */
    hosts: string[];
}
export declare const CreateExpressionTemplateFallthroughRequest: Schema.Schema<CreateExpressionTemplateFallthroughRequest>;
export interface CreateExpressionTemplateFallthroughResponse {
    /** WAF Expression for fallthrough */
    expression: string;
    /** Title for the expression */
    title: string;
}
export declare const CreateExpressionTemplateFallthroughResponse: Schema.Schema<CreateExpressionTemplateFallthroughResponse>;
export type CreateExpressionTemplateFallthroughError = DefaultErrors | InvalidObjectIdentifier;
export declare const createExpressionTemplateFallthrough: API.OperationMethod<CreateExpressionTemplateFallthroughRequest, CreateExpressionTemplateFallthroughResponse, CreateExpressionTemplateFallthroughError, Credentials | HttpClient.HttpClient>;
export interface GetOperationRequest {
    operationId: string;
    /** Path param: Identifier. */
    zoneId: string;
    /** Query param: Add feature(s) to the results. The feature name that is given here corresponds to the resulting feature object. Have a look at the top-level object description for more details on the spe */
    feature?: ("thresholds" | "parameter_schemas" | "schema_info")[];
}
export declare const GetOperationRequest: Schema.Schema<GetOperationRequest>;
export interface GetOperationResponse {
    /** The endpoint which can contain path parameter templates in curly braces, each will be replaced from left to right with {varN}, starting with {var1}, during insertion. This will further be Cloudflare-n */
    endpoint: string;
    /** RFC3986-compliant host. */
    host: string;
    lastUpdated: string;
    /** The HTTP method used to access the endpoint. */
    method: "GET" | "POST" | "HEAD" | "OPTIONS" | "PUT" | "DELETE" | "CONNECT" | "PATCH" | "TRACE";
    /** UUID. */
    operationId: string;
    features?: {
        thresholds?: {
            authIdTokens?: number | null;
            dataPoints?: number | null;
            lastUpdated?: string | null;
            p50?: number | null;
            p90?: number | null;
            p99?: number | null;
            periodSeconds?: number | null;
            requests?: number | null;
            suggestedThreshold?: number | null;
        } | null;
    } | {
        parameterSchemas: {
            lastUpdated?: string | null;
            parameterSchemas?: {
                parameters?: unknown[] | null;
                responses?: null;
            } | null;
        };
    } | {
        apiRouting?: {
            lastUpdated?: string | null;
            route?: string | null;
        } | null;
    } | {
        confidenceIntervals?: {
            lastUpdated?: string | null;
            suggestedThreshold?: {
                confidenceIntervals?: {
                    p90?: {
                        lower?: number | null;
                        upper?: number | null;
                    } | null;
                    p95?: {
                        lower?: number | null;
                        upper?: number | null;
                    } | null;
                    p99?: {
                        lower?: number | null;
                        upper?: number | null;
                    } | null;
                } | null;
                mean?: number | null;
            } | null;
        } | null;
    } | {
        schemaInfo?: {
            activeSchema?: {
                id?: string | null;
                createdAt?: string | null;
                isLearned?: boolean | null;
                name?: string | null;
            } | null;
            learnedAvailable?: boolean | null;
            mitigationAction?: "none" | "log" | "block" | null;
        } | null;
    } | null;
}
export declare const GetOperationResponse: Schema.Schema<GetOperationResponse>;
export type GetOperationError = DefaultErrors | InvalidObjectIdentifier | OperationNotFound;
export declare const getOperation: API.OperationMethod<GetOperationRequest, GetOperationResponse, GetOperationError, Credentials | HttpClient.HttpClient>;
export interface ListOperationsRequest {
    /** Path param: Identifier. */
    zoneId: string;
    page?: number;
    perPage?: number;
    /** Query param: Direction to order results. */
    direction?: "asc" | "desc";
    /** Query param: Filter results to only include endpoints containing this pattern. */
    endpoint?: string;
    /** Query param: Add feature(s) to the results. The feature name that is given here corresponds to the resulting feature object. Have a look at the top-level object description for more details on the spe */
    feature?: ("thresholds" | "parameter_schemas" | "schema_info")[];
    /** Query param: Filter results to only include the specified hosts. */
    host?: string[];
    /** Query param: Filter results to only include the specified HTTP methods. */
    method?: string[];
    /** Query param: Field to order by. When requesting a feature, the feature keys are available for ordering as well, e.g., `thresholds.suggested_threshold`. */
    order?: "method" | "host" | "endpoint" | "thresholds.$key";
}
export declare const ListOperationsRequest: Schema.Schema<ListOperationsRequest>;
export interface ListOperationsResponse {
    result: {
        endpoint: string;
        host: string;
        lastUpdated: string;
        method: "GET" | "POST" | "HEAD" | "OPTIONS" | "PUT" | "DELETE" | "CONNECT" | "PATCH" | "TRACE";
        operationId: string;
        features?: {
            thresholds?: {
                authIdTokens?: number | null;
                dataPoints?: number | null;
                lastUpdated?: string | null;
                p50?: number | null;
                p90?: number | null;
                p99?: number | null;
                periodSeconds?: number | null;
                requests?: number | null;
                suggestedThreshold?: number | null;
            } | null;
        } | {
            parameterSchemas: {
                lastUpdated?: string | null;
                parameterSchemas?: {
                    parameters?: unknown[] | null;
                    responses?: null;
                } | null;
            };
        } | {
            apiRouting?: {
                lastUpdated?: string | null;
                route?: string | null;
            } | null;
        } | {
            confidenceIntervals?: {
                lastUpdated?: string | null;
                suggestedThreshold?: {
                    confidenceIntervals?: {
                        p90?: {
                            lower?: number | null;
                            upper?: number | null;
                        } | null;
                        p95?: {
                            lower?: number | null;
                            upper?: number | null;
                        } | null;
                        p99?: {
                            lower?: number | null;
                            upper?: number | null;
                        } | null;
                    } | null;
                    mean?: number | null;
                } | null;
            } | null;
        } | {
            schemaInfo?: {
                activeSchema?: {
                    id?: string | null;
                    createdAt?: string | null;
                    isLearned?: boolean | null;
                    name?: string | null;
                } | null;
                learnedAvailable?: boolean | null;
                mitigationAction?: "none" | "log" | "block" | null;
            } | null;
        } | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListOperationsResponse: Schema.Schema<ListOperationsResponse>;
export type ListOperationsError = DefaultErrors;
export declare const listOperations: API.PaginatedOperationMethod<ListOperationsRequest, ListOperationsResponse, ListOperationsError, Credentials | HttpClient.HttpClient>;
export interface CreateOperationRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: The endpoint which can contain path parameter templates in curly braces, each will be replaced from left to right with {varN}, starting with {var1}, during insertion. This will further be  */
    endpoint: string;
    /** Body param: RFC3986-compliant host. */
    host: string;
    /** Body param: The HTTP method used to access the endpoint. */
    method: "GET" | "POST" | "HEAD" | "OPTIONS" | "PUT" | "DELETE" | "CONNECT" | "PATCH" | "TRACE";
}
export declare const CreateOperationRequest: Schema.Schema<CreateOperationRequest>;
export interface CreateOperationResponse {
    /** The endpoint which can contain path parameter templates in curly braces, each will be replaced from left to right with {varN}, starting with {var1}, during insertion. This will further be Cloudflare-n */
    endpoint: string;
    /** RFC3986-compliant host. */
    host: string;
    lastUpdated: string;
    /** The HTTP method used to access the endpoint. */
    method: "GET" | "POST" | "HEAD" | "OPTIONS" | "PUT" | "DELETE" | "CONNECT" | "PATCH" | "TRACE";
    /** UUID. */
    operationId: string;
    features?: {
        thresholds?: {
            authIdTokens?: number | null;
            dataPoints?: number | null;
            lastUpdated?: string | null;
            p50?: number | null;
            p90?: number | null;
            p99?: number | null;
            periodSeconds?: number | null;
            requests?: number | null;
            suggestedThreshold?: number | null;
        } | null;
    } | {
        parameterSchemas: {
            lastUpdated?: string | null;
            parameterSchemas?: {
                parameters?: unknown[] | null;
                responses?: null;
            } | null;
        };
    } | {
        apiRouting?: {
            lastUpdated?: string | null;
            route?: string | null;
        } | null;
    } | {
        confidenceIntervals?: {
            lastUpdated?: string | null;
            suggestedThreshold?: {
                confidenceIntervals?: {
                    p90?: {
                        lower?: number | null;
                        upper?: number | null;
                    } | null;
                    p95?: {
                        lower?: number | null;
                        upper?: number | null;
                    } | null;
                    p99?: {
                        lower?: number | null;
                        upper?: number | null;
                    } | null;
                } | null;
                mean?: number | null;
            } | null;
        } | null;
    } | {
        schemaInfo?: {
            activeSchema?: {
                id?: string | null;
                createdAt?: string | null;
                isLearned?: boolean | null;
                name?: string | null;
            } | null;
            learnedAvailable?: boolean | null;
            mitigationAction?: "none" | "log" | "block" | null;
        } | null;
    } | null;
}
export declare const CreateOperationResponse: Schema.Schema<CreateOperationResponse>;
export type CreateOperationError = DefaultErrors | InvalidObjectIdentifier;
export declare const createOperation: API.OperationMethod<CreateOperationRequest, CreateOperationResponse, CreateOperationError, Credentials | HttpClient.HttpClient>;
export interface DeleteOperationRequest {
    operationId: string;
    /** Identifier. */
    zoneId: string;
}
export declare const DeleteOperationRequest: Schema.Schema<DeleteOperationRequest>;
export interface DeleteOperationResponse {
    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;
    }[];
    /** Whether the API call was successful. */
    success: true;
}
export declare const DeleteOperationResponse: Schema.Schema<DeleteOperationResponse>;
export type DeleteOperationError = DefaultErrors | InvalidObjectIdentifier | OperationNotFound;
export declare const deleteOperation: API.OperationMethod<DeleteOperationRequest, DeleteOperationResponse, DeleteOperationError, Credentials | HttpClient.HttpClient>;
export interface BulkCreateOperationsRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: */
    body: {
        endpoint: string;
        host: string;
        method: "GET" | "POST" | "HEAD" | "OPTIONS" | "PUT" | "DELETE" | "CONNECT" | "PATCH" | "TRACE";
    }[];
}
export declare const BulkCreateOperationsRequest: Schema.Schema<BulkCreateOperationsRequest>;
export interface BulkCreateOperationsResponse {
    result: {
        endpoint: string;
        host: string;
        lastUpdated: string;
        method: "GET" | "POST" | "HEAD" | "OPTIONS" | "PUT" | "DELETE" | "CONNECT" | "PATCH" | "TRACE";
        operationId: string;
        features?: {
            thresholds?: {
                authIdTokens?: number | null;
                dataPoints?: number | null;
                lastUpdated?: string | null;
                p50?: number | null;
                p90?: number | null;
                p99?: number | null;
                periodSeconds?: number | null;
                requests?: number | null;
                suggestedThreshold?: number | null;
            } | null;
        } | {
            parameterSchemas: {
                lastUpdated?: string | null;
                parameterSchemas?: {
                    parameters?: unknown[] | null;
                    responses?: null;
                } | null;
            };
        } | {
            apiRouting?: {
                lastUpdated?: string | null;
                route?: string | null;
            } | null;
        } | {
            confidenceIntervals?: {
                lastUpdated?: string | null;
                suggestedThreshold?: {
                    confidenceIntervals?: {
                        p90?: {
                            lower?: number | null;
                            upper?: number | null;
                        } | null;
                        p95?: {
                            lower?: number | null;
                            upper?: number | null;
                        } | null;
                        p99?: {
                            lower?: number | null;
                            upper?: number | null;
                        } | null;
                    } | null;
                    mean?: number | null;
                } | null;
            } | null;
        } | {
            schemaInfo?: {
                activeSchema?: {
                    id?: string | null;
                    createdAt?: string | null;
                    isLearned?: boolean | null;
                    name?: string | null;
                } | null;
                learnedAvailable?: boolean | null;
                mitigationAction?: "none" | "log" | "block" | null;
            } | null;
        } | null;
    }[];
}
export declare const BulkCreateOperationsResponse: Schema.Schema<BulkCreateOperationsResponse>;
export type BulkCreateOperationsError = DefaultErrors;
export declare const bulkCreateOperations: API.PaginatedOperationMethod<BulkCreateOperationsRequest, BulkCreateOperationsResponse, BulkCreateOperationsError, Credentials | HttpClient.HttpClient>;
export interface BulkDeleteOperationsRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const BulkDeleteOperationsRequest: Schema.Schema<BulkDeleteOperationsRequest>;
export interface BulkDeleteOperationsResponse {
    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;
    }[];
    /** Whether the API call was successful. */
    success: true;
}
export declare const BulkDeleteOperationsResponse: Schema.Schema<BulkDeleteOperationsResponse>;
export type BulkDeleteOperationsError = DefaultErrors | InvalidObjectIdentifier;
export declare const bulkDeleteOperations: API.OperationMethod<BulkDeleteOperationsRequest, BulkDeleteOperationsResponse, BulkDeleteOperationsError, Credentials | HttpClient.HttpClient>;
export interface GetOperationSchemaValidationRequest {
    operationId: string;
    /** Identifier. */
    zoneId: string;
}
export declare const GetOperationSchemaValidationRequest: Schema.Schema<GetOperationSchemaValidationRequest>;
export interface GetOperationSchemaValidationResponse {
    /** When set, this applies a mitigation action to this operation  - `log` log request when request does not conform to schema for this operation - `block` deny access to the site when request does not con */
    mitigationAction?: "log" | "block" | "none" | null;
    /** UUID. */
    operationId?: string | null;
}
export declare const GetOperationSchemaValidationResponse: Schema.Schema<GetOperationSchemaValidationResponse>;
export type GetOperationSchemaValidationError = DefaultErrors | InvalidObjectIdentifier | OperationNotFound;
export declare const getOperationSchemaValidation: API.OperationMethod<GetOperationSchemaValidationRequest, GetOperationSchemaValidationResponse, GetOperationSchemaValidationError, Credentials | HttpClient.HttpClient>;
export interface PutOperationSchemaValidationRequest {
    operationId: string;
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: When set, this applies a mitigation action to this operation  - `log` log request when request does not conform to schema for this operation - `block` deny access to the site when request  */
    mitigationAction?: "log" | "block" | "none" | null;
}
export declare const PutOperationSchemaValidationRequest: Schema.Schema<PutOperationSchemaValidationRequest>;
export interface PutOperationSchemaValidationResponse {
    /** When set, this applies a mitigation action to this operation  - `log` log request when request does not conform to schema for this operation - `block` deny access to the site when request does not con */
    mitigationAction?: "log" | "block" | "none" | null;
    /** UUID. */
    operationId?: string | null;
}
export declare const PutOperationSchemaValidationResponse: Schema.Schema<PutOperationSchemaValidationResponse>;
export type PutOperationSchemaValidationError = DefaultErrors | InvalidObjectIdentifier | OperationNotFound;
export declare const putOperationSchemaValidation: API.OperationMethod<PutOperationSchemaValidationRequest, PutOperationSchemaValidationResponse, PutOperationSchemaValidationError, Credentials | HttpClient.HttpClient>;
export interface PatchOperationSchemaValidationRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: */
    settingsMultipleRequest: Record<string, unknown>;
}
export declare const PatchOperationSchemaValidationRequest: Schema.Schema<PatchOperationSchemaValidationRequest>;
export type PatchOperationSchemaValidationResponse = Record<string, unknown>;
export declare const PatchOperationSchemaValidationResponse: Schema.Schema<PatchOperationSchemaValidationResponse>;
export type PatchOperationSchemaValidationError = DefaultErrors | InvalidObjectIdentifier;
export declare const patchOperationSchemaValidation: API.OperationMethod<PatchOperationSchemaValidationRequest, PatchOperationSchemaValidationResponse, PatchOperationSchemaValidationError, Credentials | HttpClient.HttpClient>;
export interface ListSchemasRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Query param: Add feature(s) to the results. The feature name that is given here corresponds to the resulting feature object. Have a look at the top-level object description for more details on the spe */
    feature?: ("thresholds" | "parameter_schemas" | "schema_info")[];
    /** Query param: Receive schema only for the given host(s). */
    host?: string[];
}
export declare const ListSchemasRequest: Schema.Schema<ListSchemasRequest>;
export interface ListSchemasResponse {
    schemas?: unknown[] | null;
    timestamp?: string | null;
}
export declare const ListSchemasResponse: Schema.Schema<ListSchemasResponse>;
export type ListSchemasError = DefaultErrors | InvalidObjectIdentifier;
export declare const listSchemas: API.OperationMethod<ListSchemasRequest, ListSchemasResponse, ListSchemasError, Credentials | HttpClient.HttpClient>;
export interface GetSettingSchemaValidationRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const GetSettingSchemaValidationRequest: Schema.Schema<GetSettingSchemaValidationRequest>;
export interface GetSettingSchemaValidationResponse {
    /** The default mitigation action used when there is no mitigation action defined on the operation  Mitigation actions are as follows:  - `log` - log request when request does not conform to schema - `blo */
    validationDefaultMitigationAction?: "none" | "log" | "block" | null;
    /** When set, this overrides both zone level and operation level mitigation actions.  - `none` will skip running schema validation entirely for the request - `null` indicates that no override is in place */
    validationOverrideMitigationAction?: "none" | null;
}
export declare const GetSettingSchemaValidationResponse: Schema.Schema<GetSettingSchemaValidationResponse>;
export type GetSettingSchemaValidationError = DefaultErrors | InvalidObjectIdentifier;
export declare const getSettingSchemaValidation: API.OperationMethod<GetSettingSchemaValidationRequest, GetSettingSchemaValidationResponse, GetSettingSchemaValidationError, Credentials | HttpClient.HttpClient>;
export interface PutSettingSchemaValidationRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: The default mitigation action used when there is no mitigation action defined on the operation  Mitigation actions are as follows:  - `log` - log request when request does not conform to s */
    validationDefaultMitigationAction: "none" | "log" | "block";
    /** Body param: When set, this overrides both zone level and operation level mitigation actions.  - `none` will skip running schema validation entirely for the request - `null` indicates that no override  */
    validationOverrideMitigationAction?: "none" | "disable_override" | null;
}
export declare const PutSettingSchemaValidationRequest: Schema.Schema<PutSettingSchemaValidationRequest>;
export interface PutSettingSchemaValidationResponse {
    /** The default mitigation action used when there is no mitigation action defined on the operation  Mitigation actions are as follows:  - `log` - log request when request does not conform to schema - `blo */
    validationDefaultMitigationAction?: "none" | "log" | "block" | null;
    /** When set, this overrides both zone level and operation level mitigation actions.  - `none` will skip running schema validation entirely for the request - `null` indicates that no override is in place */
    validationOverrideMitigationAction?: "none" | null;
}
export declare const PutSettingSchemaValidationResponse: Schema.Schema<PutSettingSchemaValidationResponse>;
export type PutSettingSchemaValidationError = DefaultErrors | InvalidObjectIdentifier;
export declare const putSettingSchemaValidation: API.OperationMethod<PutSettingSchemaValidationRequest, PutSettingSchemaValidationResponse, PutSettingSchemaValidationError, Credentials | HttpClient.HttpClient>;
export interface PatchSettingSchemaValidationRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: The default mitigation action used when there is no mitigation action defined on the operation Mitigation actions are as follows:  - `log` - log request when request does not conform to sc */
    validationDefaultMitigationAction?: "none" | "log" | "block" | null;
    /** Body param: When set, this overrides both zone level and operation level mitigation actions.  - `none` will skip running schema validation entirely for the request  To clear any override, use the spec */
    validationOverrideMitigationAction?: "none" | "disable_override" | null;
}
export declare const PatchSettingSchemaValidationRequest: Schema.Schema<PatchSettingSchemaValidationRequest>;
export interface PatchSettingSchemaValidationResponse {
    /** The default mitigation action used when there is no mitigation action defined on the operation  Mitigation actions are as follows:  - `log` - log request when request does not conform to schema - `blo */
    validationDefaultMitigationAction?: "none" | "log" | "block" | null;
    /** When set, this overrides both zone level and operation level mitigation actions.  - `none` will skip running schema validation entirely for the request - `null` indicates that no override is in place */
    validationOverrideMitigationAction?: "none" | null;
}
export declare const PatchSettingSchemaValidationResponse: Schema.Schema<PatchSettingSchemaValidationResponse>;
export type PatchSettingSchemaValidationError = DefaultErrors | InvalidObjectIdentifier;
export declare const patchSettingSchemaValidation: API.OperationMethod<PatchSettingSchemaValidationRequest, PatchSettingSchemaValidationResponse, PatchSettingSchemaValidationError, Credentials | HttpClient.HttpClient>;
export interface GetUserSchemaRequest {
    schemaId: string;
    /** Path param: Identifier. */
    zoneId: string;
    /** Query param: Omit the source-files of schemas and only retrieve their meta-data. */
    omitSource?: boolean;
}
export declare const GetUserSchemaRequest: Schema.Schema<GetUserSchemaRequest>;
export interface GetUserSchemaResponse {
    createdAt: string;
    /** Kind of schema */
    kind: "openapi_v3";
    /** Name of the schema */
    name: string;
    /** UUID. */
    schemaId: string;
    /** Source of the schema */
    source?: string | null;
    /** Flag whether schema is enabled for validation. */
    validationEnabled?: boolean | null;
}
export declare const GetUserSchemaResponse: Schema.Schema<GetUserSchemaResponse>;
export type GetUserSchemaError = DefaultErrors | InvalidObjectIdentifier | SchemaNotFound;
export declare const getUserSchema: API.OperationMethod<GetUserSchemaRequest, GetUserSchemaResponse, GetUserSchemaError, Credentials | HttpClient.HttpClient>;
export interface ListUserSchemasRequest {
    /** Path param: Identifier. */
    zoneId: string;
    page?: number;
    perPage?: number;
    /** Query param: Omit the source-files of schemas and only retrieve their meta-data. */
    omitSource?: boolean;
    /** Query param: Flag whether schema is enabled for validation. */
    validationEnabled?: boolean;
}
export declare const ListUserSchemasRequest: Schema.Schema<ListUserSchemasRequest>;
export interface ListUserSchemasResponse {
    result: {
        createdAt: string;
        kind: "openapi_v3";
        name: string;
        schemaId: string;
        source?: string | null;
        validationEnabled?: boolean | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListUserSchemasResponse: Schema.Schema<ListUserSchemasResponse>;
export type ListUserSchemasError = DefaultErrors;
export declare const listUserSchemas: API.PaginatedOperationMethod<ListUserSchemasRequest, ListUserSchemasResponse, ListUserSchemasError, Credentials | HttpClient.HttpClient>;
export interface CreateUserSchemaRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: Schema file bytes */
    file: File | Blob;
    /** Body param: Kind of schema */
    kind: "openapi_v3";
    /** Body param: Name of the schema */
    name?: string;
    /** Body param: Flag whether schema is enabled for validation. */
    validationEnabled?: true | false;
}
export declare const CreateUserSchemaRequest: Schema.Schema<CreateUserSchemaRequest>;
export interface CreateUserSchemaResponse {
    schema: {
        createdAt: string;
        kind: "openapi_v3";
        name: string;
        schemaId: string;
        source?: string | null;
        validationEnabled?: boolean | null;
    };
    uploadDetails?: {
        warnings?: {
            code: number;
            locations?: string[] | null;
            message?: string | null;
        }[] | null;
    } | null;
}
export declare const CreateUserSchemaResponse: Schema.Schema<CreateUserSchemaResponse>;
export type CreateUserSchemaError = DefaultErrors | InvalidObjectIdentifier;
export declare const createUserSchema: API.OperationMethod<CreateUserSchemaRequest, CreateUserSchemaResponse, CreateUserSchemaError, Credentials | HttpClient.HttpClient>;
export interface PatchUserSchemaRequest {
    schemaId: string;
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: Flag whether schema is enabled for validation. */
    validationEnabled?: true;
}
export declare const PatchUserSchemaRequest: Schema.Schema<PatchUserSchemaRequest>;
export interface PatchUserSchemaResponse {
    createdAt: string;
    /** Kind of schema */
    kind: "openapi_v3";
    /** Name of the schema */
    name: string;
    /** UUID. */
    schemaId: string;
    /** Source of the schema */
    source?: string | null;
    /** Flag whether schema is enabled for validation. */
    validationEnabled?: boolean | null;
}
export declare const PatchUserSchemaResponse: Schema.Schema<PatchUserSchemaResponse>;
export type PatchUserSchemaError = DefaultErrors | InvalidObjectIdentifier | SchemaNotFound;
export declare const patchUserSchema: API.OperationMethod<PatchUserSchemaRequest, PatchUserSchemaResponse, PatchUserSchemaError, Credentials | HttpClient.HttpClient>;
export interface DeleteUserSchemaRequest {
    schemaId: string;
    /** Identifier. */
    zoneId: string;
}
export declare const DeleteUserSchemaRequest: Schema.Schema<DeleteUserSchemaRequest>;
export interface DeleteUserSchemaResponse {
    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;
    }[];
    /** Whether the API call was successful. */
    success: true;
}
export declare const DeleteUserSchemaResponse: Schema.Schema<DeleteUserSchemaResponse>;
export type DeleteUserSchemaError = DefaultErrors | InvalidObjectIdentifier | SchemaNotFound;
export declare const deleteUserSchema: API.OperationMethod<DeleteUserSchemaRequest, DeleteUserSchemaResponse, DeleteUserSchemaError, Credentials | HttpClient.HttpClient>;
export interface ListUserSchemaHostsRequest {
    /** Path param: Identifier. */
    zoneId: string;
    page?: number;
    perPage?: number;
}
export declare const ListUserSchemaHostsRequest: Schema.Schema<ListUserSchemaHostsRequest>;
export interface ListUserSchemaHostsResponse {
    result: {
        createdAt: string;
        hosts: string[];
        name: string;
        schemaId: string;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListUserSchemaHostsResponse: Schema.Schema<ListUserSchemaHostsResponse>;
export type ListUserSchemaHostsError = DefaultErrors;
export declare const listUserSchemaHosts: API.PaginatedOperationMethod<ListUserSchemaHostsRequest, ListUserSchemaHostsResponse, ListUserSchemaHostsError, Credentials | HttpClient.HttpClient>;
export interface ListUserSchemaOperationsRequest {
    schemaId: string;
    /** Path param: Identifier. */
    zoneId: string;
    page?: number;
    perPage?: number;
    /** Query param: Filter results to only include endpoints containing this pattern. */
    endpoint?: string;
    /** Query param: Add feature(s) to the results. The feature name that is given here corresponds to the resulting feature object. Have a look at the top-level object description for more details on the spe */
    feature?: ("thresholds" | "parameter_schemas" | "schema_info")[];
    /** Query param: Filter results to only include the specified hosts. */
    host?: string[];
    /** Query param: Filter results to only include the specified HTTP methods. */
    method?: string[];
    /** Query param: Filter results by whether operations exist in API Shield Endpoint Management or not. `new` will just return operations from the schema that do not exist in API Shield Endpoint Management. */
    operationStatus?: "new" | "existing";
}
export declare const ListUserSchemaOperationsRequest: Schema.Schema<ListUserSchemaOperationsRequest>;
export interface ListUserSchemaOperationsResponse {
    result: ({
        endpoint: string;
        host: string;
        lastUpdated: string;
        method: "GET" | "POST" | "HEAD" | "OPTIONS" | "PUT" | "DELETE" | "CONNECT" | "PATCH" | "TRACE";
        operationId: string;
        features?: {
            thresholds?: {
                authIdTokens?: number | null;
                dataPoints?: number | null;
                lastUpdated?: string | null;
                p50?: number | null;
                p90?: number | null;
                p99?: number | null;
                periodSeconds?: number | null;
                requests?: number | null;
                suggestedThreshold?: number | null;
            } | null;
        } | {
            parameterSchemas: {
                lastUpdated?: string | null;
                parameterSchemas?: {
                    parameters?: unknown[] | null;
                    responses?: null;
                } | null;
            };
        } | {
            apiRouting?: {
                lastUpdated?: string | null;
                route?: string | null;
            } | null;
        } | {
            confidenceIntervals?: {
                lastUpdated?: string | null;
                suggestedThreshold?: {
                    confidenceIntervals?: {
                        p90?: {
                            lower?: number | null;
                            upper?: number | null;
                        } | null;
                        p95?: {
                            lower?: number | null;
                            upper?: number | null;
                        } | null;
                        p99?: {
                            lower?: number | null;
                            upper?: number | null;
                        } | null;
                    } | null;
                    mean?: number | null;
                } | null;
            } | null;
        } | {
            schemaInfo?: {
                activeSchema?: {
                    id?: string | null;
                    createdAt?: string | null;
                    isLearned?: boolean | null;
                    name?: string | null;
                } | null;
                learnedAvailable?: boolean | null;
                mitigationAction?: "none" | "log" | "block" | null;
            } | null;
        } | null;
    } | {
        endpoint: string;
        host: string;
        method: "GET" | "POST" | "HEAD" | "OPTIONS" | "PUT" | "DELETE" | "CONNECT" | "PATCH" | "TRACE";
    })[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListUserSchemaOperationsResponse: Schema.Schema<ListUserSchemaOperationsResponse>;
export type ListUserSchemaOperationsError = DefaultErrors;
export declare const listUserSchemaOperations: API.PaginatedOperationMethod<ListUserSchemaOperationsRequest, ListUserSchemaOperationsResponse, ListUserSchemaOperationsError, Credentials | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=api-gateway.d.ts.map