import {z} from 'zod'

export type LogRecordsAvailableColumnsRequest = {log_stream_id?: (unknown | null) | undefined, experiment_id?: (unknown | null) | undefined, metrics_testing_id?: (unknown | null) | undefined, start_time?: (string | null) | undefined, end_time?: (string | null) | undefined};

export type CreateApiPublicV2ProjectsProjectIdSessionsAvailableColumnsArgs = {project_id: unknown, body: LogRecordsAvailableColumnsRequest};

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

export const columnCategory = z.enum(["standard", "metric", "user_metadata", "metric_status", "dataset_metadata", "dataset", "feedback", "tags"]);

export const dataType = z.enum(["uuid", "text", "integer", "floating_point", "boolean", "timestamp", "string_list", "tag", "dataset", "prompt", "playground", "rank", "category_count", "retrieved_chunk_list_boolean", "score_rating_aggregate", "star_rating_aggregate", "thumb_rating_aggregate", "tags_rating_aggregate", "text_rating_aggregate", "annotation_agreement", "fully_annotated"]);

export const dataUnit = z.enum(["percentage", "nano_seconds", "milli_seconds", "dollars", "count_and_total"]);

export const stepType = z.enum(["http", "llm", "retriever", "tool", "workflow", "agent", "control", "trace", "session"]);

export const metricThreshold = z.object({inverted: z.boolean().optional(), buckets: z.array(z.union([z.number().int(), z.number()])).optional(), display_value_levels: z.array(z.string()).optional()});

export const nodeNameFilter = z.object({name: z.literal("node_name").optional(), operator: z.enum(["eq", "ne", "contains", "one_of", "not_in"]), value: z.union([z.string(), z.array(z.string())]), case_sensitive: z.boolean().optional()});

export const metadataFilter = z.object({name: z.literal("metadata").optional(), operator: z.enum(["one_of", "not_in", "eq", "ne"]), key: z.string(), value: z.union([z.string(), z.array(z.string())])});

export const modalityFilter = z.object({name: z.literal("modality").optional(), operator: z.enum(["eq", "ne", "one_of", "not_in"]), value: z.union([z.string(), z.array(z.string())])});

export const rollUpMethodDisplayOptions = z.enum(["average", "sum", "max", "min", "category_count", "percentage_true", "percentage_false"]);

export const scorerTypes = z.enum(["llm", "code", "luna", "decision", "preset"]);

export const fewShotExample = z.object({generation_prompt_and_response: z.string(), evaluating_response: z.string()});

export const chainPollTemplate = z.object({metric_system_prompt: z.string().nullable().optional(), metric_description: z.string().nullable().optional(), value_field_name: z.string().optional(), explanation_field_name: z.string().optional(), template: z.string(), metric_few_shot_examples: z.array(fewShotExample).optional(), response_schema: z.record(z.string(), z.unknown()).nullable().optional()});

export const baseGeneratedScorerDB = z.object({id: z.string(), name: z.string(), instructions: z.string().nullable().optional(), chain_poll_template: chainPollTemplate, user_prompt: z.string().nullable().optional()});

export const baseRegisteredScorerDB = z.object({id: z.string(), name: z.string(), score_type: z.string().nullable().optional()});

export const lunaInputTypeEnum = z.enum(["span", "trace_object", "trace_input_output_only"]);

export const lunaOutputTypeEnum = z.enum(["float", "string", "string_list", "bool_list"]);

export const scorerName = z.enum(["action_completion_luna", "action_advancement_luna", "agentic_session_success", "agentic_session_success", "action_completion_vision", "action_completion_audio", "agentic_workflow_success", "agentic_workflow_success", "agent_efficiency", "agent_flow", "agent_flow_vision", "agent_flow_audio", "chunk_attribution_utilization_luna", "chunk_attribution_utilization", "chunk_relevance", "chunk_relevance_luna", "context_precision", "precision_at_k", "completeness_luna", "completeness", "context_adherence", "context_adherence_luna", "context_adherence_vision_luna", "context_adherence_vision", "context_adherence_audio", "context_relevance", "context_relevance_luna", "conversation_quality", "conversation_quality_vision", "conversation_quality_audio", "unsafe_output", "correctness", "correctness_vision", "correctness_audio", "ground_truth_adherence", "ground_truth_adherence_vision", "ground_truth_adherence_audio", "visual_fidelity", "visual_quality", "input_pii", "input_pii_vision_luna", "input_pii_gpt", "input_pii_vision", "input_pii_audio", "input_sexist", "input_sexist", "input_sexist_vision", "input_sexist_audio", "input_sexist_luna", "input_sexist_luna", "input_sexist_vision_luna", "input_tone", "input_tone_gpt", "input_toxicity", "input_toxicity_luna", "input_toxicity_vision_luna", "input_toxicity_vision", "input_toxicity_audio", "instruction_adherence", "instruction_adherence_vision", "instruction_adherence_audio", "output_pii", "output_pii_vision_luna", "output_pii_gpt", "output_pii_vision", "output_pii_audio", "output_sexist", "output_sexist", "output_sexist_vision", "output_sexist_audio", "output_sexist_luna", "output_sexist_luna", "output_sexist_vision_luna", "output_tone", "output_tone_gpt", "output_toxicity", "output_toxicity_luna", "output_toxicity_vision_luna", "output_toxicity_vision", "output_toxicity_audio", "prompt_injection", "prompt_injection_vision", "prompt_injection_audio", "prompt_injection_luna", "prompt_injection_vision_luna", "reasoning_coherence", "reasoning_coherence_vision", "reasoning_coherence_audio", "sql_efficiency", "sql_adherence", "sql_injection", "sql_correctness", "tool_error_rate", "tool_error_rate_luna", "tool_selection_quality", "tool_selection_quality_vision", "tool_selection_quality_audio", "tool_selection_quality_luna", "user_intent_change", "user_intent_change_vision", "user_intent_change_audio", "interruption_detection"]);

export const baseFinetunedScorerDB = z.object({id: z.string(), name: z.string(), lora_task_id: z.number().int(), lora_weights_path: z.string().nullable().optional(), prompt: z.string(), luna_input_type: lunaInputTypeEnum.nullable().optional(), luna_output_type: lunaOutputTypeEnum.nullable().optional(), class_name_to_vocab_ix: z.union([z.record(z.string(), z.array(z.number().int())), z.record(z.string(), z.number().int())]).nullable().optional(), executor: scorerName.nullable().optional()});

export const baseLuna3ScorerDB = z.object({instruction: z.string().min(1).max(10000), adapter_path: z.string().min(1).max(1024), class_name_to_vocab_ix: z.record(z.string(), z.array(z.number().int())), threshold: z.number().nullable().optional(), id: z.string()});

export const decisionChoice = z.object({label: z.string(), description: z.string().nullable().optional()});

export const decisionLevel = z.object({level: z.number().int().gte(0).lte(9), label: z.string(), description: z.string().nullable().optional()});

export const decisionBooleanCriteria = z.object({true: z.string(), false: z.string()});

export const decisionScorerDB = z.object({id: z.string(), organization_id: z.string(), created_by: z.string().nullable().optional(), question: z.string(), answer_options: z.union([z.array(z.string()), z.array(decisionChoice), z.array(decisionLevel), decisionBooleanCriteria]).nullable().optional(), created_at: z.string()});

export const baseScorerVersionDB = z.object({id: z.string(), version: z.number().int(), scorer_id: z.string(), generated_scorer: baseGeneratedScorerDB.nullable().optional(), registered_scorer: baseRegisteredScorerDB.nullable().optional(), finetuned_scorer: baseFinetunedScorerDB.nullable().optional(), luna3_scorer: baseLuna3ScorerDB.nullable().optional(), decision_scorer: decisionScorerDB.nullable().optional(), model_name: z.string().nullable().optional(), num_judges: z.number().int().nullable().optional(), cot_enabled: z.boolean().nullable().optional(), runtime: z.string().nullable().optional(), code_sha256: z.string().nullable().optional()});

export const outputTypeEnum = z.enum(["boolean", "categorical", "count", "discrete", "freeform", "percentage", "multilabel", "retrieved_chunk_list_boolean", "boolean_multilabel", "boolean_probability"]);

export const inputTypeEnum = z.enum(["basic", "llm_spans", "retriever_spans", "sessions_normalized", "sessions_trace_io_only", "tool_spans", "trace_input_only", "trace_io_only", "trace_normalized", "trace_output_only", "agent_spans", "workflow_spans", "trace_selected_spans"]);

export const multimodalCapability = z.enum(["vision", "audio"]);

export const numericRollUpMethod = z.enum(["average", "sum", "max", "min"]);

export const categoricalRollUpMethod = z.literal("category_count");

export const baseMetricRollUpConfigDB = z.object({roll_up_methods: z.union([z.array(numericRollUpMethod), z.array(categoricalRollUpMethod)])});

export const modelType = z.enum(["slm", "llm", "code", "decision"]);

export const scorerInvocationPayloadFormat = z.enum(["query", "response", "pairwise", "node_input_output"]);

export const scorerInvocationConfig = z.object({required_inputs: z.array(z.enum(["query", "response"])).optional(), payload_format: scorerInvocationPayloadFormat});

export const rollUpStrategy = z.enum(["avg", "sum", "first", "last", "none"]);

export const runtimeScorerConfig = z.object({id: z.string(), scorer_version_id: z.string().nullable().optional(), filters: z.array(z.discriminatedUnion("name", [nodeNameFilter, metadataFilter, modalityFilter])).nullable().optional(), roll_up_method: rollUpMethodDisplayOptions.nullable().optional(), name: z.string().nullable().optional(), scorer_type: scorerTypes.nullable().optional(), model_name: z.string().nullable().optional(), num_judges: z.number().int().nullable().optional(), scorer_version: baseScorerVersionDB.nullable().optional(), scoreable_node_types: z.array(z.string()).nullable().optional(), cot_enabled: z.boolean().nullable().optional(), output_type: outputTypeEnum.nullable().optional(), input_type: inputTypeEnum.nullable().optional(), multimodal_capabilities: z.array(multimodalCapability).nullable().optional(), roll_up_config: baseMetricRollUpConfigDB.nullable().optional(), score_type: z.string().nullable().optional(), model_type: modelType.nullable().optional(), invocation: scorerInvocationConfig.nullable().optional(), chainpoll_template: chainPollTemplate.nullable().optional(), metric_name: z.string().nullable().optional(), scorer_path_name: z.string().nullable().optional(), user_code: z.string().nullable().optional(), registered_scorer_id: z.string().nullable().optional(), model_alias: z.string().nullable().optional(), ground_truth: z.boolean().optional(), requires_tools_in_llm_span: z.boolean().optional(), default_model_alias: z.string().nullable().optional(), roll_up_strategy: rollUpStrategy.nullable().optional(), required_scorers: z.array(z.string()).nullable().optional(), required_metric_ids: z.array(z.string()).nullable().optional(), instruction: z.string().nullable().optional(), adapter: z.string().nullable().optional(), threshold: z.number().optional(), prompt: z.string().nullable().optional(), lora_task_id: z.number().int().nullable().optional(), lora_weights_path: z.string().nullable().optional(), luna_input_type: lunaInputTypeEnum.nullable().optional(), luna_output_type: lunaOutputTypeEnum.nullable().optional(), class_name_to_vocab_ix: z.union([z.record(z.string(), z.array(z.number().int())), z.record(z.string(), z.number().int())]).nullable().optional(), decision_question: z.string().nullable().optional(), decision_answer_options: z.union([z.array(z.string()), z.array(decisionChoice), z.array(decisionLevel), decisionBooleanCriteria]).nullable().optional()});

export const insightType = z.enum(["vertical_bar", "horizontal_bar"]);

export const logRecordsFilterType = z.enum(["id", "date", "number", "boolean", "text", "collection", "fully_annotated"]);

export const logRecordsColumnInfo = z.object({id: z.string(), label: z.string().nullable().optional(), category: columnCategory, description: z.string().nullable().optional(), group_label: z.string().nullable().optional(), data_type: dataType.nullable(), data_unit: dataUnit.nullable().optional(), multi_valued: z.boolean().optional(), allowed_values: z.array(z.unknown()).nullable().optional(), sortable: z.boolean().optional(), filterable: z.boolean().optional(), is_empty: z.boolean().optional(), applicable_types: z.array(stepType).optional(), is_optional: z.boolean().optional(), roll_up_method: z.string().nullable().optional(), metric_key_alias: z.string().nullable().optional(), threshold: metricThreshold.nullable().optional(), scorer_config: runtimeScorerConfig.nullable().optional(), scorer_id: z.string().nullable().optional(), insight_type: insightType.nullable().optional(), filter_type: logRecordsFilterType.nullable().optional(), label_color: z.enum(["positive", "negative"]).nullable().optional()});

export const logRecordsAvailableColumnsResponse = z.object({columns: z.array(logRecordsColumnInfo).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
};

/**
 * Sessions Available Columns
 * 
 * POST /public/v2/projects/{project_id}/sessions/available_columns
 * 
 * Also accepts auth: ClassicAPIKeyHeader, OAuth2PasswordBearer, HTTPBasic
 */
export const createApiPublicV2ProjectsProjectIdSessionsAvailableColumns = async (args: CreateApiPublicV2ProjectsProjectIdSessionsAvailableColumnsArgs, options?: CreateApiPublicV2ProjectsProjectIdSessionsAvailableColumnsOptions) => {
const {baseUrl = "https://api.galileo.ai", fetch: fetchFn = fetch, APIKeyHeader} = options ?? {}

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

if (APIKeyHeader !== undefined) headers.set("Splunk-AO-API-Key", APIKeyHeader)

const url = `${baseUrl.replace(/\/+$/, '')}/public/v2/projects/${encodeURIComponent(String(args.project_id))}/sessions/available_columns${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "POST", headers, body: JSON.stringify(args.body)})

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

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