// 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 };

export class CloudConnectorRulesNotFound
  extends /*@__PURE__*/ T.applyErrorMatchers(
    /*@__PURE__*/ S.TaggedError<CloudConnectorRulesNotFound>()(
      "CloudConnectorRulesNotFound",
      {
        code: S.Number,
        message: S.String,
      },
    ),
    [
      {
        code: 10003,
        message: { includes: "could not find entrypoint ruleset" },
      },
    ],
  ) {}

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

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

export interface RulesListResultItemParameters {
  /** Host to perform Cloud Connection to */
  host?: string | null;
}
export const RulesListResultItemParameters = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    host: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "RulesListResultItemParameters",
}) as any as S.Schema<RulesListResultItemParameters>;

export type RulesListResultItemProvider =
  | "aws_s3"
  | "cloudflare_r2"
  | "gcp_storage"
  | "azure_storage";
export const RulesListResultItemProvider = /*@__PURE__*/ S.String;

export interface RulesListResultItem {
  id?: string | null;
  description?: string | null;
  enabled?: boolean | null;
  expression?: string | null;
  /** Parameters of Cloud Connector Rule */
  parameters?: RulesListResultItemParameters | null;
  /** Cloud Provider type */
  provider?: RulesListResultItemProvider | null;
}
export const RulesListResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    description: S.optional(S.NullOr(S.String)),
    enabled: S.optional(S.NullOr(S.Boolean)),
    expression: S.optional(S.NullOr(S.String)),
    parameters: S.optional(S.NullOr(RulesListResultItemParameters)),
    provider: S.optional(S.NullOr(RulesListResultItemProvider)),
  }),
).annotate({
  identifier: "RulesListResultItem",
}) as any as S.Schema<RulesListResultItem>;

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

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

export interface RulesUpdateRequestRulesItemParameters {
  /** Host to perform Cloud Connection to */
  host?: string;
}
export const RulesUpdateRequestRulesItemParameters = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      host: S.optional(S.String),
    }),
).annotate({
  identifier: "RulesUpdateRequestRulesItemParameters",
}) as any as S.Schema<RulesUpdateRequestRulesItemParameters>;

export type RulesUpdateRequestRulesItemProvider =
  | "aws_s3"
  | "cloudflare_r2"
  | "gcp_storage"
  | "azure_storage";
export const RulesUpdateRequestRulesItemProvider = /*@__PURE__*/ S.String;

export interface RulesUpdateRequestRulesItem {
  id?: string;
  description?: string;
  enabled?: boolean;
  expression?: string;
  /** Parameters of Cloud Connector Rule */
  parameters?: RulesUpdateRequestRulesItemParameters;
  /** Cloud Provider type */
  provider?: RulesUpdateRequestRulesItemProvider | (string & {});
}
export const RulesUpdateRequestRulesItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.String),
    description: S.optional(S.String),
    enabled: S.optional(S.Boolean),
    expression: S.optional(S.String),
    parameters: S.optional(RulesUpdateRequestRulesItemParameters),
    provider: S.optional(RulesUpdateRequestRulesItemProvider),
  }),
).annotate({
  identifier: "RulesUpdateRequestRulesItem",
}) as any as S.Schema<RulesUpdateRequestRulesItem>;

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

export interface PutRuleRequest {
  /** Identifier. */
  zoneId: string;
  rules?: RulesUpdateRequestRulesList;
}
export const PutRuleRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    zoneId: S.String.pipe(T.Label("zone_id")),
    rules: S.optional(RulesUpdateRequestRulesList.pipe(T.HttpBody())),
  }).pipe(
    T.Http({
      method: "PUT",
      uri: "/zones/{zone_id}/cloud_connector/rules",
      code: 200,
    }),
  ),
).annotate({ identifier: "PutRuleRequest" }) as any as S.Schema<PutRuleRequest>;

export type RulesUpdateResultItemParameters = RulesListResultItemParameters;
export const RulesUpdateResultItemParameters = RulesListResultItemParameters;

export type RulesUpdateResultItemProvider =
  | "aws_s3"
  | "cloudflare_r2"
  | "gcp_storage"
  | "azure_storage";
export const RulesUpdateResultItemProvider = /*@__PURE__*/ S.String;

export interface RulesUpdateResultItem {
  id?: string | null;
  description?: string | null;
  enabled?: boolean | null;
  expression?: string | null;
  /** Parameters of Cloud Connector Rule */
  parameters?: RulesListResultItemParameters | null;
  /** Cloud Provider type */
  provider?: RulesUpdateResultItemProvider | null;
}
export const RulesUpdateResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.optional(S.NullOr(S.String)),
    description: S.optional(S.NullOr(S.String)),
    enabled: S.optional(S.NullOr(S.Boolean)),
    expression: S.optional(S.NullOr(S.String)),
    parameters: S.optional(S.NullOr(RulesListResultItemParameters)),
    provider: S.optional(S.NullOr(RulesUpdateResultItemProvider)),
  }),
).annotate({
  identifier: "RulesUpdateResultItem",
}) as any as S.Schema<RulesUpdateResultItem>;

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

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

export type ListRulesError =
  | Forbidden
  | CloudConnectorRulesNotFound
  | CloudflareOpError;
/** Retrieves the Cloud Connector rules configured for a zone. Rules define how traffic is routed to cloud services. */
export const listRules: API.PaginatedOperationMethod<
  ListRulesRequest,
  ListRulesResponse,
  ListRulesError,
  CloudflareOpContext,
  RulesListResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: ListRulesRequest,
    output: ListRulesResponse,
    errors: [
      Forbidden,
      CloudConnectorRulesNotFound,
      CloudflareRateLimited,
      CloudflareError,
    ],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;

export type PutRuleError = Forbidden | CloudflareOpError;
/** Updates Cloud Connector rules for a zone, replacing the existing rule configuration. */
export const putRule: API.PaginatedOperationMethod<
  PutRuleRequest,
  PutRuleResponse,
  PutRuleError,
  CloudflareOpContext,
  RulesUpdateResultItem
> = /*@__PURE__*/ API.makePaginated(
  () => ({
    input: PutRuleRequest,
    output: PutRuleResponse,
    errors: [Forbidden, CloudflareRateLimited, CloudflareError],
    protocol: CloudflarePaginatedProtocol,
    retry: Retry.Retry,
    pagination: { mode: "single", items: "result" } as const,
  }),
  cloudflarePaginate,
) as any;