@distilled.cloud/cloudflare 0.0.0 → 0.2.0-alpha

package/lib/services/api-gateway.d.ts

@@ -0,0 +1,830 @@
+/**
+ * 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";
+import { type DefaultErrors } from "../errors";
+declare const InvalidObjectIdentifier_base: Schema.ErrorClass<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.ErrorClass<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.ErrorClass<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.ErrorClass<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;
+    /** 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 type ListDiscoveryOperationsResponse = unknown;
+export declare const ListDiscoveryOperationsResponse: Schema.Schema<unknown>;
+export type ListDiscoveryOperationsError = DefaultErrors;
+export declare const listDiscoveryOperations: API.OperationMethod<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;
+    /** 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 type ListOperationsResponse = {
+    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 ListOperationsResponse: Schema.Schema<ListOperationsResponse>;
+export type ListOperationsError = DefaultErrors;
+export declare const listOperations: API.OperationMethod<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: unknown;
+    messages: unknown;
+    /** 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 type BulkCreateOperationsResponse = {
+    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.OperationMethod<BulkCreateOperationsRequest, BulkCreateOperationsResponse, BulkCreateOperationsError, Credentials | HttpClient.HttpClient>;
+export interface BulkDeleteOperationsRequest {
+    /** Identifier. */
+    zoneId: string;
+}
+export declare const BulkDeleteOperationsRequest: Schema.Schema<BulkDeleteOperationsRequest>;
+export interface BulkDeleteOperationsResponse {
+    errors: unknown;
+    messages: unknown;
+    /** 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: 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 type GetSettingSchemaValidationResponse = unknown;
+export declare const GetSettingSchemaValidationResponse: Schema.Schema<unknown>;
+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 type PutSettingSchemaValidationResponse = unknown;
+export declare const PutSettingSchemaValidationResponse: Schema.Schema<unknown>;
+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 type PatchSettingSchemaValidationResponse = unknown;
+export declare const PatchSettingSchemaValidationResponse: Schema.Schema<unknown>;
+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;
+    /** 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 type ListUserSchemasResponse = {
+    createdAt: string;
+    kind: "openapi_v3";
+    name: string;
+    schemaId: string;
+    source?: string | null;
+    validationEnabled?: boolean | null;
+}[];
+export declare const ListUserSchemasResponse: Schema.Schema<ListUserSchemasResponse>;
+export type ListUserSchemasError = DefaultErrors;
+export declare const listUserSchemas: API.OperationMethod<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: unknown;
+    messages: unknown;
+    /** 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;
+}
+export declare const ListUserSchemaHostsRequest: Schema.Schema<ListUserSchemaHostsRequest>;
+export type ListUserSchemaHostsResponse = {
+    createdAt: string;
+    hosts: string[];
+    name: string;
+    schemaId: string;
+}[];
+export declare const ListUserSchemaHostsResponse: Schema.Schema<ListUserSchemaHostsResponse>;
+export type ListUserSchemaHostsError = DefaultErrors;
+export declare const listUserSchemaHosts: API.OperationMethod<ListUserSchemaHostsRequest, ListUserSchemaHostsResponse, ListUserSchemaHostsError, Credentials | HttpClient.HttpClient>;
+export interface ListUserSchemaOperationsRequest {
+    schemaId: string;
+    /** Path param: Identifier. */
+    zoneId: string;
+    /** 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 type ListUserSchemaOperationsResponse = ({
+    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";
+})[];
+export declare const ListUserSchemaOperationsResponse: Schema.Schema<ListUserSchemaOperationsResponse>;
+export type ListUserSchemaOperationsError = DefaultErrors;
+export declare const listUserSchemaOperations: API.OperationMethod<ListUserSchemaOperationsRequest, ListUserSchemaOperationsResponse, ListUserSchemaOperationsError, Credentials | HttpClient.HttpClient>;
+export {};
+//# sourceMappingURL=api-gateway.d.ts.map