// 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>> = {
  actionParameters: "action_parameters",
  botScore: "bot_score",
  isEuCountry: "is_eu_country",
  isoCode: "iso_code",
  plainText: "plain_text",
  postalCode: "postal_code",
  regionCode: "region_code",
  skipChallenge: "skip_challenge",
  skipResponse: "skip_response",
  statusCode: "status_code",
  stepName: "step_name",
  subdivision_2IsoCode: "subdivision_2_iso_code",
  threatScore: "threat_score",
};

export interface TracesCreateRequestBody {
  /** Base64 encoded request body */
  base64?: string;
  /** Arbitrary json as request body */
  json?: unknown;
  /** Request body as plain text */
  plainText?: string;
}
export const TracesCreateRequestBody = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    base64: S.optional(S.String),
    json: S.optional(S.Unknown),
    plainText: S.optional(S.String.pipe(T.Body("plain_text"))),
  }),
).annotate({
  identifier: "TracesCreateRequestBody",
}) as any as S.Schema<TracesCreateRequestBody>;

export interface TracesCreateRequestContextGeoloc {
  city?: string;
  continent?: string;
  isEuCountry?: boolean;
  isoCode?: string;
  latitude?: number;
  longitude?: number;
  postalCode?: string;
  regionCode?: string;
  subdivision_2_iso_code?: string;
  timezone?: string;
}
export const TracesCreateRequestContextGeoloc = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    city: S.optional(S.String),
    continent: S.optional(S.String),
    isEuCountry: S.optional(S.Boolean.pipe(T.Body("is_eu_country"))),
    isoCode: S.optional(S.String.pipe(T.Body("iso_code"))),
    latitude: S.optional(S.Number),
    longitude: S.optional(S.Number),
    postalCode: S.optional(S.String.pipe(T.Body("postal_code"))),
    regionCode: S.optional(S.String.pipe(T.Body("region_code"))),
    subdivision_2_iso_code: S.optional(S.String),
    timezone: S.optional(S.String),
  }),
).annotate({
  identifier: "TracesCreateRequestContextGeoloc",
}) as any as S.Schema<TracesCreateRequestContextGeoloc>;

export interface TracesCreateRequestContext {
  /** Bot score used for evaluating tracing request processing */
  botScore?: number;
  /** Geodata for tracing request */
  geoloc?: TracesCreateRequestContextGeoloc;
  /** Whether to skip any challenges for tracing request (e.g.: captcha) */
  skipChallenge?: boolean;
  /** Threat score used for evaluating tracing request processing */
  threatScore?: number;
}
export const TracesCreateRequestContext = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    botScore: S.optional(S.Number.pipe(T.Body("bot_score"))),
    geoloc: S.optional(TracesCreateRequestContextGeoloc),
    skipChallenge: S.optional(S.Boolean.pipe(T.Body("skip_challenge"))),
    threatScore: S.optional(S.Number.pipe(T.Body("threat_score"))),
  }),
).annotate({
  identifier: "TracesCreateRequestContext",
}) as any as S.Schema<TracesCreateRequestContext>;

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

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

export interface CreateTraceRequest {
  /** Identifier. */
  accountId: string;
  /** HTTP Method of tracing request */
  method: string;
  /** URL to which perform tracing request */
  url: string;
  body?: TracesCreateRequestBody;
  /** Additional request parameters */
  context?: TracesCreateRequestContext;
  /** Cookies added to tracing request */
  cookies?: TracesCreateRequestCookiesMap;
  /** Headers added to tracing request */
  headers?: TracesCreateRequestHeadersMap;
  /** HTTP Protocol of tracing request */
  protocol?: string;
  /** Skip sending the request to the Origin server after all rules evaluation */
  skipResponse?: boolean;
}
export const CreateTraceRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    method: S.String,
    url: S.String,
    body: S.optional(TracesCreateRequestBody),
    context: S.optional(TracesCreateRequestContext),
    cookies: S.optional(TracesCreateRequestCookiesMap),
    headers: S.optional(TracesCreateRequestHeadersMap),
    protocol: S.optional(S.String),
    skipResponse: S.optional(S.Boolean.pipe(T.Body("skip_response"))),
  })
    .pipe(
      T.Http({
        method: "POST",
        uri: "/accounts/{account_id}/request-tracer/trace",
        code: 200,
      }),
    )
    .pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateTraceRequest",
}) as any as S.Schema<CreateTraceRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface CreateTraceResponse {
  /** HTTP Status code of zone response */
  statusCode?: number | null;
  trace?: unknown | null;
}
export const CreateTraceResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    statusCode: S.optional(S.NullOr(S.Number).pipe(T.Body("status_code"))),
    trace: S.optional(S.NullOr(S.Unknown)),
  }).pipe(T.KeyDictionary(KEY_DICTIONARY)),
).annotate({
  identifier: "CreateTraceResponse",
}) as any as S.Schema<CreateTraceResponse>;

export type CreateTraceError = CloudflareOpError;
/** Request Trace */
export const createTrace: API.OperationMethod<
  CreateTraceRequest,
  CreateTraceResponse,
  CreateTraceError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: CreateTraceRequest,
  output: CreateTraceResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));