import {z} from 'zod'

export type GetApiTelemetryArgs = {anonymize?: boolean | undefined, details_level?: number | undefined, per_collection?: boolean | undefined, timeout?: number | undefined};

export type GetApiTelemetryOptions = {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 appFeaturesTelemetry = z.object({debug: z.boolean(), service_debug_feature: z.boolean(), recovery_mode: z.boolean(), gpu: z.boolean(), rocksdb: z.boolean(), staging: z.boolean()});

export const featureFlags = z.object({all: z.boolean().optional(), incremental_hnsw_building: z.boolean().optional(), appendable_quantization: z.boolean().optional(), single_file_mmap_vector_storage: z.boolean().optional(), async_payload_storage: z.boolean().optional(), async_hnsw_graph: z.boolean().optional(), write_segment_manifest: z.boolean().optional(), append_only_mutations: z.boolean().optional(), compact_bitmask: z.boolean().optional(), append_only_storages: z.boolean().optional(), compact_logstore_tracker: z.boolean().optional(), transfer_raw_points: z.boolean().optional(), transfer_raw_payloads: z.boolean().optional(), persist_proxy_segments: z.boolean().optional(), combined_vector_storage: z.boolean().optional(), serverless_compatible: z.boolean().optional()});

export const lowMemoryMode = z.union([z.literal("disabled"), z.literal("no_resident"), z.literal("no_populate")]);

export const hnswGlobalConfig = z.object({healing_threshold: z.number().gte(0).lte(1).optional()});

export const containerRuntime = z.enum(["none", "docker", "kubernetes", "other"]);

export const cpuEndian = z.enum(["little", "big", "other"]);

export const gpuDeviceTelemetry = z.object({name: z.string()});

export const runningEnvironmentTelemetry = z.object({distribution: z.string().nullable().optional(), distribution_version: z.string().nullable().optional(), is_docker: z.boolean(), container_runtime: containerRuntime, cores: z.number().int().gte(0).nullable().optional(), cpu_cores_used: z.number().nullable().optional(), ram_size: z.number().int().gte(0).nullable().optional(), disk_size: z.number().int().gte(0).nullable().optional(), cpu_flags: z.string(), cpu_endian: z.union([cpuEndian, z.unknown()]).optional(), gpu_devices: z.array(gpuDeviceTelemetry).nullable().optional()});

export const auditTelemetry = z.object({dir: z.string(), rotation: z.string(), max_log_files: z.number().int().gte(0), trust_forwarded_headers: z.boolean(), log_api: z.boolean(), output: z.string(), dir_size_bytes: z.number().int().gte(0).nullable().optional()});

export const appBuildTelemetry = z.object({name: z.string(), version: z.string(), features: z.union([appFeaturesTelemetry, z.unknown()]).optional(), runtime_features: z.union([featureFlags, z.unknown()]).optional(), low_memory_mode: z.union([lowMemoryMode, z.unknown()]).optional(), hnsw_global_config: z.union([hnswGlobalConfig, z.unknown()]).optional(), system: z.union([runningEnvironmentTelemetry, z.unknown()]).optional(), jwt_rbac: z.boolean().nullable().optional(), hide_jwt_dashboard: z.boolean().nullable().optional(), audit: z.union([auditTelemetry, z.unknown()]).optional(), startup: 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 collectionConfigTelemetry = z.object({params: collectionParams, hnsw_config: hnswConfig, optimizer_config: optimizersConfig, wal_config: walConfig, quantization_config: z.union([quantizationConfig, z.unknown()]).optional(), strict_mode_config: z.union([strictModeConfigOutput, z.unknown()]).optional(), uuid: z.string().nullable().optional(), metadata: z.union([payload, z.unknown()]).optional()});

export const shardKey = z.union([z.string(), z.number().int().gte(0)]);

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

export const segmentType = z.enum(["plain", "indexed", "special"]);

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 ioBackend = z.enum(["mmap", "io_uring"]);

export const vectorDataInfo = z.object({num_vectors: z.number().int().gte(0), num_indexed_vectors: z.number().int().gte(0), num_deleted_vectors: z.number().int().gte(0), io_backend: z.union([ioBackend, z.unknown()]).optional()});

export const segmentInfo = z.object({uuid: z.string(), segment_type: segmentType, num_vectors: z.number().int().gte(0), num_points: z.number().int().gte(0), num_deferred_points: z.number().int().gte(0).nullable().optional(), num_deleted_deferred_points: z.number().int().gte(0).nullable().optional(), num_indexed_vectors: z.number().int().gte(0), num_deleted_vectors: z.number().int().gte(0), vectors_size_bytes: z.number().int().gte(0), payloads_size_bytes: z.number().int().gte(0), ram_usage_bytes: z.number().int().gte(0), disk_usage_bytes: z.number().int().gte(0), is_appendable: z.boolean(), index_schema: z.record(z.string(), payloadIndexInfo), vector_data: z.record(z.string(), vectorDataInfo), payload_storage_io_backend: z.union([ioBackend, z.unknown()]).optional(), deferred_internal_id: z.number().int().gte(0).nullable().optional()});

export const vectorStorageType = z.union([z.literal("Memory"), z.literal("Mmap"), z.literal("ChunkedMmap"), z.literal("InRamChunkedMmap"), z.literal("InRamMmap"), z.literal("GraphInline")]);

export const indexes = z.union([z.object({type: z.literal("plain"), options: z.object({})}), z.object({type: z.literal("hnsw"), options: hnswConfig})]);

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

export const vectorDataConfig = z.object({size: z.number().int().gte(0), distance: distance, storage_type: vectorStorageType, index: indexes, quantization_config: z.union([quantizationConfig, z.unknown()]).optional(), multivector_config: z.union([multiVectorConfig, z.unknown()]).optional(), datatype: z.union([vectorStorageDatatype, z.unknown()]).optional()});

export const sparseIndexType = z.union([z.literal("MutableRam"), z.literal("ImmutableRam"), z.literal("Mmap")]);

export const sparseIndexConfig = z.object({full_scan_threshold: z.number().int().gte(0).nullable().optional(), index_type: sparseIndexType, datatype: z.union([vectorStorageDatatype, z.unknown()]).optional(), memory: z.union([memory, z.unknown()]).optional()});

export const sparseVectorStorageType = z.literal("mmap");

export const sparseVectorDataConfig = z.object({index: sparseIndexConfig, storage_type: sparseVectorStorageType.optional(), modifier: z.union([modifier, z.unknown()]).optional()});

export const payloadStorageType = z.union([z.object({type: z.literal("mmap")}), z.object({type: z.literal("in_ram_mmap")})]);

export const segmentConfig = z.object({vector_data: z.record(z.string(), vectorDataConfig).optional(), sparse_vector_data: z.record(z.string(), sparseVectorDataConfig).optional(), payload_storage_type: payloadStorageType, id_tracker_memory: z.union([memory, z.unknown()]).optional()});

export const operationDurationStatistics = z.object({count: z.number().int().gte(0), fail_count: z.number().int().gte(0).nullable().optional(), avg_duration_micros: z.number().nullable().optional(), min_duration_micros: z.number().nullable().optional(), max_duration_micros: z.number().nullable().optional(), total_duration_micros: z.number().int().gte(0).nullable().optional(), last_responded: z.string().nullable().optional()});

export const vectorIndexSearchesTelemetry = z.object({index_name: z.string().nullable().optional(), unfiltered_plain: operationDurationStatistics, unfiltered_hnsw: operationDurationStatistics, unfiltered_sparse: operationDurationStatistics, filtered_plain: operationDurationStatistics, filtered_small_cardinality: operationDurationStatistics, filtered_large_cardinality: operationDurationStatistics, filtered_acorn: operationDurationStatistics.optional(), filtered_exact: operationDurationStatistics, filtered_sparse: operationDurationStatistics, unfiltered_exact: operationDurationStatistics});

export const payloadIndexTelemetry = z.object({field_name: z.string().nullable().optional(), index_type: z.string(), points_values_count: z.number().int().gte(0), points_count: z.number().int().gte(0), histogram_bucket_size: z.number().int().gte(0).nullable().optional()});

export const segmentTelemetry = z.object({info: segmentInfo, config: segmentConfig, vector_index_searches: z.array(vectorIndexSearchesTelemetry), payload_field_indices: z.array(payloadIndexTelemetry)});

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

export const trackerStatus = z.union([z.enum(["optimizing", "done"]), z.object({cancelled: z.string()}), z.object({error: z.string()})]);

export const trackerTelemetry = z.object({name: z.string(), uuid: z.string(), segment_ids: z.array(z.number().int().gte(0)), segment_uuids: z.array(z.string()), status: trackerStatus, start_at: z.string(), end_at: z.string().nullable().optional()});

export const optimizerTelemetry = z.object({status: optimizersStatus, optimizations: operationDurationStatistics, log: z.array(trackerTelemetry).nullable().optional()});

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

export const localShardTelemetry = z.object({variant_name: z.string().nullable().optional(), status: z.union([shardStatus, z.unknown()]).optional(), total_optimized_points: z.number().int().gte(0), vectors_size_bytes: z.number().int().gte(0).nullable().optional(), payloads_size_bytes: z.number().int().gte(0).nullable().optional(), num_points: z.number().int().gte(0).nullable().optional(), num_vectors: z.number().int().gte(0).nullable().optional(), num_vectors_by_name: z.record(z.string(), z.number().int().gte(0)).nullable().optional(), segments: z.array(segmentTelemetry).nullable().optional(), optimizations: z.union([optimizerTelemetry, z.unknown()]).optional(), async_scorer: z.boolean().nullable().optional(), indexed_only_excluded_vectors: z.record(z.string(), z.number().int().gte(0)).nullable().optional(), update_queue: z.union([shardUpdateQueueInfo, z.unknown()]).optional()});

export const remoteShardTelemetry = z.object({shard_id: z.number().int().gte(0), peer_id: z.number().int().gte(0), searches: z.union([operationDurationStatistics, z.unknown()]).optional(), updates: z.union([operationDurationStatistics, z.unknown()]).optional()});

export const replicaState = z.enum(["Active", "Dead", "Partial", "Initializing", "Listener", "PartialSnapshot", "Recovery", "Resharding", "ReshardingScaleDown", "ActiveRead", "ManualRecovery"]);

export const partialSnapshotTelemetry = z.object({ongoing_create_snapshot_requests: z.number().int().gte(0), is_recovering: z.boolean(), recovery_timestamp: z.number().int().gte(0)});

export const replicaSetTelemetry = z.object({id: z.number().int().gte(0), key: z.union([shardKey, z.unknown()]).optional(), local: z.union([localShardTelemetry, z.unknown()]).optional(), remote: z.array(remoteShardTelemetry), replicate_states: z.record(z.string(), replicaState), partial_snapshot: z.union([partialSnapshotTelemetry, z.unknown()]).optional()});

export const shardTransferMethod = z.enum(["stream_records", "snapshot", "wal_delta", "resharding_stream_records"]);

export const shardTransferInfo = z.object({shard_id: z.number().int().gte(0), to_shard_id: z.number().int().gte(0).nullable().optional(), from: z.number().int().gte(0), to: z.number().int().gte(0), sync: z.boolean(), method: z.union([shardTransferMethod, z.unknown()]).optional(), comment: z.string().nullable().optional()});

export const reshardingStage = z.enum(["migrating_points", "read_hash_ring_committed", "write_hash_ring_committed"]);

export const reshardingDirection = z.enum(["up", "down"]);

export const reshardingTelemetry = z.object({stage: reshardingStage, direction: reshardingDirection, shard_id: z.number().int().gte(0), peer_id: z.number().int().gte(0), shard_key: z.union([shardKey, z.unknown()]).optional(), uuid: z.string()});

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

export const shardCleanStatusFailedTelemetry = z.object({reason: z.string()});

export const shardCleanStatusTelemetry = z.union([z.enum(["started", "done", "cancelled"]), z.object({progress: shardCleanStatusProgressTelemetry}), z.object({failed: shardCleanStatusFailedTelemetry})]);

export const collectionTelemetry = z.object({id: z.string(), init_time_ms: z.number().int().gte(0).nullable().optional(), config: z.union([collectionConfigTelemetry, z.unknown()]).optional(), shards: z.array(replicaSetTelemetry).nullable().optional(), transfers: z.array(shardTransferInfo).nullable().optional(), resharding: z.array(reshardingTelemetry).nullable().optional(), shard_clean_tasks: z.record(z.string(), shardCleanStatusTelemetry).nullable().optional()});

export const collectionsAggregatedTelemetry = z.object({vectors: z.number().int().gte(0), optimizers_status: optimizersStatus, params: collectionParams});

export const collectionTelemetryEnum = z.union([collectionTelemetry, collectionsAggregatedTelemetry]);

export const collectionSnapshotTelemetry = z.object({id: z.string(), running_snapshots: z.number().int().gte(0).nullable().optional(), running_snapshot_recovery: z.number().int().gte(0).nullable().optional(), total_snapshot_creations: z.number().int().gte(0).nullable().optional()});

export const collectionsTelemetry = z.object({number_of_collections: z.number().int().gte(0), max_collections: z.number().int().gte(0).nullable().optional(), collections: z.array(collectionTelemetryEnum).nullable().optional(), snapshots: z.array(collectionSnapshotTelemetry).nullable().optional()});

export const stateRole = z.enum(["Follower", "Candidate", "Leader", "PreCandidate"]);

export const consensusThreadStatus = z.union([z.object({consensus_thread_status: z.literal("working"), last_update: z.string()}), z.object({consensus_thread_status: z.literal("stopped")}), z.object({consensus_thread_status: z.literal("stopped_with_err"), err: z.string()})]);

export const clusterStatusTelemetry = z.object({number_of_peers: z.number().int().gte(0), term: z.number().int().gte(0), commit: z.number().int().gte(0), pending_operations: z.number().int().gte(0), role: z.union([stateRole, z.unknown()]).optional(), is_voter: z.boolean(), peer_id: z.number().int().gte(0).nullable().optional(), consensus_thread_status: consensusThreadStatus});

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

export const consensusConfigTelemetry = z.object({max_message_queue_size: z.number().int().gte(0), tick_period_ms: z.number().int().gte(0), bootstrap_timeout_sec: z.number().int().gte(0)});

export const clusterConfigTelemetry = z.object({grpc_timeout_ms: z.number().int().gte(0), p2p: p2pConfigTelemetry, consensus: consensusConfigTelemetry});

export const peerInfo = z.object({uri: z.string()});

export const peerMetadata = z.object({version: z.string()});

export const clusterTelemetry = z.object({enabled: z.boolean(), status: z.union([clusterStatusTelemetry, z.unknown()]).optional(), config: z.union([clusterConfigTelemetry, z.unknown()]).optional(), peers: z.record(z.string(), peerInfo).nullable().optional(), peer_metadata: z.record(z.string(), peerMetadata).nullable().optional(), metadata: z.record(z.string(), z.unknown()).nullable().optional(), resharding_enabled: z.boolean().nullable().optional()});

export const webApiTelemetry = z.object({responses: z.record(z.string(), z.record(z.string(), operationDurationStatistics)), per_collection_responses: z.record(z.string(), z.record(z.string(), z.record(z.string(), operationDurationStatistics))).optional()});

export const grpcTelemetry = z.object({responses: z.record(z.string(), z.record(z.string(), operationDurationStatistics)), per_collection_responses: z.record(z.string(), z.record(z.string(), z.record(z.string(), operationDurationStatistics))).optional()});

export const requestsTelemetry = z.object({rest: webApiTelemetry, grpc: grpcTelemetry});

export const memoryTelemetry = z.object({active_bytes: z.number().int().gte(0), allocated_bytes: z.number().int().gte(0), metadata_bytes: z.number().int().gte(0), resident_bytes: z.number().int().gte(0), retained_bytes: z.number().int().gte(0)});

export const hardwareTelemetry = z.object({collection_data: z.record(z.string(), hardwareUsage)});

export const searchThreadPoolTelemetry = z.object({mode: z.string(), high_cpu_threads: z.number().int().gte(0), high_io_threads: z.number().int().gte(0)});

export const quotaConfig = z.object({enabled: z.boolean().optional(), max_resident_memory_percent: z.number().int().gte(1).lte(100).nullable().optional(), max_disk_usage_percent: z.number().int().gte(1).lte(100).nullable().optional(), release_margin_percent: z.number().int().gte(0).lte(100).nullable().optional()});

export const quotaExceeded = z.object({resident_memory: z.boolean().nullable().optional(), disk_usage: z.boolean().nullable().optional()});

export const quotaTelemetry = z.object({config: quotaConfig, exceeded: quotaExceeded});

export const telemetryData = z.object({id: z.string(), app: z.union([appBuildTelemetry, z.unknown()]).optional(), collections: collectionsTelemetry, cluster: z.union([clusterTelemetry, z.unknown()]).optional(), requests: z.union([requestsTelemetry, z.unknown()]).optional(), memory: z.union([memoryTelemetry, z.unknown()]).optional(), hardware: z.union([hardwareTelemetry, z.unknown()]).optional(), search_pool: z.union([searchThreadPoolTelemetry, z.unknown()]).optional(), quota: z.union([quotaTelemetry, z.unknown()]).optional()});

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

/**
 * Collect telemetry data
 * 
 * GET /telemetry
 * 
 * Also accepts auth: bearerAuth
 */
export const getApiTelemetry = async (args: GetApiTelemetryArgs, options?: GetApiTelemetryOptions) => {
const {baseUrl = "http://localhost:6333", fetch: fetchFn = fetch, apiKey} = options ?? {}

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

if (args.anonymize != null) query.append("anonymize", String(args.anonymize))
if (args.details_level != null) query.append("details_level", String(args.details_level))
if (args.per_collection != null) query.append("per_collection", String(args.per_collection))
if (args.timeout != null) query.append("timeout", String(args.timeout))
if (apiKey !== undefined) headers.set("api-key", apiKey)

const url = `${baseUrl.replace(/\/+$/, '')}/telemetry${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(getApiTelemetryResponse, await res.json())
};