import {z} from 'zod'

export type GetApiCollectionsCollectionNameArgs = {collection_name: string};

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

export const hardwareUsage = z.object({cpu: z.number().int().gte(0), payload_io_read: z.number().int().gte(0), payload_io_write: z.number().int().gte(0), payload_index_io_read: z.number().int().gte(0), payload_index_io_write: z.number().int().gte(0), vector_io_read: z.number().int().gte(0), vector_io_write: z.number().int().gte(0)});

export const modelUsage = z.object({tokens: z.number().int().gte(0)});

export const inferenceUsage = z.object({models: z.record(z.string(), modelUsage)});

export const usage = z.object({hardware: z.union([hardwareUsage, z.unknown()]).optional(), inference: z.union([inferenceUsage, z.unknown()]).optional()});

export const collectionStatus = z.enum(["green", "yellow", "grey", "red"]);

export const optimizersStatus = z.union([z.literal("ok"), z.object({error: z.string()})]);

export const collectionWarning = z.object({message: z.string()});

export const distance = z.enum(["Cosine", "Euclid", "Dot", "Manhattan"]);

export const memory = z.enum(["cold", "cached", "pinned"]);

export const hnswConfigDiff = z.object({m: z.number().int().gte(0).nullable().optional(), ef_construct: z.number().int().gte(4).nullable().optional(), full_scan_threshold: z.number().int().gte(10).nullable().optional(), max_indexing_threads: z.number().int().gte(0).nullable().optional(), on_disk: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), payload_m: z.number().int().gte(0).nullable().optional(), inline_storage: z.boolean().nullable().optional()});

export const scalarType = z.literal("int8");

export const scalarQuantizationConfig = z.object({type: scalarType, quantile: z.number().gte(0.5).lte(1).nullable().optional(), always_ram: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional()});

export const scalarQuantization = z.object({scalar: scalarQuantizationConfig});

export const compressionRatio = z.enum(["x4", "x8", "x16", "x32", "x64"]);

export const productQuantizationConfig = z.object({compression: compressionRatio, always_ram: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional()});

export const productQuantization = z.object({product: productQuantizationConfig});

export const binaryQuantizationEncoding = z.enum(["one_bit", "two_bits", "one_and_half_bits"]);

export const binaryQuantizationQueryEncoding = z.enum(["default", "binary", "scalar4bits", "scalar8bits"]);

export const binaryQuantizationConfig = z.object({always_ram: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), encoding: z.union([binaryQuantizationEncoding, z.unknown()]).optional(), query_encoding: z.union([binaryQuantizationQueryEncoding, z.unknown()]).optional()});

export const binaryQuantization = z.object({binary: binaryQuantizationConfig});

export const turboQuantBitSize = z.enum(["bits1", "bits1_5", "bits2", "bits4", "bits8"]);

export const turboQuantQuantizationConfig = z.object({always_ram: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), bits: z.union([turboQuantBitSize, z.unknown()]).optional()});

export const turboQuantization = z.object({turbo: turboQuantQuantizationConfig});

export const quantizationConfig = z.union([scalarQuantization, productQuantization, binaryQuantization, turboQuantization]);

export const datatype = z.enum(["float32", "uint8", "float16", "turbo4", "turbo8", "turbo16"]);

export const multiVectorComparator = z.literal("max_sim");

export const multiVectorConfig = z.object({comparator: multiVectorComparator});

export const vectorParams = z.object({size: z.number().int().gte(1).lte(65536), distance: distance, hnsw_config: z.union([hnswConfigDiff, z.unknown()]).optional(), quantization_config: z.union([quantizationConfig, z.unknown()]).optional(), on_disk: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), datatype: z.union([datatype, z.unknown()]).optional(), multivector_config: z.union([multiVectorConfig, z.unknown()]).optional()});

export const vectorsConfig = z.union([vectorParams, z.record(z.string(), vectorParams)]);

export const shardingMethod = z.enum(["auto", "custom"]);

export const payloadStorageParams = z.object({memory: z.union([memory, z.unknown()]).optional()});

export const idTrackerParams = z.object({memory: z.union([memory, z.unknown()]).optional()});

export const sparseIndexParams = z.object({full_scan_threshold: z.number().int().gte(0).nullable().optional(), on_disk: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), datatype: z.union([datatype, z.unknown()]).optional()});

export const modifier = z.enum(["none", "idf"]);

export const sparseVectorParams = z.object({index: z.union([sparseIndexParams, z.unknown()]).optional(), modifier: z.union([modifier, z.unknown()]).optional()});

export const collectionParams = z.object({vectors: vectorsConfig.optional(), shard_number: z.number().int().gte(1).optional(), sharding_method: z.union([shardingMethod, z.unknown()]).optional(), replication_factor: z.number().int().gte(1).optional(), write_consistency_factor: z.number().int().gte(1).optional(), read_fan_out_factor: z.number().int().gte(0).nullable().optional(), read_fan_out_delay_ms: z.number().int().gte(0).nullable().optional(), on_disk_payload: z.boolean().nullable().optional(), payload: z.union([payloadStorageParams, z.unknown()]).optional(), id_tracker: z.union([idTrackerParams, z.unknown()]).optional(), sparse_vectors: z.record(z.string(), sparseVectorParams).nullable().optional()});

export const hnswConfig = z.object({m: z.number().int().gte(0), ef_construct: z.number().int().gte(4), full_scan_threshold: z.number().int().gte(0), max_indexing_threads: z.number().int().gte(0).optional(), on_disk: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), payload_m: z.number().int().gte(0).nullable().optional(), inline_storage: z.boolean().nullable().optional()});

export const optimizersConfig = z.object({deleted_threshold: z.number().gte(0).lte(1).optional(), vacuum_min_vector_number: z.number().int().gte(100).optional(), default_segment_number: z.number().int().gte(0), max_segment_size: z.number().int().gte(1).nullable().optional(), memmap_threshold: z.number().int().gte(0).nullable().optional(), indexing_threshold: z.number().int().gte(0).nullable().optional(), flush_interval_sec: z.number().int().gte(0), max_optimization_threads: z.number().int().gte(0).nullable().optional(), prevent_unoptimized: z.boolean().nullable().optional()});

export const walConfig = z.object({wal_capacity_mb: z.number().int().gte(1), wal_segments_ahead: z.number().int().gte(0), wal_retain_closed: z.number().int().gte(1).optional()});

export const strictModeMultivectorOutput = z.object({max_vectors: z.number().int().gte(0).nullable().optional()});

export const strictModeMultivectorConfigOutput = z.record(z.string(), strictModeMultivectorOutput);

export const strictModeSparseOutput = z.object({max_length: z.number().int().gte(0).nullable().optional()});

export const strictModeSparseConfigOutput = z.record(z.string(), strictModeSparseOutput);

export const strictModeConfigOutput = z.object({enabled: z.boolean().nullable().optional(), max_query_limit: z.number().int().gte(0).nullable().optional(), max_timeout: z.number().int().gte(0).nullable().optional(), unindexed_filtering_retrieve: z.boolean().nullable().optional(), unindexed_filtering_update: z.boolean().nullable().optional(), search_max_hnsw_ef: z.number().int().gte(0).nullable().optional(), search_allow_exact: z.boolean().nullable().optional(), search_max_oversampling: z.number().nullable().optional(), upsert_max_batchsize: z.number().int().gte(0).nullable().optional(), search_max_batchsize: z.number().int().gte(0).nullable().optional(), max_collection_vector_size_bytes: z.number().int().gte(0).nullable().optional(), read_rate_limit: z.number().int().gte(0).nullable().optional(), write_rate_limit: z.number().int().gte(0).nullable().optional(), max_collection_payload_size_bytes: z.number().int().gte(0).nullable().optional(), max_points_count: z.number().int().gte(0).nullable().optional(), filter_max_conditions: z.number().int().gte(0).nullable().optional(), condition_max_size: z.number().int().gte(0).nullable().optional(), multivector_config: z.union([strictModeMultivectorConfigOutput, z.unknown()]).optional(), sparse_config: z.union([strictModeSparseConfigOutput, z.unknown()]).optional(), max_payload_index_count: z.number().int().gte(0).nullable().optional(), max_resident_memory_percent: z.number().int().gte(0).nullable().optional()});

export const payload = z.record(z.string(), z.unknown());

export const collectionConfig = z.object({params: collectionParams, hnsw_config: hnswConfig, optimizer_config: optimizersConfig, wal_config: z.union([walConfig, z.unknown()]).optional(), quantization_config: z.union([quantizationConfig, z.unknown()]).optional(), strict_mode_config: z.union([strictModeConfigOutput, z.unknown()]).optional(), metadata: z.union([payload, z.unknown()]).optional()});

export const payloadSchemaType = z.enum(["keyword", "integer", "float", "geo", "text", "bool", "datetime", "uuid"]);

export const keywordIndexType = z.literal("keyword");

export const keywordIndexParams = z.object({type: keywordIndexType, is_tenant: z.boolean().nullable().optional(), on_disk: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), enable_hnsw: z.boolean().nullable().optional(), prefix: z.boolean().nullable().optional(), nested: z.string().nullable().optional()});

export const integerIndexType = z.literal("integer");

export const integerIndexParams = z.object({type: integerIndexType, lookup: z.boolean().nullable().optional(), range: z.boolean().nullable().optional(), is_principal: z.boolean().nullable().optional(), on_disk: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), enable_hnsw: z.boolean().nullable().optional(), nested: z.string().nullable().optional()});

export const floatIndexType = z.literal("float");

export const floatIndexParams = z.object({type: floatIndexType, is_principal: z.boolean().nullable().optional(), on_disk: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), enable_hnsw: z.boolean().nullable().optional(), nested: z.string().nullable().optional()});

export const geoIndexType = z.literal("geo");

export const geoIndexParams = z.object({type: geoIndexType, on_disk: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), enable_hnsw: z.boolean().nullable().optional(), nested: z.string().nullable().optional()});

export const textIndexType = z.literal("text");

export const tokenizerType = z.enum(["prefix", "whitespace", "word", "multilingual", "code"]);

export const language = z.enum(["arabic", "azerbaijani", "basque", "bengali", "catalan", "chinese", "danish", "dutch", "english", "finnish", "french", "german", "greek", "hebrew", "hinglish", "hungarian", "indonesian", "italian", "japanese", "kazakh", "nepali", "norwegian", "portuguese", "romanian", "russian", "slovene", "spanish", "swedish", "tajik", "turkish"]);

export const stopwordsSet = z.object({languages: z.array(language).nullable().optional(), custom: z.array(z.string()).nullable().optional()});

export const stopwordsInterface = z.union([language, stopwordsSet]);

export const snowball = z.literal("snowball");

export const snowballLanguage = z.enum(["arabic", "armenian", "danish", "dutch", "english", "finnish", "french", "german", "greek", "hungarian", "italian", "norwegian", "portuguese", "romanian", "russian", "spanish", "swedish", "tamil", "turkish"]);

export const snowballParams = z.object({type: snowball, language: snowballLanguage});

export const noStemmer = z.literal("none");

export const disabledStemmerParams = z.object({type: noStemmer});

export const stemmingAlgorithm = z.union([snowballParams, disabledStemmerParams]);

export const textScoringType = z.literal("bm25");

export const textScoringParams = z.object({type: textScoringType});

export const textScoringInterface = z.union([z.boolean(), textScoringParams]);

export const textIndexParams = z.object({type: textIndexType, tokenizer: tokenizerType.optional(), min_token_len: z.number().int().gte(0).nullable().optional(), max_token_len: z.number().int().gte(0).nullable().optional(), lowercase: z.boolean().nullable().optional(), ascii_folding: z.boolean().nullable().optional(), phrase_matching: z.boolean().nullable().optional(), stopwords: z.union([stopwordsInterface, z.unknown()]).optional(), on_disk: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), stemmer: z.union([stemmingAlgorithm, z.unknown()]).optional(), enable_hnsw: z.boolean().nullable().optional(), scoring: z.union([textScoringInterface, z.unknown()]).optional(), nested: z.string().nullable().optional()});

export const boolIndexType = z.literal("bool");

export const boolIndexParams = z.object({type: boolIndexType, on_disk: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), enable_hnsw: z.boolean().nullable().optional(), nested: z.string().nullable().optional()});

export const datetimeIndexType = z.literal("datetime");

export const datetimeIndexParams = z.object({type: datetimeIndexType, is_principal: z.boolean().nullable().optional(), on_disk: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), enable_hnsw: z.boolean().nullable().optional(), nested: z.string().nullable().optional()});

export const uuidIndexType = z.literal("uuid");

export const uuidIndexParams = z.object({type: uuidIndexType, is_tenant: z.boolean().nullable().optional(), on_disk: z.boolean().nullable().optional(), memory: z.union([memory, z.unknown()]).optional(), enable_hnsw: z.boolean().nullable().optional(), nested: z.string().nullable().optional()});

export const payloadSchemaParams = z.union([keywordIndexParams, integerIndexParams, floatIndexParams, geoIndexParams, textIndexParams, boolIndexParams, datetimeIndexParams, uuidIndexParams]);

export const payloadIndexInfo = z.object({data_type: payloadSchemaType, params: z.union([payloadSchemaParams, z.unknown()]).optional(), points: z.number().int().gte(0)});

export const updateQueueInfo = z.object({length: z.number().int().gte(0), deferred_points: z.number().int().gte(0).nullable().optional()});

export const collectionInfo = z.object({status: collectionStatus, optimizer_status: optimizersStatus, warnings: z.array(collectionWarning).optional(), indexed_vectors_count: z.number().int().gte(0).nullable().optional(), points_count: z.number().int().gte(0).nullable().optional(), segments_count: z.number().int().gte(0), config: collectionConfig, payload_schema: z.record(z.string(), payloadIndexInfo), update_queue: z.union([updateQueueInfo, z.unknown()]).optional(), created_at: z.string().nullable().optional()});

export const getApiCollectionsCollectionNameResponse = z.object({usage: z.union([usage, z.unknown()]).optional(), time: z.number().optional(), status: z.string().optional(), result: collectionInfo.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
};

/**
 * Collection info
 * 
 * GET /collections/{collection_name}
 * 
 * Also accepts auth: bearerAuth
 */
export const getApiCollectionsCollectionName = async (args: GetApiCollectionsCollectionNameArgs, options?: GetApiCollectionsCollectionNameOptions) => {
const {baseUrl = "http://localhost:6333", fetch: fetchFn = fetch, apiKey} = options ?? {}

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

if (apiKey !== undefined) headers.set("api-key", apiKey)

const url = `${baseUrl.replace(/\/+$/, '')}/collections/${encodeURIComponent(String(args.collection_name))}${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(getApiCollectionsCollectionNameResponse, await res.json())
};