import {z} from 'zod'

export type GetApiV1NamespacesTenantMetaNamespaceSavedQueriesUuidEvaluateArgs = {'tenant_meta.namespace': string, uuid: string, 'get_parameters.mask'?: string | undefined};

export type GetApiV1NamespacesTenantMetaNamespaceSavedQueriesUuidEvaluateOptions = {baseUrl?: string | undefined, fetch?: typeof fetch | undefined};

export const v1IndexData = z.object({data: z.array(z.string()).optional(), search_score: z.number().optional(), tenant: z.string().optional(), will_be_deleted_at: z.string().optional()});

export const googleprotobufAny = z.object({"@type": z.string().optional()}).and(z.record(z.string(), z.unknown()));

export const v1Meta = z.object({annotations: z.record(z.string(), z.string()).optional(), create_time: z.string().optional(), created_by: z.string().optional(), description: z.string().optional(), index_data: v1IndexData.optional(), kind: z.string().optional(), name: z.string(), parent_kind: z.string().optional(), parent_uuid: z.string().optional(), references: z.record(z.string(), googleprotobufAny).optional(), tags: z.array(z.string()).optional(), update_time: z.string().optional(), updated_by: z.string().optional(), upsert_time: z.string().optional(), version: z.string().optional()});

export const listParametersGroup = z.object({aggregation_paths: z.string().optional(), show_aggregation_uuids: z.boolean().optional(), unique_count_paths: z.string().optional(), unique_value_paths: z.string().optional()});

export const groupByTimeGroupByTimeInterval = z.enum(["GROUP_BY_TIME_INTERVAL_UNSPECIFIED", "GROUP_BY_TIME_INTERVAL_YEAR", "GROUP_BY_TIME_INTERVAL_QUARTER", "GROUP_BY_TIME_INTERVAL_MONTH", "GROUP_BY_TIME_INTERVAL_WEEK", "GROUP_BY_TIME_INTERVAL_DAY", "GROUP_BY_TIME_INTERVAL_HOUR", "GROUP_BY_TIME_INTERVAL_MINUTE", "GROUP_BY_TIME_INTERVAL_SECOND"]);

export const listParametersGroupByTime = z.object({aggregation_operator: z.string().optional(), aggregation_paths: z.string().optional(), aggregation_value_field: z.string().optional(), end_time: z.string().optional(), group_size: z.number().int().optional(), interval: groupByTimeGroupByTimeInterval.optional(), mode: z.string().optional(), show_aggregation_uuids: z.boolean().optional(), start_time: z.string().optional()});

export const v1ScoreOptions = z.object({boost: z.number().optional(), constant: z.number().optional()});

export const v1Fuzzy = z.object({max_edits: z.number().int().optional(), max_expansion: z.number().int().optional(), prefix_length: z.number().int().optional(), score_options: v1ScoreOptions.optional()});

export const v1SearchClauseAutocomplete = z.object({fuzzy: v1Fuzzy.optional(), path: z.string(), query: z.string(), score_options: v1ScoreOptions.optional(), token_order: z.string().optional()});

export const v1SearchValue = z.object({bool_value: z.boolean().optional(), double_value: z.number().optional(), int64_value: z.string().optional(), string_value: z.string().optional(), timestamp_value: z.string().optional()});

export const v1SearchClauseEquals = z.object({path: z.string(), score_options: v1ScoreOptions.optional(), value: v1SearchValue});

export const v1SearchClauseIn = z.object({path: z.string(), score_options: v1ScoreOptions.optional(), values: z.array(v1SearchValue)});

export const v1SearchClausePhrase = z.object({path: z.string(), query: z.string(), score_options: v1ScoreOptions.optional()});

export const v1SearchClauseQueryString = z.object({path: z.string(), query: z.string(), score_options: v1ScoreOptions.optional()});

export const v1SearchClauseRange = z.object({gt: v1SearchValue.optional(), gte: v1SearchValue.optional(), lt: v1SearchValue.optional(), lte: v1SearchValue.optional(), path: z.string(), score_options: v1ScoreOptions.optional()});

export const v1SearchClauseRegex = z.object({allow_analyzed: z.boolean().optional(), path: z.string(), query: z.string(), score_options: v1ScoreOptions.optional()});

export const v1SearchClauseText = z.object({full_match: z.boolean().optional(), fuzzy: v1Fuzzy.optional(), path: z.string(), query: z.string(), score_options: v1ScoreOptions.optional()});

export const v1SearchClauseWildcard = z.object({allow_analyzed: z.boolean().optional(), path: z.string(), query: z.string(), score_options: v1ScoreOptions.optional()});

export const v1SearchClause = z.object({autocomplete: v1SearchClauseAutocomplete.optional(), compound: z.lazy(() => v1SearchQuery.optional()), equals: v1SearchClauseEquals.optional(), in: v1SearchClauseIn.optional(), phrase: v1SearchClausePhrase.optional(), query_string: v1SearchClauseQueryString.optional(), range: v1SearchClauseRange.optional(), regex: v1SearchClauseRegex.optional(), text: v1SearchClauseText.optional(), wildcard: v1SearchClauseWildcard.optional()});

export const v1SearchQuery: z.ZodType<V1SearchQuery> = z.object({filters: z.array(v1SearchClause).optional(), must: z.array(v1SearchClause).optional(), must_not: z.array(v1SearchClause).optional(), should: z.array(v1SearchClause).optional()});

export const sortEntrySortEntryOrder = z.enum(["SORT_ENTRY_ORDER_UNSPECIFIED", "SORT_ENTRY_ORDER_ASC", "SORT_ENTRY_ORDER_DESC"]);

export const listParametersSortEntry = z.object({order: sortEntrySortEntryOrder.optional(), path: z.string().optional()});

export const v1ListParameters = z.object({action: z.string().optional(), ci_run_uuid: z.string().optional(), count: z.boolean().optional(), disable_pagination: z.boolean().optional(), filter: z.string().optional(), group: listParametersGroup.optional(), group_by_time: listParametersGroupByTime.optional(), mask: z.string().optional(), page_id: z.string().optional(), page_size: z.number().int().optional(), page_token: z.number().int().optional(), search_query: v1SearchQuery.optional(), sort: listParametersSortEntry.optional(), traverse: z.boolean().optional()});

export const v1QueryReference = z.object({connect_from: z.string().optional(), connect_operator: z.string().optional(), connect_to: z.string().optional(), query_spec: z.lazy(() => queryQuerySpec.optional())});

export const queryJoinFilters = z.object({filter: z.string().optional(), kind: z.string()});

export const queryQuerySpec: z.ZodType<QueryQuerySpec> = z.object({kind: z.string(), list_parameters: v1ListParameters.optional(), references: z.array(v1QueryReference).optional(), return_as: z.string().optional(), with: z.array(queryJoinFilters).optional()});

export const v1QuerySpec = z.object({query_response: googleprotobufAny.optional(), query_spec: queryQuerySpec.optional()});

export const v1TenantMeta = z.object({namespace: z.string()});

export const v1Query = z.object({meta: v1Meta, spec: v1QuerySpec.optional(), tenant_meta: v1TenantMeta, uuid: z.string().optional()});

export const savedQuerySpecQueryType = z.enum(["QUERY_TYPE_UNSPECIFIED", "QUERY_TYPE_DASHBOARD", "QUERY_TYPE_USER"]);

export const v1SavedQuerySpec = z.object({is_default: z.boolean().optional(), lock: z.boolean().optional(), monitor: z.boolean().optional(), query: v1Query.optional(), query_type: savedQuerySpecQueryType.optional()});

export const v1SavedQuery = z.object({meta: v1Meta, propagate: z.boolean().optional(), spec: v1SavedQuerySpec.optional(), tenant_meta: v1TenantMeta, uuid: z.string().optional()});

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * EvaluateSavedQuery
 * 
 * GET /v1/namespaces/{tenant_meta.namespace}/saved-queries/{uuid}/evaluate
 */
export const getApiV1NamespacesTenantMetaNamespaceSavedQueriesUuidEvaluate = async (args: GetApiV1NamespacesTenantMetaNamespaceSavedQueriesUuidEvaluateArgs, options?: GetApiV1NamespacesTenantMetaNamespaceSavedQueriesUuidEvaluateOptions) => {
const {baseUrl = "https://api.endorlabs.com", fetch: fetchFn = fetch} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('accept', "application/json")

if (args['get_parameters.mask'] != null) query.append("get_parameters.mask", String(args['get_parameters.mask']))

const url = `${baseUrl.replace(/\/+$/, '')}/v1/namespaces/${encodeURIComponent(String(args['tenant_meta.namespace']))}/saved-queries/${encodeURIComponent(String(args.uuid))}/evaluate${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "GET", headers})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(v1SavedQuery, await res.json())
};