// AUTO-GENERATED by scripts/generate.ts from .generated-specs. Do not edit.
import * as S from "@distilled.cloud/core/schema";
import * as API from "@distilled.cloud/core/api";
import * as T from "../traits.ts";
import {
  CloudflareProtocol,
  CloudflarePaginatedProtocol,
  type CloudflareOpError,
  type CloudflareOpContext,
} from "../protocol.ts";
import { cloudflarePaginate, ResultInfo } from "../pagination.ts";
import { CloudflareError, CloudflareRateLimited } from "../errors.ts";
import * as Retry from "../retry.ts";

export type { CloudflareOpError, CloudflareOpContext };

/** Fallback camelCase→wire mapping for opaque content (mined from the distilled SDK). */
const KEY_DICTIONARY: Record<string, string | ReadonlyArray<string>> = {
  createdAt: "created_at",
  mitigationAction: "mitigation_action",
  operationId: "operation_id",
  perPage: "per_page",
  resultInfo: "result_info",
  schemaId: "schema_id",
  totalCount: "total_count",
  validationDefaultMitigationAction: "validation_default_mitigation_action",
  validationEnabled: "validation_enabled",
  validationOverrideMitigationAction: "validation_override_mitigation_action",
};

export class Forbidden
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<Forbidden>()("Forbidden", {
      code: S.Number,
      message: S.String,
    }),
    [{ status: 403 }],
  ) {}

export class InvalidSchema
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<InvalidSchema>()("InvalidSchema", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 50010 }],
  ) {}

export class OperationNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<OperationNotFound>()("OperationNotFound", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 10404 }],
  ) {}

export class SchemaNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<SchemaNotFound>()("SchemaNotFound", {
      code: S.Number,
      message: S.String,
    }),
    [{ code: 19400 }],
  ) {}

export class UnentitledMitigationAction
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<UnentitledMitigationAction>()(
      "UnentitledMitigationAction",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [{ code: 11400 }],
  ) {}

export class ZonePurged
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<ZonePurged>()("ZonePurged", {
      code: S.Number,
      message: S.String,
    }),
    [{ message: { includes: "has been purged" } }],
  ) {}

export type SettingsOperationsBulkEditRequestBodyValueMitigationAction =
  | "none"
  | "log"
  | "block";
export const SettingsOperationsBulkEditRequestBodyValueMitigationAction =
  /*@__PURE__*/ S.String;

export interface SettingsOperationsBulkEditRequestBodyValue {
  /** Mitigation actions are as follows: */
  mitigationAction?:
    | SettingsOperationsBulkEditRequestBodyValueMitigationAction
    | (string & {});
}
export const SettingsOperationsBulkEditRequestBodyValue =
  /*@__PURE__*/ S.suspend(() =>
    S.Struct({
      mitigationAction: S.optional(
        SettingsOperationsBulkEditRequestBodyValueMitigationAction.pipe(
          T.Body("mitigation_action"),
        ),
      ),
    }),
  ).annotate({
    identifier: "SettingsOperationsBulkEditRequestBodyValue",
  }) as any as S.Schema<SettingsOperationsBulkEditRequestBodyValue>;

export type SettingsOperationsBulkEditRequestBodyMap = {
  [key: string]: SettingsOperationsBulkEditRequestBodyValue | undefined;
};
export const SettingsOperationsBulkEditRequestBodyMap = /*@__PURE__*/ S.Record(
  S.String,
  SettingsOperationsBulkEditRequestBodyValue,
) as any as S.Schema<SettingsOperationsBulkEditRequestBodyMap>;

export interface BulkPatchSettingOperationsRequest {
  /** Identifier. */
  zoneId: string;
  body: SettingsOperationsBulkEditRequestBodyMap;
}
export const BulkPatchSettingOperationsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    body: SettingsOperationsBulkEditRequestBodyMap.pipe(T.HttpBody()),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/zones/{zone_id}/schema_validation/settings/operations",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "BulkPatchSettingOperationsRequest",
}) as any as S.Schema<BulkPatchSettingOperationsRequest>;

export type SettingsOperationsBulkEditResultValueMitigationAction =
  | "log"
  | "block"
  | "none";
export const SettingsOperationsBulkEditResultValueMitigationAction =
  /*@__PURE__*/ S.String;

export interface SettingsOperationsBulkEditResultValue {
  /** When set, this applies a mitigation action to this operation which supersedes a global schema validation setting just for this operation */
  mitigationAction: SettingsOperationsBulkEditResultValueMitigationAction;
  /** UUID. */
  operationId: string;
}
export const SettingsOperationsBulkEditResultValue = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      mitigationAction:
        SettingsOperationsBulkEditResultValueMitigationAction.pipe(
          T.Body("mitigation_action"),
        ),
      operationId: S.String.pipe(T.Body("operation_id")),
    }),
).annotate({
  identifier: "SettingsOperationsBulkEditResultValue",
}) as any as S.Schema<SettingsOperationsBulkEditResultValue>;

export type SettingsOperationsBulkEditResultMap = {
  [key: string]: SettingsOperationsBulkEditResultValue | undefined;
};
export const SettingsOperationsBulkEditResultMap = /*@__PURE__*/ S.Record(
  S.String,
  SettingsOperationsBulkEditResultValue,
) as any as S.Schema<SettingsOperationsBulkEditResultMap>;

export type BulkPatchSettingOperationsResponse =
  SettingsOperationsBulkEditResultMap;
export const BulkPatchSettingOperationsResponse = /*@__PURE__*/ S.suspend(() =>
  SettingsOperationsBulkEditResultMap.pipe(
    T.EnvelopePayloadRoot(),
    T.KeyDictionary(KEY_DICTIONARY),
  ),
).annotate({
  identifier: "BulkPatchSettingOperationsResponse",
}) as any as S.Schema<BulkPatchSettingOperationsResponse>;

export type SchemasCreateRequestKind = "openapi_v3";
export const SchemasCreateRequestKind = /*@__PURE__*/ S.String;

export interface CreateSchemaRequest {
  /** Identifier. */
  zoneId: string;
  /** The kind of the schema */
  kind: SchemasCreateRequestKind | (string & {});
  /** A human-readable name for the schema */
  name: 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;
}
export const CreateSchemaRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    kind: SchemasCreateRequestKind,
    name: S.String,
    source: S.String,
    validationEnabled: S.Boolean.pipe(T.Body("validation_enabled")),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/zones/{zone_id}/schema_validation/schemas",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateSchemaRequest",
}) as any as S.Schema<CreateSchemaRequest>;

export type SchemasCreateResponseKind = "openapi_v3";
export const SchemasCreateResponseKind = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateSchemaResponse {
  createdAt: string;
  /** The kind of the schema */
  kind: SchemasCreateResponseKind;
  /** 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 const CreateSchemaResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    createdAt: S.String.pipe(T.Body("created_at")),
    kind: SchemasCreateResponseKind,
    name: S.String,
    schemaId: S.String.pipe(T.Body("schema_id")),
    source: S.String,
    validationEnabled: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("validation_enabled")),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateSchemaResponse",
}) as any as S.Schema<CreateSchemaResponse>;

export interface DeleteSchemaRequest {
  /** Identifier. */
  zoneId: string;
  /** UUID. */
  schemaId: string;
}
export const DeleteSchemaRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    schemaId: S.String.pipe(T.Label("schema_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/zones/{zone_id}/schema_validation/schemas/{schema_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteSchemaRequest",
}) as any as S.Schema<DeleteSchemaRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteSchemaResponse {
  /** The ID of the schema that was just deleted */
  id: string;
}
export const DeleteSchemaResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteSchemaResponse",
}) as any as S.Schema<DeleteSchemaResponse>;

export interface DeleteSettingOperationRequest {
  /** Identifier. */
  zoneId: string;
  /** UUID. */
  operationId: string;
}
export const DeleteSettingOperationRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    operationId: S.String.pipe(T.Label("operation_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/zones/{zone_id}/schema_validation/settings/operations/{operation_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteSettingOperationRequest",
}) as any as S.Schema<DeleteSettingOperationRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface DeleteSettingOperationResponse {
  /** UUID. */
  operationId?: string | null;
}
export const DeleteSettingOperationResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    operationId: S.optional(S.NullOr(S.String).pipe(T.Body("operation_id"))),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteSettingOperationResponse",
}) as any as S.Schema<DeleteSettingOperationResponse>;

export interface GetSchemaRequest {
  /** Identifier. */
  zoneId: string;
  /** UUID. */
  schemaId: string;
  /** Omit the source-files of schemas and only retrieve their meta-data. */
  omitSource?: boolean;
}
export const GetSchemaRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    schemaId: S.String.pipe(T.Label("schema_id")),
    omitSource: S.optional(S.Boolean.pipe(T.Query("omit_source"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/schema_validation/schemas/{schema_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSchemaRequest",
}) as any as S.Schema<GetSchemaRequest>;

export type SchemasGetResponseKind = "openapi_v3";
export const SchemasGetResponseKind = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetSchemaResponse {
  createdAt: string;
  /** The kind of the schema */
  kind: SchemasGetResponseKind;
  /** 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 const GetSchemaResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    createdAt: S.String.pipe(T.Body("created_at")),
    kind: SchemasGetResponseKind,
    name: S.String,
    schemaId: S.String.pipe(T.Body("schema_id")),
    source: S.String,
    validationEnabled: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("validation_enabled")),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSchemaResponse",
}) as any as S.Schema<GetSchemaResponse>;

export interface GetSettingRequest {
  /** Identifier. */
  zoneId: string;
}
export const GetSettingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/schema_validation/settings",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSettingRequest",
}) as any as S.Schema<GetSettingRequest>;

export type SettingsGetResponseValidationDefaultMitigationAction =
  | "none"
  | "log"
  | "block";
export const SettingsGetResponseValidationDefaultMitigationAction =
  /*@__PURE__*/ S.String;

export type SettingsGetResponseValidationOverrideMitigationAction = "none";
export const SettingsGetResponseValidationOverrideMitigationAction =
  /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetSettingResponse {
  /** The default mitigation action used */
  validationDefaultMitigationAction: SettingsGetResponseValidationDefaultMitigationAction;
  /** 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. */
  validationOverrideMitigationAction?: SettingsGetResponseValidationOverrideMitigationAction | null;
}
export const GetSettingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    validationDefaultMitigationAction:
      SettingsGetResponseValidationDefaultMitigationAction.pipe(
        T.Body("validation_default_mitigation_action"),
      ),
    validationOverrideMitigationAction: S.optional(
      S.NullOr(SettingsGetResponseValidationOverrideMitigationAction).pipe(
        T.Body("validation_override_mitigation_action"),
      ),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSettingResponse",
}) as any as S.Schema<GetSettingResponse>;

export interface GetSettingOperationRequest {
  /** Identifier. */
  zoneId: string;
  /** UUID. */
  operationId: string;
}
export const GetSettingOperationRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    operationId: S.String.pipe(T.Label("operation_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/schema_validation/settings/operations/{operation_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSettingOperationRequest",
}) as any as S.Schema<GetSettingOperationRequest>;

export type SettingsOperationsGetResponseMitigationAction =
  | "log"
  | "block"
  | "none";
export const SettingsOperationsGetResponseMitigationAction =
  /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetSettingOperationResponse {
  /** When set, this applies a mitigation action to this operation which supersedes a global schema validation setting just for this operation */
  mitigationAction: SettingsOperationsGetResponseMitigationAction;
  /** UUID. */
  operationId: string;
}
export const GetSettingOperationResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    mitigationAction: SettingsOperationsGetResponseMitigationAction.pipe(
      T.Body("mitigation_action"),
    ),
    operationId: S.String.pipe(T.Body("operation_id")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "GetSettingOperationResponse",
}) as any as S.Schema<GetSettingOperationResponse>;

export interface ListSchemasRequest {
  /** Identifier. */
  zoneId: string;
  /** Omit the source-files of schemas and only retrieve their meta-data. */
  omitSource?: boolean;
  /** Page number of paginated results. */
  page?: number;
  /** Maximum number of results per page. */
  perPage?: number;
  /** Filter for enabled schemas */
  validationEnabled?: boolean;
}
export const ListSchemasRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    omitSource: S.optional(S.Boolean.pipe(T.Query("omit_source"))),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    validationEnabled: S.optional(
      S.Boolean.pipe(T.Query("validation_enabled")),
    ),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/schema_validation/schemas",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListSchemasRequest",
}) as any as S.Schema<ListSchemasRequest>;

export type SchemasListResultItemKind = "openapi_v3";
export const SchemasListResultItemKind = /*@__PURE__*/ S.String;

export interface SchemasListResultItem {
  createdAt: string;
  /** The kind of the schema */
  kind: SchemasListResultItemKind;
  /** 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 const SchemasListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    createdAt: S.String.pipe(T.Body("created_at")),
    kind: SchemasListResultItemKind,
    name: S.String,
    schemaId: S.String.pipe(T.Body("schema_id")),
    source: S.String,
    validationEnabled: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("validation_enabled")),
    ),
  }),
).annotate({
  identifier: "SchemasListResultItem",
}) as any as S.Schema<SchemasListResultItem>;

export type SchemasListResultList = Array<SchemasListResultItem>;
export const SchemasListResultList = /*@__PURE__*/ S.Array(
  SchemasListResultItem,
) as any as S.Schema<SchemasListResultList>;

export interface ListSchemasResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: SchemasListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListSchemasResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: SchemasListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListSchemasResponse",
}) as any as S.Schema<ListSchemasResponse>;

export interface ListSettingOperationsRequest {
  /** Identifier. */
  zoneId: string;
  /** Page number of paginated results. */
  page?: number;
  /** Maximum number of results per page. */
  perPage?: number;
}
export const ListSettingOperationsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/schema_validation/settings/operations",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListSettingOperationsRequest",
}) as any as S.Schema<ListSettingOperationsRequest>;

export type SettingsOperationsListResultItemMitigationAction =
  | "log"
  | "block"
  | "none";
export const SettingsOperationsListResultItemMitigationAction =
  /*@__PURE__*/ S.String;

export interface SettingsOperationsListResultItem {
  /** When set, this applies a mitigation action to this operation which supersedes a global schema validation setting just for this operation */
  mitigationAction: SettingsOperationsListResultItemMitigationAction;
  /** UUID. */
  operationId: string;
}
export const SettingsOperationsListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    mitigationAction: SettingsOperationsListResultItemMitigationAction.pipe(
      T.Body("mitigation_action"),
    ),
    operationId: S.String.pipe(T.Body("operation_id")),
  }),
).annotate({
  identifier: "SettingsOperationsListResultItem",
}) as any as S.Schema<SettingsOperationsListResultItem>;

export type SettingsOperationsListResultList =
  Array<SettingsOperationsListResultItem>;
export const SettingsOperationsListResultList = /*@__PURE__*/ S.Array(
  SettingsOperationsListResultItem,
) as any as S.Schema<SettingsOperationsListResultList>;

export interface ListSettingOperationsResponse {
  /** The unwrapped `result` payload of the v4 response envelope. */
  result: SettingsOperationsListResultList;
  /** Pagination info from the envelope's `result_info`. */
  resultInfo?: ResultInfo | null;
}
export const ListSettingOperationsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    result: SettingsOperationsListResultList.pipe(T.EnvelopePayload()),
    resultInfo: S.optional(S.NullOr(ResultInfo).pipe(T.ResultInfo())),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListSettingOperationsResponse",
}) as any as S.Schema<ListSettingOperationsResponse>;

export interface PatchSchemaRequest {
  /** Identifier. */
  zoneId: string;
  /** UUID. */
  schemaId: string;
  /** Flag whether schema is enabled for validation. */
  validationEnabled?: boolean;
}
export const PatchSchemaRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    schemaId: S.String.pipe(T.Label("schema_id")),
    validationEnabled: S.optional(S.Boolean.pipe(T.Body("validation_enabled"))),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/zones/{zone_id}/schema_validation/schemas/{schema_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchSchemaRequest",
}) as any as S.Schema<PatchSchemaRequest>;

export type SchemasEditResponseKind = "openapi_v3";
export const SchemasEditResponseKind = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchSchemaResponse {
  createdAt: string;
  /** The kind of the schema */
  kind: SchemasEditResponseKind;
  /** 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 const PatchSchemaResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    createdAt: S.String.pipe(T.Body("created_at")),
    kind: SchemasEditResponseKind,
    name: S.String,
    schemaId: S.String.pipe(T.Body("schema_id")),
    source: S.String,
    validationEnabled: S.optional(
      S.NullOr(S.Boolean).pipe(T.Body("validation_enabled")),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchSchemaResponse",
}) as any as S.Schema<PatchSchemaResponse>;

export type SettingsEditRequestValidationDefaultMitigationAction =
  | "none"
  | "log"
  | "block";
export const SettingsEditRequestValidationDefaultMitigationAction =
  /*@__PURE__*/ S.String;

export type SettingsEditRequestValidationOverrideMitigationAction = "none";
export const SettingsEditRequestValidationOverrideMitigationAction =
  /*@__PURE__*/ S.String;

export interface PatchSettingRequest {
  /** Identifier. */
  zoneId: string;
  /** The default mitigation action used */
  validationDefaultMitigationAction?:
    | SettingsEditRequestValidationDefaultMitigationAction
    | (string & {});
  /** When set, this overrides both zone level and operation level mitigation actions. */
  validationOverrideMitigationAction?:
    | SettingsEditRequestValidationOverrideMitigationAction
    | (string & {})
    | null;
}
export const PatchSettingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    validationDefaultMitigationAction: S.optional(
      SettingsEditRequestValidationDefaultMitigationAction.pipe(
        T.Body("validation_default_mitigation_action"),
      ),
    ),
    validationOverrideMitigationAction: S.optional(
      S.NullOr(SettingsEditRequestValidationOverrideMitigationAction).pipe(
        T.Body("validation_override_mitigation_action"),
      ),
    ),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/zones/{zone_id}/schema_validation/settings",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchSettingRequest",
}) as any as S.Schema<PatchSettingRequest>;

export type SettingsEditResponseValidationDefaultMitigationAction =
  | "none"
  | "log"
  | "block";
export const SettingsEditResponseValidationDefaultMitigationAction =
  /*@__PURE__*/ S.String;

export type SettingsEditResponseValidationOverrideMitigationAction = "none";
export const SettingsEditResponseValidationOverrideMitigationAction =
  /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchSettingResponse {
  /** The default mitigation action used */
  validationDefaultMitigationAction: SettingsEditResponseValidationDefaultMitigationAction;
  /** 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. */
  validationOverrideMitigationAction?: SettingsEditResponseValidationOverrideMitigationAction | null;
}
export const PatchSettingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    validationDefaultMitigationAction:
      SettingsEditResponseValidationDefaultMitigationAction.pipe(
        T.Body("validation_default_mitigation_action"),
      ),
    validationOverrideMitigationAction: S.optional(
      S.NullOr(SettingsEditResponseValidationOverrideMitigationAction).pipe(
        T.Body("validation_override_mitigation_action"),
      ),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchSettingResponse",
}) as any as S.Schema<PatchSettingResponse>;

export type SettingsUpdateRequestValidationDefaultMitigationAction =
  | "none"
  | "log"
  | "block";
export const SettingsUpdateRequestValidationDefaultMitigationAction =
  /*@__PURE__*/ S.String;

export type SettingsUpdateRequestValidationOverrideMitigationAction = "none";
export const SettingsUpdateRequestValidationOverrideMitigationAction =
  /*@__PURE__*/ S.String;

export interface PutSettingRequest {
  /** Identifier. */
  zoneId: string;
  /** The default mitigation action used */
  validationDefaultMitigationAction:
    | SettingsUpdateRequestValidationDefaultMitigationAction
    | (string & {});
  /** When set, this overrides both zone level and operation level mitigation actions. */
  validationOverrideMitigationAction?:
    | SettingsUpdateRequestValidationOverrideMitigationAction
    | (string & {})
    | null;
}
export const PutSettingRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    validationDefaultMitigationAction:
      SettingsUpdateRequestValidationDefaultMitigationAction.pipe(
        T.Body("validation_default_mitigation_action"),
      ),
    validationOverrideMitigationAction: S.optional(
      S.NullOr(SettingsUpdateRequestValidationOverrideMitigationAction).pipe(
        T.Body("validation_override_mitigation_action"),
      ),
    ),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/zones/{zone_id}/schema_validation/settings",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutSettingRequest",
}) as any as S.Schema<PutSettingRequest>;

export type SettingsUpdateResponseValidationDefaultMitigationAction =
  | "none"
  | "log"
  | "block";
export const SettingsUpdateResponseValidationDefaultMitigationAction =
  /*@__PURE__*/ S.String;

export type SettingsUpdateResponseValidationOverrideMitigationAction = "none";
export const SettingsUpdateResponseValidationOverrideMitigationAction =
  /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PutSettingResponse {
  /** The default mitigation action used */
  validationDefaultMitigationAction: SettingsUpdateResponseValidationDefaultMitigationAction;
  /** 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. */
  validationOverrideMitigationAction?: SettingsUpdateResponseValidationOverrideMitigationAction | null;
}
export const PutSettingResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    validationDefaultMitigationAction:
      SettingsUpdateResponseValidationDefaultMitigationAction.pipe(
        T.Body("validation_default_mitigation_action"),
      ),
    validationOverrideMitigationAction: S.optional(
      S.NullOr(SettingsUpdateResponseValidationOverrideMitigationAction).pipe(
        T.Body("validation_override_mitigation_action"),
      ),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutSettingResponse",
}) as any as S.Schema<PutSettingResponse>;

export type SettingsOperationsUpdateRequestMitigationAction =
  | "log"
  | "block"
  | "none";
export const SettingsOperationsUpdateRequestMitigationAction =
  /*@__PURE__*/ S.String;

export interface PutSettingOperationRequest {
  /** Identifier. */
  zoneId: string;
  /** UUID. */
  operationId: string;
  /** When set, this applies a mitigation action to this operation */
  mitigationAction:
    | SettingsOperationsUpdateRequestMitigationAction
    | (string & {});
}
export const PutSettingOperationRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    operationId: S.String.pipe(T.Label("operation_id")),
    mitigationAction: SettingsOperationsUpdateRequestMitigationAction.pipe(
      T.Body("mitigation_action"),
    ),
  })
    .pipe(
      T.Http({
        method: "PUT",
        uri: "/zones/{zone_id}/schema_validation/settings/operations/{operation_id}",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutSettingOperationRequest",
}) as any as S.Schema<PutSettingOperationRequest>;

export type SettingsOperationsUpdateResponseMitigationAction =
  | "log"
  | "block"
  | "none";
export const SettingsOperationsUpdateResponseMitigationAction =
  /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PutSettingOperationResponse {
  /** When set, this applies a mitigation action to this operation which supersedes a global schema validation setting just for this operation */
  mitigationAction: SettingsOperationsUpdateResponseMitigationAction;
  /** UUID. */
  operationId: string;
}
export const PutSettingOperationResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    mitigationAction: SettingsOperationsUpdateResponseMitigationAction.pipe(
      T.Body("mitigation_action"),
    ),
    operationId: S.String.pipe(T.Body("operation_id")),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PutSettingOperationResponse",
}) as any as S.Schema<PutSettingOperationResponse>;

export type BulkPatchSettingOperationsError = CloudflareOpError;
/** Updates schema validation settings for multiple API operations in a single request. Efficient for applying consistent validation rules across endpoints. */
export const bulkPatchSettingOperations: API.OperationMethod<
  BulkPatchSettingOperationsRequest,
  BulkPatchSettingOperationsResponse,
  BulkPatchSettingOperationsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: BulkPatchSettingOperationsRequest,
  output: BulkPatchSettingOperationsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type CreateSchemaError = InvalidSchema | Forbidden | CloudflareOpError;
/** Uploads a new OpenAPI schema for API Shield schema validation. The schema defines expected request/response formats for API endpoints. */
export const createSchema: API.OperationMethod<
  CreateSchemaRequest,
  CreateSchemaResponse,
  CreateSchemaError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateSchemaRequest,
  output: CreateSchemaResponse,
  errors: [InvalidSchema, Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteSchemaError = SchemaNotFound | CloudflareOpError;
/** Permanently removes an uploaded OpenAPI schema from API Shield. Operations using this schema will lose their validation rules. */
export const deleteSchema: API.OperationMethod<
  DeleteSchemaRequest,
  DeleteSchemaResponse,
  DeleteSchemaError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteSchemaRequest,
  output: DeleteSchemaResponse,
  errors: [SchemaNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type DeleteSettingOperationError = OperationNotFound | CloudflareOpError;
/** Removes custom schema validation settings for a specific API operation, reverting to zone-level defaults. */
export const deleteSettingOperation: API.OperationMethod<
  DeleteSettingOperationRequest,
  DeleteSettingOperationResponse,
  DeleteSettingOperationError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteSettingOperationRequest,
  output: DeleteSettingOperationResponse,
  errors: [OperationNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSchemaError = SchemaNotFound | Forbidden | CloudflareOpError;
/** Gets the contents and metadata of a specific OpenAPI schema uploaded to API Shield. */
export const getSchema: API.OperationMethod<
  GetSchemaRequest,
  GetSchemaResponse,
  GetSchemaError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSchemaRequest,
  output: GetSchemaResponse,
  errors: [SchemaNotFound, Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSettingError = Forbidden | CloudflareOpError;
/** Retrieves the current global schema validation settings for a zone. */
export const getSetting: API.OperationMethod<
  GetSettingRequest,
  GetSettingResponse,
  GetSettingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSettingRequest,
  output: GetSettingResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetSettingOperationError =
  | OperationNotFound
  | Forbidden
  | CloudflareOpError;
/** Retrieves the schema validation settings configured for a specific API operation. */
export const getSettingOperation: API.OperationMethod<
  GetSettingOperationRequest,
  GetSettingOperationResponse,
  GetSettingOperationError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetSettingOperationRequest,
  output: GetSettingOperationResponse,
  errors: [
    OperationNotFound,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListSchemasError = ZonePurged | Forbidden | CloudflareOpError;
/** Lists all OpenAPI schemas uploaded to API Shield with pagination support. */
export const listSchemas: API.PaginatedOperationMethod<
  ListSchemasRequest,
  ListSchemasResponse,
  ListSchemasError,
  CloudflareOpContext,
  SchemasListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListSchemasRequest,
    output: ListSchemasResponse,
    errors: [ZonePurged, Forbidden, CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type ListSettingOperationsError = CloudflareOpError;
/** Lists all per-operation schema validation settings configured for the zone. */
export const listSettingOperations: API.PaginatedOperationMethod<
  ListSettingOperationsRequest,
  ListSettingOperationsResponse,
  ListSettingOperationsError,
  CloudflareOpContext,
  SettingsOperationsListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListSettingOperationsRequest,
    output: ListSettingOperationsResponse,
    errors: [CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: {
      mode: "page",
      inputToken: "page",
      outputToken: "resultInfo.page",
      items: "result",
      pageSize: "perPage",
    } as const,
  }),
  cloudflarePaginate,
) as any;

export type PatchSchemaError = SchemaNotFound | CloudflareOpError;
/** Modifies an existing OpenAPI schema in API Shield, updating the validation rules for associated API operations. */
export const patchSchema: API.OperationMethod<
  PatchSchemaRequest,
  PatchSchemaResponse,
  PatchSchemaError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchSchemaRequest,
  output: PatchSchemaResponse,
  errors: [SchemaNotFound, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchSettingError = CloudflareOpError;
/** Partially updates global schema validation settings for a zone using PATCH semantics. */
export const patchSetting: API.OperationMethod<
  PatchSettingRequest,
  PatchSettingResponse,
  PatchSettingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchSettingRequest,
  output: PatchSettingResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PutSettingError =
  | UnentitledMitigationAction
  | Forbidden
  | CloudflareOpError;
/** Fully updates global schema validation settings for a zone, replacing existing configuration. */
export const putSetting: API.OperationMethod<
  PutSettingRequest,
  PutSettingResponse,
  PutSettingError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PutSettingRequest,
  output: PutSettingResponse,
  errors: [
    UnentitledMitigationAction,
    Forbidden,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PutSettingOperationError =
  | OperationNotFound
  | UnentitledMitigationAction
  | CloudflareOpError;
/** Fully updates schema validation settings for a specific API operation. */
export const putSettingOperation: API.OperationMethod<
  PutSettingOperationRequest,
  PutSettingOperationResponse,
  PutSettingOperationError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PutSettingOperationRequest,
  output: PutSettingOperationResponse,
  errors: [
    OperationNotFound,
    UnentitledMitigationAction,
    CloudflareRateLimited,
    CloudflareError,
  ],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));