// 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,
  type CloudflareOpError,
  type CloudflareOpContext,
} from "../protocol.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>> = {
  conflictsWith: "conflicts_with",
  hasConflict: "has_conflict",
  managedRequestHeaders: "managed_request_headers",
  managedResponseHeaders: "managed_response_headers",
};

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

export interface DeleteManagedTransformRequest {
  /** The unique ID of the zone. */
  zoneId: string;
}
export const DeleteManagedTransformRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "DELETE",
        uri: "/zones/{zone_id}/managed_headers",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "DeleteManagedTransformRequest",
}) as any as S.Schema<DeleteManagedTransformRequest>;

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

export interface ListManagedTransformsRequest {
  /** The unique ID of the zone. */
  zoneId: string;
}
export const ListManagedTransformsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
  })
    .pipe(
      T.Http({
        method: "GET",
        uri: "/zones/{zone_id}/managed_headers",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListManagedTransformsRequest",
}) as any as S.Schema<ListManagedTransformsRequest>;

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

export interface ListResponseManagedRequestHeadersItem {
  /** The human-readable identifier of the Managed Transform. */
  id: string;
  /** Whether the Managed Transform is enabled. */
  enabled: boolean;
  /** Whether the Managed Transform conflicts with the currently-enabled Managed Transforms. */
  hasConflict: boolean;
  /** The Managed Transforms that this Managed Transform conflicts with. */
  conflictsWith?: ListResponseManagedRequestHeadersItemConflictsWithList | null;
}
export const ListResponseManagedRequestHeadersItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      enabled: S.Boolean,
      hasConflict: S.Boolean.pipe(T.Body("has_conflict")),
      conflictsWith: S.optional(
        S.NullOr(ListResponseManagedRequestHeadersItemConflictsWithList).pipe(
          T.Body("conflicts_with"),
        ),
      ),
    }),
).annotate({
  identifier: "ListResponseManagedRequestHeadersItem",
}) as any as S.Schema<ListResponseManagedRequestHeadersItem>;

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

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

export interface ListResponseManagedResponseHeadersItem {
  /** The human-readable identifier of the Managed Transform. */
  id: string;
  /** Whether the Managed Transform is enabled. */
  enabled: boolean;
  /** Whether the Managed Transform conflicts with the currently-enabled Managed Transforms. */
  hasConflict: boolean;
  /** The Managed Transforms that this Managed Transform conflicts with. */
  conflictsWith?: ListResponseManagedResponseHeadersItemConflictsWithList | null;
}
export const ListResponseManagedResponseHeadersItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      enabled: S.Boolean,
      hasConflict: S.Boolean.pipe(T.Body("has_conflict")),
      conflictsWith: S.optional(
        S.NullOr(ListResponseManagedResponseHeadersItemConflictsWithList).pipe(
          T.Body("conflicts_with"),
        ),
      ),
    }),
).annotate({
  identifier: "ListResponseManagedResponseHeadersItem",
}) as any as S.Schema<ListResponseManagedResponseHeadersItem>;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface ListManagedTransformsResponse {
  /** The list of Managed Request Transforms. */
  managedRequestHeaders: ListResponseManagedRequestHeadersList;
  /** The list of Managed Response Transforms. */
  managedResponseHeaders: ListResponseManagedResponseHeadersList;
}
export const ListManagedTransformsResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    managedRequestHeaders: ListResponseManagedRequestHeadersList.pipe(
      T.Body("managed_request_headers"),
    ),
    managedResponseHeaders: ListResponseManagedResponseHeadersList.pipe(
      T.Body("managed_response_headers"),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "ListManagedTransformsResponse",
}) as any as S.Schema<ListManagedTransformsResponse>;

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

export interface EditRequestManagedRequestHeadersItem {
  /** The human-readable identifier of the Managed Transform. */
  id: string;
  /** Whether the Managed Transform is enabled. */
  enabled: boolean;
  /** Whether the Managed Transform conflicts with the currently-enabled Managed Transforms. */
  hasConflict?: boolean;
  /** The Managed Transforms that this Managed Transform conflicts with. */
  conflictsWith?: EditRequestManagedRequestHeadersItemConflictsWithList;
}
export const EditRequestManagedRequestHeadersItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      enabled: S.Boolean,
      hasConflict: S.optional(S.Boolean.pipe(T.Body("has_conflict"))),
      conflictsWith: S.optional(
        EditRequestManagedRequestHeadersItemConflictsWithList.pipe(
          T.Body("conflicts_with"),
        ),
      ),
    }),
).annotate({
  identifier: "EditRequestManagedRequestHeadersItem",
}) as any as S.Schema<EditRequestManagedRequestHeadersItem>;

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

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

export interface EditRequestManagedResponseHeadersItem {
  /** The human-readable identifier of the Managed Transform. */
  id: string;
  /** Whether the Managed Transform is enabled. */
  enabled: boolean;
  /** Whether the Managed Transform conflicts with the currently-enabled Managed Transforms. */
  hasConflict?: boolean;
  /** The Managed Transforms that this Managed Transform conflicts with. */
  conflictsWith?: EditRequestManagedResponseHeadersItemConflictsWithList;
}
export const EditRequestManagedResponseHeadersItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      enabled: S.Boolean,
      hasConflict: S.optional(S.Boolean.pipe(T.Body("has_conflict"))),
      conflictsWith: S.optional(
        EditRequestManagedResponseHeadersItemConflictsWithList.pipe(
          T.Body("conflicts_with"),
        ),
      ),
    }),
).annotate({
  identifier: "EditRequestManagedResponseHeadersItem",
}) as any as S.Schema<EditRequestManagedResponseHeadersItem>;

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

export interface PatchManagedTransformRequest {
  /** The unique ID of the zone. */
  zoneId: string;
  /** The list of Managed Request Transforms. */
  managedRequestHeaders?: EditRequestManagedRequestHeadersList;
  /** The list of Managed Response Transforms. */
  managedResponseHeaders?: EditRequestManagedResponseHeadersList;
}
export const PatchManagedTransformRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    managedRequestHeaders: S.optional(
      EditRequestManagedRequestHeadersList.pipe(
        T.Body("managed_request_headers"),
      ),
    ),
    managedResponseHeaders: S.optional(
      EditRequestManagedResponseHeadersList.pipe(
        T.Body("managed_response_headers"),
      ),
    ),
  })
    .pipe(
      T.Http({
        method: "PATCH",
        uri: "/zones/{zone_id}/managed_headers",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchManagedTransformRequest",
}) as any as S.Schema<PatchManagedTransformRequest>;

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

export interface EditResponseManagedRequestHeadersItem {
  /** The human-readable identifier of the Managed Transform. */
  id: string;
  /** Whether the Managed Transform is enabled. */
  enabled: boolean;
  /** Whether the Managed Transform conflicts with the currently-enabled Managed Transforms. */
  hasConflict: boolean;
  /** The Managed Transforms that this Managed Transform conflicts with. */
  conflictsWith?: EditResponseManagedRequestHeadersItemConflictsWithList | null;
}
export const EditResponseManagedRequestHeadersItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      enabled: S.Boolean,
      hasConflict: S.Boolean.pipe(T.Body("has_conflict")),
      conflictsWith: S.optional(
        S.NullOr(EditResponseManagedRequestHeadersItemConflictsWithList).pipe(
          T.Body("conflicts_with"),
        ),
      ),
    }),
).annotate({
  identifier: "EditResponseManagedRequestHeadersItem",
}) as any as S.Schema<EditResponseManagedRequestHeadersItem>;

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

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

export interface EditResponseManagedResponseHeadersItem {
  /** The human-readable identifier of the Managed Transform. */
  id: string;
  /** Whether the Managed Transform is enabled. */
  enabled: boolean;
  /** Whether the Managed Transform conflicts with the currently-enabled Managed Transforms. */
  hasConflict: boolean;
  /** The Managed Transforms that this Managed Transform conflicts with. */
  conflictsWith?: EditResponseManagedResponseHeadersItemConflictsWithList | null;
}
export const EditResponseManagedResponseHeadersItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      id: S.String,
      enabled: S.Boolean,
      hasConflict: S.Boolean.pipe(T.Body("has_conflict")),
      conflictsWith: S.optional(
        S.NullOr(EditResponseManagedResponseHeadersItemConflictsWithList).pipe(
          T.Body("conflicts_with"),
        ),
      ),
    }),
).annotate({
  identifier: "EditResponseManagedResponseHeadersItem",
}) as any as S.Schema<EditResponseManagedResponseHeadersItem>;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface PatchManagedTransformResponse {
  /** The list of Managed Request Transforms. */
  managedRequestHeaders: EditResponseManagedRequestHeadersList;
  /** The list of Managed Response Transforms. */
  managedResponseHeaders: EditResponseManagedResponseHeadersList;
}
export const PatchManagedTransformResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    managedRequestHeaders: EditResponseManagedRequestHeadersList.pipe(
      T.Body("managed_request_headers"),
    ),
    managedResponseHeaders: EditResponseManagedResponseHeadersList.pipe(
      T.Body("managed_response_headers"),
    ),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "PatchManagedTransformResponse",
}) as any as S.Schema<PatchManagedTransformResponse>;

export type DeleteManagedTransformError = Forbidden | CloudflareOpError;
/** Disables all Managed Transforms. */
export const deleteManagedTransform: API.OperationMethod<
  DeleteManagedTransformRequest,
  DeleteManagedTransformResponse,
  DeleteManagedTransformError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: DeleteManagedTransformRequest,
  output: DeleteManagedTransformResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListManagedTransformsError = Forbidden | CloudflareOpError;
/** Fetches a list of all Managed Transforms. */
export const listManagedTransforms: API.OperationMethod<
  ListManagedTransformsRequest,
  ListManagedTransformsResponse,
  ListManagedTransformsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListManagedTransformsRequest,
  output: ListManagedTransformsResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type PatchManagedTransformError = Forbidden | CloudflareOpError;
/** Updates the status of one or more Managed Transforms. */
export const patchManagedTransform: API.OperationMethod<
  PatchManagedTransformRequest,
  PatchManagedTransformResponse,
  PatchManagedTransformError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: PatchManagedTransformRequest,
  output: PatchManagedTransformResponse,
  errors: [Forbidden, CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));