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

export type FilesRequestStatus = "completed" | "queued" | "running" | "error";
export const FilesRequestStatus = /*@__PURE__*/ S.String;

export interface FilesRequest {
  accountId: string;
  /** rag id */
  id: string;
  page?: number;
  perPage?: number;
  search?: string;
  status?: FilesRequestStatus | (string & {});
}
export const FilesRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String.pipe(T.Label()),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
    search: S.optional(S.String.pipe(T.Query())),
    status: S.optional(FilesRequestStatus.pipe(T.Query())),
  }).pipe(
    T.Http({
      method: "GET",
      uri: "/accounts/{account_id}/autorag/rags/{id}/files",
      code: 200,
    }),
  ),
).annotate({ identifier: "FilesRequest" }) as any as S.Schema<FilesRequest>;

export interface FilesResultItem {
  error: string;
  key: string;
}
export const FilesResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    error: S.String,
    key: S.String,
  }),
).annotate({
  identifier: "FilesResultItem",
}) as any as S.Schema<FilesResultItem>;

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

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

export interface GetJobRequest {
  accountId: string;
  /** rag id */
  id: string;
  jobId: string;
}
export const GetJobRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String.pipe(T.Label()),
    jobId: S.String.pipe(T.Label("job_id")),
  }).pipe(
    T.Http({
      method: "GET",
      uri: "/accounts/{account_id}/autorag/rags/{id}/jobs/{job_id}",
      code: 200,
    }),
  ),
).annotate({ identifier: "GetJobRequest" }) as any as S.Schema<GetJobRequest>;

export type GetJobResponseSource = "user" | "schedule";
export const GetJobResponseSource = /*@__PURE__*/ S.String;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface GetJobResponse {
  id: string;
  source: GetJobResponseSource;
  endReason?: string | null;
  endedAt?: string | null;
  lastSeenAt?: string | null;
  startedAt?: string | null;
}
export const GetJobResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    source: GetJobResponseSource,
    endReason: S.optional(S.NullOr(S.String).pipe(T.Body("end_reason"))),
    endedAt: S.optional(S.NullOr(S.String).pipe(T.Body("ended_at"))),
    lastSeenAt: S.optional(S.NullOr(S.String).pipe(T.Body("last_seen_at"))),
    startedAt: S.optional(S.NullOr(S.String).pipe(T.Body("started_at"))),
  }),
).annotate({ identifier: "GetJobResponse" }) as any as S.Schema<GetJobResponse>;

export interface JobsLogsRequest {
  accountId: string;
  /** rag id */
  id: string;
  jobId: string;
  page?: number;
  perPage?: number;
}
export const JobsLogsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String.pipe(T.Label()),
    jobId: S.String.pipe(T.Label("job_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: "/accounts/{account_id}/autorag/rags/{id}/jobs/{job_id}/logs",
      code: 200,
    }),
  ),
).annotate({
  identifier: "JobsLogsRequest",
}) as any as S.Schema<JobsLogsRequest>;

export interface JobsLogsResultItem {
  id: number;
  createdAt: number;
  message: string;
  messageType: number;
}
export const JobsLogsResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.Number,
    createdAt: S.Number.pipe(T.Body("created_at")),
    message: S.String,
    messageType: S.Number.pipe(T.Body("message_type")),
  }),
).annotate({
  identifier: "JobsLogsResultItem",
}) as any as S.Schema<JobsLogsResultItem>;

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

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

export interface ListJobsRequest {
  accountId: string;
  /** rag id */
  id: string;
  page?: number;
  perPage?: number;
}
export const ListJobsRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String.pipe(T.Label()),
    page: S.optional(S.Number.pipe(T.Query())),
    perPage: S.optional(S.Number.pipe(T.Query("per_page"))),
  }).pipe(
    T.Http({
      method: "GET",
      uri: "/accounts/{account_id}/autorag/rags/{id}/jobs",
      code: 200,
    }),
  ),
).annotate({
  identifier: "ListJobsRequest",
}) as any as S.Schema<ListJobsRequest>;

export type ListJobsResultItemSource = "user" | "schedule";
export const ListJobsResultItemSource = /*@__PURE__*/ S.String;

export interface ListJobsResultItem {
  id: string;
  source: ListJobsResultItemSource;
  endReason?: string | null;
  endedAt?: string | null;
  lastSeenAt?: string | null;
  startedAt?: string | null;
}
export const ListJobsResultItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    id: S.String,
    source: ListJobsResultItemSource,
    endReason: S.optional(S.NullOr(S.String).pipe(T.Body("end_reason"))),
    endedAt: S.optional(S.NullOr(S.String).pipe(T.Body("ended_at"))),
    lastSeenAt: S.optional(S.NullOr(S.String).pipe(T.Body("last_seen_at"))),
    startedAt: S.optional(S.NullOr(S.String).pipe(T.Body("started_at"))),
  }),
).annotate({
  identifier: "ListJobsResultItem",
}) as any as S.Schema<ListJobsResultItem>;

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

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

export type SearchRequestFiltersCase0Type =
  | "eq"
  | "ne"
  | "gt"
  | "gte"
  | "lt"
  | "lte";
export const SearchRequestFiltersCase0Type = /*@__PURE__*/ S.String;

export type SearchRequestFiltersCase0Value = string | number | boolean;
export const SearchRequestFiltersCase0Value = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([[], [], []]),
);

export interface SearchRequestFiltersCase0 {
  key: string;
  type: SearchRequestFiltersCase0Type | (string & {});
  value: SearchRequestFiltersCase0Value;
}
export const SearchRequestFiltersCase0 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    key: S.String,
    type: SearchRequestFiltersCase0Type,
    value: SearchRequestFiltersCase0Value,
  }),
).annotate({
  identifier: "SearchRequestFiltersCase0",
}) as any as S.Schema<SearchRequestFiltersCase0>;

export type SearchRequestFiltersCase1FiltersItemType =
  | "eq"
  | "ne"
  | "gt"
  | "gte"
  | "lt"
  | "lte";
export const SearchRequestFiltersCase1FiltersItemType = /*@__PURE__*/ S.String;

export type SearchRequestFiltersCase1FiltersItemValue =
  | string
  | number
  | boolean;
export const SearchRequestFiltersCase1FiltersItemValue =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export interface SearchRequestFiltersCase1FiltersItem {
  key: string;
  type: SearchRequestFiltersCase1FiltersItemType | (string & {});
  value: SearchRequestFiltersCase1FiltersItemValue;
}
export const SearchRequestFiltersCase1FiltersItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      key: S.String,
      type: SearchRequestFiltersCase1FiltersItemType,
      value: SearchRequestFiltersCase1FiltersItemValue,
    }),
).annotate({
  identifier: "SearchRequestFiltersCase1FiltersItem",
}) as any as S.Schema<SearchRequestFiltersCase1FiltersItem>;

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

export type SearchRequestFiltersCase1Type = "and" | "or";
export const SearchRequestFiltersCase1Type = /*@__PURE__*/ S.String;

export interface SearchRequestFiltersCase1 {
  filters: SearchRequestFiltersCase1FiltersList;
  type: SearchRequestFiltersCase1Type | (string & {});
}
export const SearchRequestFiltersCase1 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    filters: SearchRequestFiltersCase1FiltersList,
    type: SearchRequestFiltersCase1Type,
  }),
).annotate({
  identifier: "SearchRequestFiltersCase1",
}) as any as S.Schema<SearchRequestFiltersCase1>;

export type SearchRequestFilters =
  | SearchRequestFiltersCase0
  | SearchRequestFiltersCase1;
export const SearchRequestFilters = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["key", "type", "value"],
    ["filters", "type"],
  ]),
);

export interface SearchRequestRankingOptions {
  ranker?: string;
  scoreThreshold?: number;
}
export const SearchRequestRankingOptions = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    ranker: S.optional(S.String),
    scoreThreshold: S.optional(S.Number.pipe(T.Body("score_threshold"))),
  }),
).annotate({
  identifier: "SearchRequestRankingOptions",
}) as any as S.Schema<SearchRequestRankingOptions>;

export type SearchRequestRerankingModel = "@cf/baai/bge-reranker-base" | "";
export const SearchRequestRerankingModel = /*@__PURE__*/ S.String;

export interface SearchRequestReranking {
  enabled?: boolean;
  model?: SearchRequestRerankingModel | (string & {});
}
export const SearchRequestReranking = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.optional(S.Boolean),
    model: S.optional(SearchRequestRerankingModel),
  }),
).annotate({
  identifier: "SearchRequestReranking",
}) as any as S.Schema<SearchRequestReranking>;

export interface SearchRequest {
  accountId: string;
  /** rag id */
  id: string;
  query: string;
  filters?: SearchRequestFilters;
  maxNumResults?: number;
  rankingOptions?: SearchRequestRankingOptions;
  reranking?: SearchRequestReranking;
  rewriteQuery?: boolean;
}
export const SearchRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String.pipe(T.Label()),
    query: S.String,
    filters: S.optional(SearchRequestFilters),
    maxNumResults: S.optional(S.Number.pipe(T.Body("max_num_results"))),
    rankingOptions: S.optional(
      SearchRequestRankingOptions.pipe(T.Body("ranking_options")),
    ),
    reranking: S.optional(SearchRequestReranking),
    rewriteQuery: S.optional(S.Boolean.pipe(T.Body("rewrite_query"))),
  }).pipe(
    T.Http({
      method: "POST",
      uri: "/accounts/{account_id}/autorag/rags/{id}/search",
      code: 200,
    }),
  ),
).annotate({ identifier: "SearchRequest" }) as any as S.Schema<SearchRequest>;

export interface SearchResponseDataItemContentItem {
  text?: string | null;
  type?: string | null;
}
export const SearchResponseDataItemContentItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    text: S.optional(S.NullOr(S.String)),
    type: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "SearchResponseDataItemContentItem",
}) as any as S.Schema<SearchResponseDataItemContentItem>;

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

export interface SearchResponseDataItem {
  score: number;
  attributes?: unknown | null;
  content?: SearchResponseDataItemContentList | null;
  fileId?: string | null;
  filename?: string | null;
}
export const SearchResponseDataItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    score: S.Number,
    attributes: S.optional(S.NullOr(S.Unknown)),
    content: S.optional(S.NullOr(SearchResponseDataItemContentList)),
    fileId: S.optional(S.NullOr(S.String).pipe(T.Body("file_id"))),
    filename: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "SearchResponseDataItem",
}) as any as S.Schema<SearchResponseDataItem>;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface SearchResponse {
  searchQuery: string;
  data?: SearchResponseDataList | null;
  hasMore?: boolean | null;
  nextPage?: string | null;
  object?: string | null;
}
export const SearchResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    searchQuery: S.String.pipe(T.Body("search_query")),
    data: S.optional(S.NullOr(SearchResponseDataList)),
    hasMore: S.optional(S.NullOr(S.Boolean).pipe(T.Body("has_more"))),
    nextPage: S.optional(S.NullOr(S.String).pipe(T.Body("next_page"))),
    object: S.optional(S.NullOr(S.String)),
  }),
).annotate({ identifier: "SearchResponse" }) as any as S.Schema<SearchResponse>;

export type SearchAiRequestFiltersCase0Type =
  | "eq"
  | "ne"
  | "gt"
  | "gte"
  | "lt"
  | "lte";
export const SearchAiRequestFiltersCase0Type = /*@__PURE__*/ S.String;

export type SearchAiRequestFiltersCase0Value = string | number | boolean;
export const SearchAiRequestFiltersCase0Value = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([[], [], []]),
);

export interface SearchAiRequestFiltersCase0 {
  key: string;
  type: SearchAiRequestFiltersCase0Type | (string & {});
  value: SearchAiRequestFiltersCase0Value;
}
export const SearchAiRequestFiltersCase0 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    key: S.String,
    type: SearchAiRequestFiltersCase0Type,
    value: SearchAiRequestFiltersCase0Value,
  }),
).annotate({
  identifier: "SearchAiRequestFiltersCase0",
}) as any as S.Schema<SearchAiRequestFiltersCase0>;

export type SearchAiRequestFiltersCase1FiltersItemType =
  | "eq"
  | "ne"
  | "gt"
  | "gte"
  | "lt"
  | "lte";
export const SearchAiRequestFiltersCase1FiltersItemType =
  /*@__PURE__*/ S.String;

export type SearchAiRequestFiltersCase1FiltersItemValue =
  | string
  | number
  | boolean;
export const SearchAiRequestFiltersCase1FiltersItemValue =
  /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[], [], []]));

export interface SearchAiRequestFiltersCase1FiltersItem {
  key: string;
  type: SearchAiRequestFiltersCase1FiltersItemType | (string & {});
  value: SearchAiRequestFiltersCase1FiltersItemValue;
}
export const SearchAiRequestFiltersCase1FiltersItem = /*@__PURE__*/ S.suspend(
  () =>
    S.Struct({
      key: S.String,
      type: SearchAiRequestFiltersCase1FiltersItemType,
      value: SearchAiRequestFiltersCase1FiltersItemValue,
    }),
).annotate({
  identifier: "SearchAiRequestFiltersCase1FiltersItem",
}) as any as S.Schema<SearchAiRequestFiltersCase1FiltersItem>;

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

export type SearchAiRequestFiltersCase1Type = "and" | "or";
export const SearchAiRequestFiltersCase1Type = /*@__PURE__*/ S.String;

export interface SearchAiRequestFiltersCase1 {
  filters: SearchAiRequestFiltersCase1FiltersList;
  type: SearchAiRequestFiltersCase1Type | (string & {});
}
export const SearchAiRequestFiltersCase1 = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    filters: SearchAiRequestFiltersCase1FiltersList,
    type: SearchAiRequestFiltersCase1Type,
  }),
).annotate({
  identifier: "SearchAiRequestFiltersCase1",
}) as any as S.Schema<SearchAiRequestFiltersCase1>;

export type SearchAiRequestFilters =
  | SearchAiRequestFiltersCase0
  | SearchAiRequestFiltersCase1;
export const SearchAiRequestFilters = /*@__PURE__*/ S.Unknown.pipe(
  T.UnionCases([
    ["key", "type", "value"],
    ["filters", "type"],
  ]),
);

export type SearchAiRequestModel =
  | "@cf/meta/llama-3.3-70b-instruct-fp8-fast"
  | "@cf/meta/llama-3.1-8b-instruct-fast"
  | "@cf/meta/llama-3.1-8b-instruct-fp8"
  | "@cf/meta/llama-4-scout-17b-16e-instruct"
  | "@cf/qwen/qwen3-30b-a3b-fp8"
  | "@cf/deepseek-ai/deepseek-r1-distill-qwen-32b"
  | "@cf/moonshotai/kimi-k2-instruct"
  | "anthropic/claude-3-7-sonnet"
  | "anthropic/claude-sonnet-4"
  | "anthropic/claude-opus-4"
  | "anthropic/claude-3-5-haiku"
  | "cerebras/qwen-3-235b-a22b-instruct"
  | "cerebras/qwen-3-235b-a22b-thinking"
  | "cerebras/llama-3.3-70b"
  | "cerebras/llama-4-maverick-17b-128e-instruct"
  | "cerebras/llama-4-scout-17b-16e-instruct"
  | "cerebras/gpt-oss-120b"
  | "google-ai-studio/gemini-2.5-flash"
  | "google-ai-studio/gemini-2.5-pro"
  | "grok/grok-4"
  | "groq/llama-3.3-70b-versatile"
  | "groq/llama-3.1-8b-instant"
  | "openai/gpt-5"
  | "openai/gpt-5-mini"
  | "openai/gpt-5-nano"
  | "";
export const SearchAiRequestModel = /*@__PURE__*/ S.String;

export type SearchAiRequestRankingOptions = SearchRequestRankingOptions;
export const SearchAiRequestRankingOptions = SearchRequestRankingOptions;

export type SearchAiRequestRerankingModel = "@cf/baai/bge-reranker-base" | "";
export const SearchAiRequestRerankingModel = /*@__PURE__*/ S.String;

export interface SearchAiRequestReranking {
  enabled?: boolean;
  model?: SearchAiRequestRerankingModel | (string & {});
}
export const SearchAiRequestReranking = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    enabled: S.optional(S.Boolean),
    model: S.optional(SearchAiRequestRerankingModel),
  }),
).annotate({
  identifier: "SearchAiRequestReranking",
}) as any as S.Schema<SearchAiRequestReranking>;

export interface SearchAiRequest {
  accountId: string;
  /** rag id */
  id: string;
  query: string;
  filters?: SearchAiRequestFilters;
  maxNumResults?: number;
  model?: SearchAiRequestModel | (string & {});
  rankingOptions?: SearchRequestRankingOptions;
  reranking?: SearchAiRequestReranking;
  rewriteQuery?: boolean;
  stream?: boolean;
  systemPrompt?: string;
}
export const SearchAiRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String.pipe(T.Label()),
    query: S.String,
    filters: S.optional(SearchAiRequestFilters),
    maxNumResults: S.optional(S.Number.pipe(T.Body("max_num_results"))),
    model: S.optional(SearchAiRequestModel),
    rankingOptions: S.optional(
      SearchRequestRankingOptions.pipe(T.Body("ranking_options")),
    ),
    reranking: S.optional(SearchAiRequestReranking),
    rewriteQuery: S.optional(S.Boolean.pipe(T.Body("rewrite_query"))),
    stream: S.optional(S.Boolean),
    systemPrompt: S.optional(S.String.pipe(T.Body("system_prompt"))),
  }).pipe(
    T.Http({
      method: "POST",
      uri: "/accounts/{account_id}/autorag/rags/{id}/ai-search",
      code: 200,
    }),
  ),
).annotate({
  identifier: "SearchAiRequest",
}) as any as S.Schema<SearchAiRequest>;

export type SearchAiResponseDataItemContentItem =
  SearchResponseDataItemContentItem;
export const SearchAiResponseDataItemContentItem =
  SearchResponseDataItemContentItem;

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

export interface SearchAiResponseDataItem {
  score: number;
  attributes?: unknown | null;
  content?: SearchAiResponseDataItemContentList | null;
  fileId?: string | null;
  filename?: string | null;
}
export const SearchAiResponseDataItem = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    score: S.Number,
    attributes: S.optional(S.NullOr(S.Unknown)),
    content: S.optional(S.NullOr(SearchAiResponseDataItemContentList)),
    fileId: S.optional(S.NullOr(S.String).pipe(T.Body("file_id"))),
    filename: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "SearchAiResponseDataItem",
}) as any as S.Schema<SearchAiResponseDataItem>;

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

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface SearchAiResponse {
  response: string;
  searchQuery: string;
  data?: SearchAiResponseDataList | null;
  hasMore?: boolean | null;
  nextPage?: string | null;
  object?: string | null;
}
export const SearchAiResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    response: S.String,
    searchQuery: S.String.pipe(T.Body("search_query")),
    data: S.optional(S.NullOr(SearchAiResponseDataList)),
    hasMore: S.optional(S.NullOr(S.Boolean).pipe(T.Body("has_more"))),
    nextPage: S.optional(S.NullOr(S.String).pipe(T.Body("next_page"))),
    object: S.optional(S.NullOr(S.String)),
  }),
).annotate({
  identifier: "SearchAiResponse",
}) as any as S.Schema<SearchAiResponse>;

export interface SyncRequest {
  accountId: string;
  /** rag id */
  id: string;
}
export const SyncRequest = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    accountId: S.String.pipe(T.Label("account_id")),
    id: S.String.pipe(T.Label()),
  }).pipe(
    T.Http({
      method: "PATCH",
      uri: "/accounts/{account_id}/autorag/rags/{id}/sync",
      code: 200,
    }),
  ),
).annotate({ identifier: "SyncRequest" }) as any as S.Schema<SyncRequest>;

/** Unwrapped `result` payload of the Cloudflare v4 response envelope. */
export interface SyncResponse {
  jobId: string;
}
export const SyncResponse = /*@__PURE__*/ S.suspend(() =>
  S.Struct({
    jobId: S.String.pipe(T.Body("job_id")),
  }),
).annotate({ identifier: "SyncResponse" }) as any as S.Schema<SyncResponse>;

export type FilesError = CloudflareOpError;
/** Files */
export const files: API.OperationMethod<
  FilesRequest,
  FilesResponse,
  FilesError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: FilesRequest,
  output: FilesResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type GetJobError = CloudflareOpError;
/** Get a Job Details */
export const getJob: API.OperationMethod<
  GetJobRequest,
  GetJobResponse,
  GetJobError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: GetJobRequest,
  output: GetJobResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type JobsLogsError = CloudflareOpError;
/** List Job Logs */
export const jobsLogs: API.OperationMethod<
  JobsLogsRequest,
  JobsLogsResponse,
  JobsLogsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: JobsLogsRequest,
  output: JobsLogsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type ListJobsError = CloudflareOpError;
/** List Jobs */
export const listJobs: API.OperationMethod<
  ListJobsRequest,
  ListJobsResponse,
  ListJobsError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: ListJobsRequest,
  output: ListJobsResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type SearchError = CloudflareOpError;
/** Search */
export const search: API.OperationMethod<
  SearchRequest,
  SearchResponse,
  SearchError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: SearchRequest,
  output: SearchResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type SearchAiError = CloudflareOpError;
/** AI Search */
export const searchAi: API.OperationMethod<
  SearchAiRequest,
  SearchAiResponse,
  SearchAiError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: SearchAiRequest,
  output: SearchAiResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));

export type SyncError = CloudflareOpError;
/** Sync */
export const sync: API.OperationMethod<
  SyncRequest,
  SyncResponse,
  SyncError,
  CloudflareOpContext
> = /*@__PURE__*/ API.make(() => ({
  input: SyncRequest,
  output: SyncResponse,
  errors: [CloudflareRateLimited, CloudflareError],
  protocol: CloudflareProtocol,
  retry: Retry.Retry,
}));