/**
 * Cloudflare SCHEMA-VALIDATION API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service schema-validation
 */
import * as Schema from "effect/Schema";
import type * as HttpClient from "effect/unstable/http/HttpClient";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import { type DefaultErrors } from "../errors.ts";
export interface GetSchemaRequest {
    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 GetSchemaRequest: Schema.Schema<GetSchemaRequest>;
export interface GetSchemaResponse {
    createdAt: string;
    /** The kind of the schema */
    kind: "openapi_v3";
    /** A human-readable name for the schema */
    name: string;
    /** A unique identifier of this schema */
    schemaId: string;
    /** The raw schema, e.g., the OpenAPI schema, either as JSON or YAML */
    source: string;
    /** An indicator if this schema is enabled */
    validationEnabled?: boolean | null;
}
export declare const GetSchemaResponse: Schema.Schema<GetSchemaResponse>;
export type GetSchemaError = DefaultErrors;
export declare const getSchema: API.OperationMethod<GetSchemaRequest, GetSchemaResponse, GetSchemaError, Credentials | HttpClient.HttpClient>;
export interface ListSchemasRequest {
    /** 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: Filter for enabled schemas */
    validationEnabled?: boolean;
}
export declare const ListSchemasRequest: Schema.Schema<ListSchemasRequest>;
export interface ListSchemasResponse {
    result: {
        createdAt: string;
        kind: "openapi_v3";
        name: string;
        schemaId: string;
        source: string;
        validationEnabled?: boolean | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListSchemasResponse: Schema.Schema<ListSchemasResponse>;
export type ListSchemasError = DefaultErrors;
export declare const listSchemas: API.PaginatedOperationMethod<ListSchemasRequest, ListSchemasResponse, ListSchemasError, Credentials | HttpClient.HttpClient>;
export interface CreateSchemaRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: The kind of the schema */
    kind: "openapi_v3";
    /** Body param: A human-readable name for the schema */
    name: string;
    /** Body param: The raw schema, e.g., the OpenAPI schema, either as JSON or YAML */
    source: string;
    /** Body param: An indicator if this schema is enabled */
    validationEnabled: boolean;
}
export declare const CreateSchemaRequest: Schema.Schema<CreateSchemaRequest>;
export interface CreateSchemaResponse {
    createdAt: string;
    /** The kind of the schema */
    kind: "openapi_v3";
    /** A human-readable name for the schema */
    name: string;
    /** A unique identifier of this schema */
    schemaId: string;
    /** The raw schema, e.g., the OpenAPI schema, either as JSON or YAML */
    source: string;
    /** An indicator if this schema is enabled */
    validationEnabled?: boolean | null;
}
export declare const CreateSchemaResponse: Schema.Schema<CreateSchemaResponse>;
export type CreateSchemaError = DefaultErrors;
export declare const createSchema: API.OperationMethod<CreateSchemaRequest, CreateSchemaResponse, CreateSchemaError, Credentials | HttpClient.HttpClient>;
export interface PatchSchemaRequest {
    schemaId: string;
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: Flag whether schema is enabled for validation. */
    validationEnabled?: boolean;
}
export declare const PatchSchemaRequest: Schema.Schema<PatchSchemaRequest>;
export interface PatchSchemaResponse {
    createdAt: string;
    /** The kind of the schema */
    kind: "openapi_v3";
    /** A human-readable name for the schema */
    name: string;
    /** A unique identifier of this schema */
    schemaId: string;
    /** The raw schema, e.g., the OpenAPI schema, either as JSON or YAML */
    source: string;
    /** An indicator if this schema is enabled */
    validationEnabled?: boolean | null;
}
export declare const PatchSchemaResponse: Schema.Schema<PatchSchemaResponse>;
export type PatchSchemaError = DefaultErrors;
export declare const patchSchema: API.OperationMethod<PatchSchemaRequest, PatchSchemaResponse, PatchSchemaError, Credentials | HttpClient.HttpClient>;
export interface DeleteSchemaRequest {
    schemaId: string;
    /** Identifier. */
    zoneId: string;
}
export declare const DeleteSchemaRequest: Schema.Schema<DeleteSchemaRequest>;
export interface DeleteSchemaResponse {
    /** The ID of the schema that was just deleted */
    id: string;
}
export declare const DeleteSchemaResponse: Schema.Schema<DeleteSchemaResponse>;
export type DeleteSchemaError = DefaultErrors;
export declare const deleteSchema: API.OperationMethod<DeleteSchemaRequest, DeleteSchemaResponse, DeleteSchemaError, Credentials | HttpClient.HttpClient>;
export interface GetSettingRequest {
    /** Identifier. */
    zoneId: string;
}
export declare const GetSettingRequest: Schema.Schema<GetSettingRequest>;
export interface GetSettingResponse {
    /** The default mitigation action used  Mitigation actions are as follows:  - `log` - log request when request does not conform to schema - `block` - deny access to the site when request does not conform  */
    validationDefaultMitigationAction: "none" | "log" | "block";
    /** When not null, this overrides global both zone level and operation level mitigation actions. This can serve as a quick way to disable schema validation for the whole zone.  - `"none"` will skip runnin */
    validationOverrideMitigationAction?: "none" | null;
}
export declare const GetSettingResponse: Schema.Schema<GetSettingResponse>;
export type GetSettingError = DefaultErrors;
export declare const getSetting: API.OperationMethod<GetSettingRequest, GetSettingResponse, GetSettingError, Credentials | HttpClient.HttpClient>;
export interface PutSettingRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: The default mitigation action used Mitigation actions are as follows:  - `"log"` - log request when request does not conform to schema - `"block"` - deny access to the site when request do */
    validationDefaultMitigationAction: "none" | "log" | "block";
    /** Body param: When set, this overrides both zone level and operation level mitigation actions.  - `"none"` - skip running schema validation entirely for the request - `null` - clears any existing overri */
    validationOverrideMitigationAction?: "none" | null;
}
export declare const PutSettingRequest: Schema.Schema<PutSettingRequest>;
export interface PutSettingResponse {
    /** The default mitigation action used  Mitigation actions are as follows:  - `log` - log request when request does not conform to schema - `block` - deny access to the site when request does not conform  */
    validationDefaultMitigationAction: "none" | "log" | "block";
    /** When not null, this overrides global both zone level and operation level mitigation actions. This can serve as a quick way to disable schema validation for the whole zone.  - `"none"` will skip runnin */
    validationOverrideMitigationAction?: "none" | null;
}
export declare const PutSettingResponse: Schema.Schema<PutSettingResponse>;
export type PutSettingError = DefaultErrors;
export declare const putSetting: API.OperationMethod<PutSettingRequest, PutSettingResponse, PutSettingError, Credentials | HttpClient.HttpClient>;
export interface PatchSettingRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: The default mitigation action used Mitigation actions are as follows:  - `"log"` - log request when request does not conform to schema - `"block"` - deny access to the site when request do */
    validationDefaultMitigationAction?: "none" | "log" | "block";
    /** Body param: When set, this overrides both zone level and operation level mitigation actions.  - `"none"` - skip running schema validation entirely for the request - `null` - clears any existing overri */
    validationOverrideMitigationAction?: "none" | null;
}
export declare const PatchSettingRequest: Schema.Schema<PatchSettingRequest>;
export interface PatchSettingResponse {
    /** The default mitigation action used  Mitigation actions are as follows:  - `log` - log request when request does not conform to schema - `block` - deny access to the site when request does not conform  */
    validationDefaultMitigationAction: "none" | "log" | "block";
    /** When not null, this overrides global both zone level and operation level mitigation actions. This can serve as a quick way to disable schema validation for the whole zone.  - `"none"` will skip runnin */
    validationOverrideMitigationAction?: "none" | null;
}
export declare const PatchSettingResponse: Schema.Schema<PatchSettingResponse>;
export type PatchSettingError = DefaultErrors;
export declare const patchSetting: API.OperationMethod<PatchSettingRequest, PatchSettingResponse, PatchSettingError, Credentials | HttpClient.HttpClient>;
export interface GetSettingOperationRequest {
    operationId: string;
    /** Identifier. */
    zoneId: string;
}
export declare const GetSettingOperationRequest: Schema.Schema<GetSettingOperationRequest>;
export interface GetSettingOperationResponse {
    /** When set, this applies a mitigation action to this operation which supersedes a global schema validation setting just for this operation  - `"log"` - log request when request does not conform to schem */
    mitigationAction: "log" | "block" | "none";
    /** UUID. */
    operationId: string;
}
export declare const GetSettingOperationResponse: Schema.Schema<GetSettingOperationResponse>;
export type GetSettingOperationError = DefaultErrors;
export declare const getSettingOperation: API.OperationMethod<GetSettingOperationRequest, GetSettingOperationResponse, GetSettingOperationError, Credentials | HttpClient.HttpClient>;
export interface ListSettingOperationsRequest {
    /** Path param: Identifier. */
    zoneId: string;
    page?: number;
    perPage?: number;
}
export declare const ListSettingOperationsRequest: Schema.Schema<ListSettingOperationsRequest>;
export interface ListSettingOperationsResponse {
    result: {
        mitigationAction: "log" | "block" | "none";
        operationId: string;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListSettingOperationsResponse: Schema.Schema<ListSettingOperationsResponse>;
export type ListSettingOperationsError = DefaultErrors;
export declare const listSettingOperations: API.PaginatedOperationMethod<ListSettingOperationsRequest, ListSettingOperationsResponse, ListSettingOperationsError, Credentials | HttpClient.HttpClient>;
export interface PutSettingOperationRequest {
    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  */
    mitigationAction: "log" | "block" | "none" | null;
}
export declare const PutSettingOperationRequest: Schema.Schema<PutSettingOperationRequest>;
export interface PutSettingOperationResponse {
    /** When set, this applies a mitigation action to this operation which supersedes a global schema validation setting just for this operation  - `"log"` - log request when request does not conform to schem */
    mitigationAction: "log" | "block" | "none";
    /** UUID. */
    operationId: string;
}
export declare const PutSettingOperationResponse: Schema.Schema<PutSettingOperationResponse>;
export type PutSettingOperationError = DefaultErrors;
export declare const putSettingOperation: API.OperationMethod<PutSettingOperationRequest, PutSettingOperationResponse, PutSettingOperationError, Credentials | HttpClient.HttpClient>;
export interface DeleteSettingOperationRequest {
    operationId: string;
    /** Identifier. */
    zoneId: string;
}
export declare const DeleteSettingOperationRequest: Schema.Schema<DeleteSettingOperationRequest>;
export interface DeleteSettingOperationResponse {
    /** UUID. */
    operationId?: string | null;
}
export declare const DeleteSettingOperationResponse: Schema.Schema<DeleteSettingOperationResponse>;
export type DeleteSettingOperationError = DefaultErrors;
export declare const deleteSettingOperation: API.OperationMethod<DeleteSettingOperationRequest, DeleteSettingOperationResponse, DeleteSettingOperationError, Credentials | HttpClient.HttpClient>;
export interface BulkPatchSettingOperationsRequest {
    /** Path param: Identifier. */
    zoneId: string;
    /** Body param: */
    body: Record<string, unknown>;
}
export declare const BulkPatchSettingOperationsRequest: Schema.Schema<BulkPatchSettingOperationsRequest>;
export type BulkPatchSettingOperationsResponse = Record<string, unknown>;
export declare const BulkPatchSettingOperationsResponse: Schema.Schema<BulkPatchSettingOperationsResponse>;
export type BulkPatchSettingOperationsError = DefaultErrors;
export declare const bulkPatchSettingOperations: API.OperationMethod<BulkPatchSettingOperationsRequest, BulkPatchSettingOperationsResponse, BulkPatchSettingOperationsError, Credentials | HttpClient.HttpClient>;
//# sourceMappingURL=schema-validation.d.ts.map