import { Client } from '../api-client.js';
export declare function createPointsApi(client: Client): {
    /**
     * Remove all payload for specified points
     */
    readonly clearPayload: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                wait?: boolean | undefined;
                ordering?: "weak" | "medium" | "strong" | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    points: (string | number)[];
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                } | {
                    filter: {
                        should?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must_not?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                    };
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            operation_id?: number | null | undefined;
                            status: "acknowledged" | "completed";
                        } | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Count points which matches given filtering condition
     */
    readonly countPoints: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                    filter?: Record<string, unknown> | {
                        should?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must_not?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                    } | null | undefined;
                    exact?: boolean | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            count: number;
                        } | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Delete specified key payload for points
     */
    readonly deletePayload: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                wait?: boolean | undefined;
                ordering?: "weak" | "medium" | "strong" | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    keys: string[];
                    points?: (string | number)[] | null | undefined;
                    filter?: Record<string, unknown> | {
                        should?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must_not?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                    } | null | undefined;
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            operation_id?: number | null | undefined;
                            status: "acknowledged" | "completed";
                        } | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Delete points
     */
    readonly deletePoints: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                wait?: boolean | undefined;
                ordering?: "weak" | "medium" | "strong" | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    points: (string | number)[];
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                } | {
                    filter: {
                        should?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must_not?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                    };
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            operation_id?: number | null | undefined;
                            status: "acknowledged" | "completed";
                        } | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Update vectors
     */
    readonly updateVectors: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                wait?: boolean | undefined;
                ordering?: "weak" | "medium" | "strong" | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    points: {
                        id: string | number;
                        vector: number[] | {
                            [key: string]: number[] | {
                                indices: number[];
                                values: number[];
                            } | undefined;
                        };
                    }[];
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            operation_id?: number | null | undefined;
                            status: "acknowledged" | "completed";
                        } | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Delete vectors
     */
    readonly deleteVectors: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                wait?: boolean | undefined;
                ordering?: "weak" | "medium" | "strong" | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    points?: (string | number)[] | null | undefined;
                    filter?: Record<string, unknown> | {
                        should?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must_not?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                    } | null | undefined;
                    vector: string[];
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            operation_id?: number | null | undefined;
                            status: "acknowledged" | "completed";
                        } | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Retrieve full information of single point by id
     */
    readonly getPoint: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                consistency?: number | "majority" | "quorum" | "all" | undefined;
            } | undefined;
            path: {
                collection_name: string;
                id: string | number;
            };
        };
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            id: string | number;
                            payload?: Record<string, unknown> | {
                                [key: string]: unknown;
                            } | null | undefined;
                            vector?: Record<string, unknown> | number[] | {
                                [key: string]: number[] | {
                                    indices: number[];
                                    values: number[];
                                } | undefined;
                            } | null | undefined;
                            shard_key?: string | number | Record<string, unknown> | null | undefined;
                        } | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Retrieve multiple points by specified IDs
     */
    readonly getPoints: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                consistency?: number | "majority" | "quorum" | "all" | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                    ids: (string | number)[];
                    with_payload?: boolean | Record<string, unknown> | string[] | {
                        include: string[];
                    } | {
                        exclude: string[];
                    } | null | undefined;
                    with_vector?: boolean | string[] | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            id: string | number;
                            payload?: Record<string, unknown> | {
                                [key: string]: unknown;
                            } | null | undefined;
                            vector?: Record<string, unknown> | number[] | {
                                [key: string]: number[] | {
                                    indices: number[];
                                    values: number[];
                                } | undefined;
                            } | null | undefined;
                            shard_key?: string | number | Record<string, unknown> | null | undefined;
                        }[] | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Replace full payload of points with new one
     */
    readonly overwritePayload: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                wait?: boolean | undefined;
                ordering?: "weak" | "medium" | "strong" | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    payload: {
                        [key: string]: unknown;
                    };
                    points?: (string | number)[] | null | undefined;
                    filter?: Record<string, unknown> | {
                        should?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must_not?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                    } | null | undefined;
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            operation_id?: number | null | undefined;
                            status: "acknowledged" | "completed";
                        } | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Look for the points which are closer to stored positive examples and at the same time further to negative examples.
     */
    readonly recommendBatchPoints: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                consistency?: number | "majority" | "quorum" | "all" | undefined;
                timeout?: number | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    searches: {
                        shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        positive?: (string | number | number[] | {
                            indices: number[];
                            values: number[];
                        })[] | undefined;
                        negative?: (string | number | number[] | {
                            indices: number[];
                            values: number[];
                        })[] | undefined;
                        strategy?: Record<string, unknown> | "average_vector" | "best_score" | null | undefined;
                        filter?: Record<string, unknown> | {
                            should?: (any | {
                                key: string;
                                match?: Record<string, unknown> | {
                                    value: string | number | boolean;
                                } | {
                                    text: string;
                                } | {
                                    any: string[] | number[];
                                } | {
                                    except: string[] | number[];
                                } | null | undefined;
                                range?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                                geo_bounding_box?: Record<string, unknown> | {
                                    top_left: {
                                        lon: number;
                                        lat: number;
                                    };
                                    bottom_right: {
                                        lon: number;
                                        lat: number;
                                    };
                                } | null | undefined;
                                geo_radius?: Record<string, unknown> | {
                                    center: {
                                        lon: number;
                                        lat: number;
                                    };
                                    radius: number;
                                } | null | undefined;
                                geo_polygon?: Record<string, unknown> | {
                                    exterior: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    };
                                    interiors?: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    }[] | null | undefined;
                                } | null | undefined;
                                values_count?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                            } | {
                                is_empty: {
                                    key: string;
                                };
                            } | {
                                is_null: {
                                    key: string;
                                };
                            } | {
                                has_id: (string | number)[];
                            } | {
                                nested: {
                                    key: string;
                                    filter: any;
                                };
                            })[] | null | undefined;
                            must?: (any | {
                                key: string;
                                match?: Record<string, unknown> | {
                                    value: string | number | boolean;
                                } | {
                                    text: string;
                                } | {
                                    any: string[] | number[];
                                } | {
                                    except: string[] | number[];
                                } | null | undefined;
                                range?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                                geo_bounding_box?: Record<string, unknown> | {
                                    top_left: {
                                        lon: number;
                                        lat: number;
                                    };
                                    bottom_right: {
                                        lon: number;
                                        lat: number;
                                    };
                                } | null | undefined;
                                geo_radius?: Record<string, unknown> | {
                                    center: {
                                        lon: number;
                                        lat: number;
                                    };
                                    radius: number;
                                } | null | undefined;
                                geo_polygon?: Record<string, unknown> | {
                                    exterior: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    };
                                    interiors?: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    }[] | null | undefined;
                                } | null | undefined;
                                values_count?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                            } | {
                                is_empty: {
                                    key: string;
                                };
                            } | {
                                is_null: {
                                    key: string;
                                };
                            } | {
                                has_id: (string | number)[];
                            } | {
                                nested: {
                                    key: string;
                                    filter: any;
                                };
                            })[] | null | undefined;
                            must_not?: (any | {
                                key: string;
                                match?: Record<string, unknown> | {
                                    value: string | number | boolean;
                                } | {
                                    text: string;
                                } | {
                                    any: string[] | number[];
                                } | {
                                    except: string[] | number[];
                                } | null | undefined;
                                range?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                                geo_bounding_box?: Record<string, unknown> | {
                                    top_left: {
                                        lon: number;
                                        lat: number;
                                    };
                                    bottom_right: {
                                        lon: number;
                                        lat: number;
                                    };
                                } | null | undefined;
                                geo_radius?: Record<string, unknown> | {
                                    center: {
                                        lon: number;
                                        lat: number;
                                    };
                                    radius: number;
                                } | null | undefined;
                                geo_polygon?: Record<string, unknown> | {
                                    exterior: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    };
                                    interiors?: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    }[] | null | undefined;
                                } | null | undefined;
                                values_count?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                            } | {
                                is_empty: {
                                    key: string;
                                };
                            } | {
                                is_null: {
                                    key: string;
                                };
                            } | {
                                has_id: (string | number)[];
                            } | {
                                nested: {
                                    key: string;
                                    filter: any;
                                };
                            })[] | null | undefined;
                        } | null | undefined;
                        params?: Record<string, unknown> | {
                            hnsw_ef?: number | null | undefined;
                            exact?: boolean | undefined;
                            quantization?: Record<string, unknown> | {
                                ignore?: boolean | undefined;
                                rescore?: boolean | null | undefined;
                                oversampling?: number | null | undefined;
                            } | null | undefined;
                            indexed_only?: boolean | undefined;
                        } | null | undefined;
                        limit: number;
                        offset?: number | null | undefined;
                        with_payload?: boolean | Record<string, unknown> | string[] | {
                            include: string[];
                        } | {
                            exclude: string[];
                        } | null | undefined;
                        with_vector?: boolean | Record<string, unknown> | string[] | null | undefined;
                        score_threshold?: number | null | undefined;
                        using?: string | Record<string, unknown> | null | undefined;
                        lookup_from?: Record<string, unknown> | {
                            collection: string;
                            vector?: string | null | undefined;
                            shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        } | null | undefined;
                    }[];
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            id: string | number;
                            version: number;
                            score: number;
                            payload?: Record<string, unknown> | {
                                [key: string]: unknown;
                            } | null | undefined;
                            vector?: Record<string, unknown> | number[] | {
                                [key: string]: number[] | {
                                    indices: number[];
                                    values: number[];
                                } | undefined;
                            } | null | undefined;
                            shard_key?: string | number | Record<string, unknown> | null | undefined;
                        }[][] | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Look for the points which are closer to stored positive examples and at the same time further to negative examples.
     */
    readonly recommendPoints: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                consistency?: number | "majority" | "quorum" | "all" | undefined;
                timeout?: number | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                    positive?: (string | number | number[] | {
                        indices: number[];
                        values: number[];
                    })[] | undefined;
                    negative?: (string | number | number[] | {
                        indices: number[];
                        values: number[];
                    })[] | undefined;
                    strategy?: Record<string, unknown> | "average_vector" | "best_score" | null | undefined;
                    filter?: Record<string, unknown> | {
                        should?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must_not?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                    } | null | undefined;
                    params?: Record<string, unknown> | {
                        hnsw_ef?: number | null | undefined;
                        exact?: boolean | undefined;
                        quantization?: Record<string, unknown> | {
                            ignore?: boolean | undefined;
                            rescore?: boolean | null | undefined;
                            oversampling?: number | null | undefined;
                        } | null | undefined;
                        indexed_only?: boolean | undefined;
                    } | null | undefined;
                    limit: number;
                    offset?: number | null | undefined;
                    with_payload?: boolean | Record<string, unknown> | string[] | {
                        include: string[];
                    } | {
                        exclude: string[];
                    } | null | undefined;
                    with_vector?: boolean | Record<string, unknown> | string[] | null | undefined;
                    score_threshold?: number | null | undefined;
                    using?: string | Record<string, unknown> | null | undefined;
                    lookup_from?: Record<string, unknown> | {
                        collection: string;
                        vector?: string | null | undefined;
                        shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                    } | null | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            id: string | number;
                            version: number;
                            score: number;
                            payload?: Record<string, unknown> | {
                                [key: string]: unknown;
                            } | null | undefined;
                            vector?: Record<string, unknown> | number[] | {
                                [key: string]: number[] | {
                                    indices: number[];
                                    values: number[];
                                } | undefined;
                            } | null | undefined;
                            shard_key?: string | number | Record<string, unknown> | null | undefined;
                        }[] | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Search point groups
     */
    readonly searchPointGroups: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                consistency?: number | "majority" | "quorum" | "all" | undefined;
                timeout?: number | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                    vector: number[] | {
                        name: string;
                        vector: number[];
                    } | {
                        name: string;
                        vector: {
                            indices: number[];
                            values: number[];
                        };
                    };
                    filter?: Record<string, unknown> | {
                        should?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must_not?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                    } | null | undefined;
                    params?: Record<string, unknown> | {
                        hnsw_ef?: number | null | undefined;
                        exact?: boolean | undefined;
                        quantization?: Record<string, unknown> | {
                            ignore?: boolean | undefined;
                            rescore?: boolean | null | undefined;
                            oversampling?: number | null | undefined;
                        } | null | undefined;
                        indexed_only?: boolean | undefined;
                    } | null | undefined;
                    with_payload?: boolean | Record<string, unknown> | string[] | {
                        include: string[];
                    } | {
                        exclude: string[];
                    } | null | undefined;
                    with_vector?: boolean | Record<string, unknown> | string[] | null | undefined;
                    score_threshold?: number | null | undefined;
                    group_by: string;
                    group_size: number;
                    limit: number;
                    with_lookup?: string | Record<string, unknown> | {
                        collection: string;
                        with_payload?: boolean | Record<string, unknown> | string[] | {
                            include: string[];
                        } | {
                            exclude: string[];
                        } | null | undefined;
                        with_vectors?: boolean | Record<string, unknown> | string[] | null | undefined;
                    } | null | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            groups: {
                                hits: {
                                    id: string | number;
                                    version: number;
                                    score: number;
                                    payload?: Record<string, unknown> | {
                                        [key: string]: unknown;
                                    } | null | undefined;
                                    vector?: Record<string, unknown> | number[] | {
                                        [key: string]: number[] | {
                                            indices: number[];
                                            values: number[];
                                        } | undefined;
                                    } | null | undefined;
                                    shard_key?: string | number | Record<string, unknown> | null | undefined;
                                }[];
                                id: string | number;
                                lookup?: Record<string, unknown> | {
                                    id: string | number;
                                    payload?: Record<string, unknown> | {
                                        [key: string]: unknown;
                                    } | null | undefined;
                                    vector?: Record<string, unknown> | number[] | {
                                        [key: string]: number[] | {
                                            indices: number[];
                                            values: number[];
                                        } | undefined;
                                    } | null | undefined;
                                    shard_key?: string | number | Record<string, unknown> | null | undefined;
                                } | null | undefined;
                            }[];
                        } | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Scroll request - paginate over all points which matches given filtering condition
     */
    readonly scrollPoints: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                consistency?: number | "majority" | "quorum" | "all" | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                    offset?: string | number | Record<string, unknown> | null | undefined;
                    limit?: number | null | undefined;
                    filter?: Record<string, unknown> | {
                        should?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must_not?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                    } | null | undefined;
                    with_payload?: boolean | Record<string, unknown> | string[] | {
                        include: string[];
                    } | {
                        exclude: string[];
                    } | null | undefined;
                    with_vector?: boolean | string[] | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            points: {
                                id: string | number;
                                payload?: Record<string, unknown> | {
                                    [key: string]: unknown;
                                } | null | undefined;
                                vector?: Record<string, unknown> | number[] | {
                                    [key: string]: number[] | {
                                        indices: number[];
                                        values: number[];
                                    } | undefined;
                                } | null | undefined;
                                shard_key?: string | number | Record<string, unknown> | null | undefined;
                            }[];
                            next_page_offset?: string | number | Record<string, unknown> | null | undefined;
                        } | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Retrieve by batch the closest points based on vector similarity and given filtering conditions
     */
    readonly searchBatchPoints: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                consistency?: number | "majority" | "quorum" | "all" | undefined;
                timeout?: number | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    searches: {
                        shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        vector: number[] | {
                            name: string;
                            vector: number[];
                        } | {
                            name: string;
                            vector: {
                                indices: number[];
                                values: number[];
                            };
                        };
                        filter?: Record<string, unknown> | {
                            should?: (any | {
                                key: string;
                                match?: Record<string, unknown> | {
                                    value: string | number | boolean;
                                } | {
                                    text: string;
                                } | {
                                    any: string[] | number[];
                                } | {
                                    except: string[] | number[];
                                } | null | undefined;
                                range?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                                geo_bounding_box?: Record<string, unknown> | {
                                    top_left: {
                                        lon: number;
                                        lat: number;
                                    };
                                    bottom_right: {
                                        lon: number;
                                        lat: number;
                                    };
                                } | null | undefined;
                                geo_radius?: Record<string, unknown> | {
                                    center: {
                                        lon: number;
                                        lat: number;
                                    };
                                    radius: number;
                                } | null | undefined;
                                geo_polygon?: Record<string, unknown> | {
                                    exterior: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    };
                                    interiors?: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    }[] | null | undefined;
                                } | null | undefined;
                                values_count?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                            } | {
                                is_empty: {
                                    key: string;
                                };
                            } | {
                                is_null: {
                                    key: string;
                                };
                            } | {
                                has_id: (string | number)[];
                            } | {
                                nested: {
                                    key: string;
                                    filter: any;
                                };
                            })[] | null | undefined;
                            must?: (any | {
                                key: string;
                                match?: Record<string, unknown> | {
                                    value: string | number | boolean;
                                } | {
                                    text: string;
                                } | {
                                    any: string[] | number[];
                                } | {
                                    except: string[] | number[];
                                } | null | undefined;
                                range?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                                geo_bounding_box?: Record<string, unknown> | {
                                    top_left: {
                                        lon: number;
                                        lat: number;
                                    };
                                    bottom_right: {
                                        lon: number;
                                        lat: number;
                                    };
                                } | null | undefined;
                                geo_radius?: Record<string, unknown> | {
                                    center: {
                                        lon: number;
                                        lat: number;
                                    };
                                    radius: number;
                                } | null | undefined;
                                geo_polygon?: Record<string, unknown> | {
                                    exterior: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    };
                                    interiors?: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    }[] | null | undefined;
                                } | null | undefined;
                                values_count?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                            } | {
                                is_empty: {
                                    key: string;
                                };
                            } | {
                                is_null: {
                                    key: string;
                                };
                            } | {
                                has_id: (string | number)[];
                            } | {
                                nested: {
                                    key: string;
                                    filter: any;
                                };
                            })[] | null | undefined;
                            must_not?: (any | {
                                key: string;
                                match?: Record<string, unknown> | {
                                    value: string | number | boolean;
                                } | {
                                    text: string;
                                } | {
                                    any: string[] | number[];
                                } | {
                                    except: string[] | number[];
                                } | null | undefined;
                                range?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                                geo_bounding_box?: Record<string, unknown> | {
                                    top_left: {
                                        lon: number;
                                        lat: number;
                                    };
                                    bottom_right: {
                                        lon: number;
                                        lat: number;
                                    };
                                } | null | undefined;
                                geo_radius?: Record<string, unknown> | {
                                    center: {
                                        lon: number;
                                        lat: number;
                                    };
                                    radius: number;
                                } | null | undefined;
                                geo_polygon?: Record<string, unknown> | {
                                    exterior: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    };
                                    interiors?: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    }[] | null | undefined;
                                } | null | undefined;
                                values_count?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                            } | {
                                is_empty: {
                                    key: string;
                                };
                            } | {
                                is_null: {
                                    key: string;
                                };
                            } | {
                                has_id: (string | number)[];
                            } | {
                                nested: {
                                    key: string;
                                    filter: any;
                                };
                            })[] | null | undefined;
                        } | null | undefined;
                        params?: Record<string, unknown> | {
                            hnsw_ef?: number | null | undefined;
                            exact?: boolean | undefined;
                            quantization?: Record<string, unknown> | {
                                ignore?: boolean | undefined;
                                rescore?: boolean | null | undefined;
                                oversampling?: number | null | undefined;
                            } | null | undefined;
                            indexed_only?: boolean | undefined;
                        } | null | undefined;
                        limit: number;
                        offset?: number | null | undefined;
                        with_payload?: boolean | Record<string, unknown> | string[] | {
                            include: string[];
                        } | {
                            exclude: string[];
                        } | null | undefined;
                        with_vector?: boolean | Record<string, unknown> | string[] | null | undefined;
                        score_threshold?: number | null | undefined;
                    }[];
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            id: string | number;
                            version: number;
                            score: number;
                            payload?: Record<string, unknown> | {
                                [key: string]: unknown;
                            } | null | undefined;
                            vector?: Record<string, unknown> | number[] | {
                                [key: string]: number[] | {
                                    indices: number[];
                                    values: number[];
                                } | undefined;
                            } | null | undefined;
                            shard_key?: string | number | Record<string, unknown> | null | undefined;
                        }[][] | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Retrieve closest points based on vector similarity and given filtering conditions
     */
    readonly searchPoints: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                consistency?: number | "majority" | "quorum" | "all" | undefined;
                timeout?: number | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                    vector: number[] | {
                        name: string;
                        vector: number[];
                    } | {
                        name: string;
                        vector: {
                            indices: number[];
                            values: number[];
                        };
                    };
                    filter?: Record<string, unknown> | {
                        should?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must_not?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                    } | null | undefined;
                    params?: Record<string, unknown> | {
                        hnsw_ef?: number | null | undefined;
                        exact?: boolean | undefined;
                        quantization?: Record<string, unknown> | {
                            ignore?: boolean | undefined;
                            rescore?: boolean | null | undefined;
                            oversampling?: number | null | undefined;
                        } | null | undefined;
                        indexed_only?: boolean | undefined;
                    } | null | undefined;
                    limit: number;
                    offset?: number | null | undefined;
                    with_payload?: boolean | Record<string, unknown> | string[] | {
                        include: string[];
                    } | {
                        exclude: string[];
                    } | null | undefined;
                    with_vector?: boolean | Record<string, unknown> | string[] | null | undefined;
                    score_threshold?: number | null | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            id: string | number;
                            version: number;
                            score: number;
                            payload?: Record<string, unknown> | {
                                [key: string]: unknown;
                            } | null | undefined;
                            vector?: Record<string, unknown> | number[] | {
                                [key: string]: number[] | {
                                    indices: number[];
                                    values: number[];
                                } | undefined;
                            } | null | undefined;
                            shard_key?: string | number | Record<string, unknown> | null | undefined;
                        }[] | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Set payload values for points
     */
    readonly setPayload: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                wait?: boolean | undefined;
                ordering?: "weak" | "medium" | "strong" | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    payload: {
                        [key: string]: unknown;
                    };
                    points?: (string | number)[] | null | undefined;
                    filter?: Record<string, unknown> | {
                        should?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must_not?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                    } | null | undefined;
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            operation_id?: number | null | undefined;
                            status: "acknowledged" | "completed";
                        } | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Perform insert + updates on points. If point with given ID already exists - it will be overwritten.
     */
    readonly upsertPoints: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                wait?: boolean | undefined;
                ordering?: "weak" | "medium" | "strong" | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    batch: {
                        ids: (string | number)[];
                        vectors: number[][] | {
                            [key: string]: (number[] | {
                                indices: number[];
                                values: number[];
                            })[] | undefined;
                        };
                        payloads?: (Record<string, unknown> | {
                            [key: string]: unknown;
                        } | null)[] | null | undefined;
                    };
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                } | {
                    points: {
                        id: string | number;
                        vector: number[] | {
                            [key: string]: number[] | {
                                indices: number[];
                                values: number[];
                            } | undefined;
                        };
                        payload?: Record<string, unknown> | {
                            [key: string]: unknown;
                        } | null | undefined;
                    }[];
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            operation_id?: number | null | undefined;
                            status: "acknowledged" | "completed";
                        } | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Recommend point groups
     */
    readonly recommendPointGroups: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                consistency?: number | "majority" | "quorum" | "all" | undefined;
                timeout?: number | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                    positive?: (string | number | number[] | {
                        indices: number[];
                        values: number[];
                    })[] | undefined;
                    negative?: (string | number | number[] | {
                        indices: number[];
                        values: number[];
                    })[] | undefined;
                    strategy?: Record<string, unknown> | "average_vector" | "best_score" | null | undefined;
                    filter?: Record<string, unknown> | {
                        should?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must_not?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                    } | null | undefined;
                    params?: Record<string, unknown> | {
                        hnsw_ef?: number | null | undefined;
                        exact?: boolean | undefined;
                        quantization?: Record<string, unknown> | {
                            ignore?: boolean | undefined;
                            rescore?: boolean | null | undefined;
                            oversampling?: number | null | undefined;
                        } | null | undefined;
                        indexed_only?: boolean | undefined;
                    } | null | undefined;
                    with_payload?: boolean | Record<string, unknown> | string[] | {
                        include: string[];
                    } | {
                        exclude: string[];
                    } | null | undefined;
                    with_vector?: boolean | Record<string, unknown> | string[] | null | undefined;
                    score_threshold?: number | null | undefined;
                    using?: string | Record<string, unknown> | null | undefined;
                    lookup_from?: Record<string, unknown> | {
                        collection: string;
                        vector?: string | null | undefined;
                        shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                    } | null | undefined;
                    group_by: string;
                    group_size: number;
                    limit: number;
                    with_lookup?: string | Record<string, unknown> | {
                        collection: string;
                        with_payload?: boolean | Record<string, unknown> | string[] | {
                            include: string[];
                        } | {
                            exclude: string[];
                        } | null | undefined;
                        with_vectors?: boolean | Record<string, unknown> | string[] | null | undefined;
                    } | null | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            groups: {
                                hits: {
                                    id: string | number;
                                    version: number;
                                    score: number;
                                    payload?: Record<string, unknown> | {
                                        [key: string]: unknown;
                                    } | null | undefined;
                                    vector?: Record<string, unknown> | number[] | {
                                        [key: string]: number[] | {
                                            indices: number[];
                                            values: number[];
                                        } | undefined;
                                    } | null | undefined;
                                    shard_key?: string | number | Record<string, unknown> | null | undefined;
                                }[];
                                id: string | number;
                                lookup?: Record<string, unknown> | {
                                    id: string | number;
                                    payload?: Record<string, unknown> | {
                                        [key: string]: unknown;
                                    } | null | undefined;
                                    vector?: Record<string, unknown> | number[] | {
                                        [key: string]: number[] | {
                                            indices: number[];
                                            values: number[];
                                        } | undefined;
                                    } | null | undefined;
                                    shard_key?: string | number | Record<string, unknown> | null | undefined;
                                } | null | undefined;
                            }[];
                        } | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Apply a series of update operations for points, vectors and payloads
     */
    readonly batchUpdate: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                wait?: boolean | undefined;
                ordering?: "weak" | "medium" | "strong" | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    operations: ({
                        upsert: {
                            batch: {
                                ids: (string | number)[];
                                vectors: number[][] | {
                                    [key: string]: (number[] | {
                                        indices: number[];
                                        values: number[];
                                    })[] | undefined;
                                };
                                payloads?: (Record<string, unknown> | {
                                    [key: string]: unknown;
                                } | null)[] | null | undefined;
                            };
                            shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        } | {
                            points: {
                                id: string | number;
                                vector: number[] | {
                                    [key: string]: number[] | {
                                        indices: number[];
                                        values: number[];
                                    } | undefined;
                                };
                                payload?: Record<string, unknown> | {
                                    [key: string]: unknown;
                                } | null | undefined;
                            }[];
                            shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        };
                    } | {
                        delete: {
                            points: (string | number)[];
                            shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        } | {
                            filter: {
                                should?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                                must?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                                must_not?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                            };
                            shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        };
                    } | {
                        set_payload: {
                            payload: {
                                [key: string]: unknown;
                            };
                            points?: (string | number)[] | null | undefined;
                            filter?: Record<string, unknown> | {
                                should?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                                must?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                                must_not?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                            } | null | undefined;
                            shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        };
                    } | {
                        overwrite_payload: {
                            payload: {
                                [key: string]: unknown;
                            };
                            points?: (string | number)[] | null | undefined;
                            filter?: Record<string, unknown> | {
                                should?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                                must?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                                must_not?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                            } | null | undefined;
                            shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        };
                    } | {
                        delete_payload: {
                            keys: string[];
                            points?: (string | number)[] | null | undefined;
                            filter?: Record<string, unknown> | {
                                should?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                                must?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                                must_not?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                            } | null | undefined;
                            shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        };
                    } | {
                        clear_payload: {
                            points: (string | number)[];
                            shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        } | {
                            filter: {
                                should?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                                must?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                                must_not?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                            };
                            shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        };
                    } | {
                        update_vectors: {
                            points: {
                                id: string | number;
                                vector: number[] | {
                                    [key: string]: number[] | {
                                        indices: number[];
                                        values: number[];
                                    } | undefined;
                                };
                            }[];
                            shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        };
                    } | {
                        delete_vectors: {
                            points?: (string | number)[] | null | undefined;
                            filter?: Record<string, unknown> | {
                                should?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                                must?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                                must_not?: (any | {
                                    key: string;
                                    match?: Record<string, unknown> | {
                                        value: string | number | boolean;
                                    } | {
                                        text: string;
                                    } | {
                                        any: string[] | number[];
                                    } | {
                                        except: string[] | number[];
                                    } | null | undefined;
                                    range?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                    geo_bounding_box?: Record<string, unknown> | {
                                        top_left: {
                                            lon: number;
                                            lat: number;
                                        };
                                        bottom_right: {
                                            lon: number;
                                            lat: number;
                                        };
                                    } | null | undefined;
                                    geo_radius?: Record<string, unknown> | {
                                        center: {
                                            lon: number;
                                            lat: number;
                                        };
                                        radius: number;
                                    } | null | undefined;
                                    geo_polygon?: Record<string, unknown> | {
                                        exterior: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        };
                                        interiors?: {
                                            points: {
                                                lon: number;
                                                lat: number;
                                            }[];
                                        }[] | null | undefined;
                                    } | null | undefined;
                                    values_count?: Record<string, unknown> | {
                                        lt?: number | null | undefined;
                                        gt?: number | null | undefined;
                                        gte?: number | null | undefined;
                                        lte?: number | null | undefined;
                                    } | null | undefined;
                                } | {
                                    is_empty: {
                                        key: string;
                                    };
                                } | {
                                    is_null: {
                                        key: string;
                                    };
                                } | {
                                    has_id: (string | number)[];
                                } | {
                                    nested: {
                                        key: string;
                                        filter: any;
                                    };
                                })[] | null | undefined;
                            } | null | undefined;
                            vector: string[];
                            shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        };
                    })[];
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            operation_id?: number | null | undefined;
                            status: "acknowledged" | "completed";
                        }[] | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Discover points
     */
    readonly discoverPoints: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                consistency?: number | "majority" | "quorum" | "all" | undefined;
                timeout?: number | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                    target?: string | number | Record<string, unknown> | number[] | {
                        indices: number[];
                        values: number[];
                    } | null | undefined;
                    context?: {
                        positive: string | number | number[] | {
                            indices: number[];
                            values: number[];
                        };
                        negative: string | number | number[] | {
                            indices: number[];
                            values: number[];
                        };
                    }[] | null | undefined;
                    filter?: Record<string, unknown> | {
                        should?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                        must_not?: (any | {
                            key: string;
                            match?: Record<string, unknown> | {
                                value: string | number | boolean;
                            } | {
                                text: string;
                            } | {
                                any: string[] | number[];
                            } | {
                                except: string[] | number[];
                            } | null | undefined;
                            range?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                            geo_bounding_box?: Record<string, unknown> | {
                                top_left: {
                                    lon: number;
                                    lat: number;
                                };
                                bottom_right: {
                                    lon: number;
                                    lat: number;
                                };
                            } | null | undefined;
                            geo_radius?: Record<string, unknown> | {
                                center: {
                                    lon: number;
                                    lat: number;
                                };
                                radius: number;
                            } | null | undefined;
                            geo_polygon?: Record<string, unknown> | {
                                exterior: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                };
                                interiors?: {
                                    points: {
                                        lon: number;
                                        lat: number;
                                    }[];
                                }[] | null | undefined;
                            } | null | undefined;
                            values_count?: Record<string, unknown> | {
                                lt?: number | null | undefined;
                                gt?: number | null | undefined;
                                gte?: number | null | undefined;
                                lte?: number | null | undefined;
                            } | null | undefined;
                        } | {
                            is_empty: {
                                key: string;
                            };
                        } | {
                            is_null: {
                                key: string;
                            };
                        } | {
                            has_id: (string | number)[];
                        } | {
                            nested: {
                                key: string;
                                filter: any;
                            };
                        })[] | null | undefined;
                    } | null | undefined;
                    params?: Record<string, unknown> | {
                        hnsw_ef?: number | null | undefined;
                        exact?: boolean | undefined;
                        quantization?: Record<string, unknown> | {
                            ignore?: boolean | undefined;
                            rescore?: boolean | null | undefined;
                            oversampling?: number | null | undefined;
                        } | null | undefined;
                        indexed_only?: boolean | undefined;
                    } | null | undefined;
                    limit: number;
                    offset?: number | null | undefined;
                    with_payload?: boolean | Record<string, unknown> | string[] | {
                        include: string[];
                    } | {
                        exclude: string[];
                    } | null | undefined;
                    with_vector?: boolean | Record<string, unknown> | string[] | null | undefined;
                    using?: string | Record<string, unknown> | null | undefined;
                    lookup_from?: Record<string, unknown> | {
                        collection: string;
                        vector?: string | null | undefined;
                        shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                    } | null | undefined;
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            id: string | number;
                            version: number;
                            score: number;
                            payload?: Record<string, unknown> | {
                                [key: string]: unknown;
                            } | null | undefined;
                            vector?: Record<string, unknown> | number[] | {
                                [key: string]: number[] | {
                                    indices: number[];
                                    values: number[];
                                } | undefined;
                            } | null | undefined;
                            shard_key?: string | number | Record<string, unknown> | null | undefined;
                        }[] | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
    /**
     * Discover batch points
     */
    readonly discoverBatchPoints: import("@qdrant/openapi-typescript-fetch").TypedFetch<{
        parameters: {
            query?: {
                consistency?: number | "majority" | "quorum" | "all" | undefined;
                timeout?: number | undefined;
            } | undefined;
            path: {
                collection_name: string;
            };
        };
        requestBody?: {
            content: {
                "application/json": {
                    searches: {
                        shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        target?: string | number | Record<string, unknown> | number[] | {
                            indices: number[];
                            values: number[];
                        } | null | undefined;
                        context?: {
                            positive: string | number | number[] | {
                                indices: number[];
                                values: number[];
                            };
                            negative: string | number | number[] | {
                                indices: number[];
                                values: number[];
                            };
                        }[] | null | undefined;
                        filter?: Record<string, unknown> | {
                            should?: (any | {
                                key: string;
                                match?: Record<string, unknown> | {
                                    value: string | number | boolean;
                                } | {
                                    text: string;
                                } | {
                                    any: string[] | number[];
                                } | {
                                    except: string[] | number[];
                                } | null | undefined;
                                range?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                                geo_bounding_box?: Record<string, unknown> | {
                                    top_left: {
                                        lon: number;
                                        lat: number;
                                    };
                                    bottom_right: {
                                        lon: number;
                                        lat: number;
                                    };
                                } | null | undefined;
                                geo_radius?: Record<string, unknown> | {
                                    center: {
                                        lon: number;
                                        lat: number;
                                    };
                                    radius: number;
                                } | null | undefined;
                                geo_polygon?: Record<string, unknown> | {
                                    exterior: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    };
                                    interiors?: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    }[] | null | undefined;
                                } | null | undefined;
                                values_count?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                            } | {
                                is_empty: {
                                    key: string;
                                };
                            } | {
                                is_null: {
                                    key: string;
                                };
                            } | {
                                has_id: (string | number)[];
                            } | {
                                nested: {
                                    key: string;
                                    filter: any;
                                };
                            })[] | null | undefined;
                            must?: (any | {
                                key: string;
                                match?: Record<string, unknown> | {
                                    value: string | number | boolean;
                                } | {
                                    text: string;
                                } | {
                                    any: string[] | number[];
                                } | {
                                    except: string[] | number[];
                                } | null | undefined;
                                range?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                                geo_bounding_box?: Record<string, unknown> | {
                                    top_left: {
                                        lon: number;
                                        lat: number;
                                    };
                                    bottom_right: {
                                        lon: number;
                                        lat: number;
                                    };
                                } | null | undefined;
                                geo_radius?: Record<string, unknown> | {
                                    center: {
                                        lon: number;
                                        lat: number;
                                    };
                                    radius: number;
                                } | null | undefined;
                                geo_polygon?: Record<string, unknown> | {
                                    exterior: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    };
                                    interiors?: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    }[] | null | undefined;
                                } | null | undefined;
                                values_count?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                            } | {
                                is_empty: {
                                    key: string;
                                };
                            } | {
                                is_null: {
                                    key: string;
                                };
                            } | {
                                has_id: (string | number)[];
                            } | {
                                nested: {
                                    key: string;
                                    filter: any;
                                };
                            })[] | null | undefined;
                            must_not?: (any | {
                                key: string;
                                match?: Record<string, unknown> | {
                                    value: string | number | boolean;
                                } | {
                                    text: string;
                                } | {
                                    any: string[] | number[];
                                } | {
                                    except: string[] | number[];
                                } | null | undefined;
                                range?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                                geo_bounding_box?: Record<string, unknown> | {
                                    top_left: {
                                        lon: number;
                                        lat: number;
                                    };
                                    bottom_right: {
                                        lon: number;
                                        lat: number;
                                    };
                                } | null | undefined;
                                geo_radius?: Record<string, unknown> | {
                                    center: {
                                        lon: number;
                                        lat: number;
                                    };
                                    radius: number;
                                } | null | undefined;
                                geo_polygon?: Record<string, unknown> | {
                                    exterior: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    };
                                    interiors?: {
                                        points: {
                                            lon: number;
                                            lat: number;
                                        }[];
                                    }[] | null | undefined;
                                } | null | undefined;
                                values_count?: Record<string, unknown> | {
                                    lt?: number | null | undefined;
                                    gt?: number | null | undefined;
                                    gte?: number | null | undefined;
                                    lte?: number | null | undefined;
                                } | null | undefined;
                            } | {
                                is_empty: {
                                    key: string;
                                };
                            } | {
                                is_null: {
                                    key: string;
                                };
                            } | {
                                has_id: (string | number)[];
                            } | {
                                nested: {
                                    key: string;
                                    filter: any;
                                };
                            })[] | null | undefined;
                        } | null | undefined;
                        params?: Record<string, unknown> | {
                            hnsw_ef?: number | null | undefined;
                            exact?: boolean | undefined;
                            quantization?: Record<string, unknown> | {
                                ignore?: boolean | undefined;
                                rescore?: boolean | null | undefined;
                                oversampling?: number | null | undefined;
                            } | null | undefined;
                            indexed_only?: boolean | undefined;
                        } | null | undefined;
                        limit: number;
                        offset?: number | null | undefined;
                        with_payload?: boolean | Record<string, unknown> | string[] | {
                            include: string[];
                        } | {
                            exclude: string[];
                        } | null | undefined;
                        with_vector?: boolean | Record<string, unknown> | string[] | null | undefined;
                        using?: string | Record<string, unknown> | null | undefined;
                        lookup_from?: Record<string, unknown> | {
                            collection: string;
                            vector?: string | null | undefined;
                            shard_key?: string | number | Record<string, unknown> | (string | number)[] | null | undefined;
                        } | null | undefined;
                    }[];
                };
            };
        } | undefined;
        responses: {
            200: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: string | undefined;
                        result?: {
                            id: string | number;
                            version: number;
                            score: number;
                            payload?: Record<string, unknown> | {
                                [key: string]: unknown;
                            } | null | undefined;
                            vector?: Record<string, unknown> | number[] | {
                                [key: string]: number[] | {
                                    indices: number[];
                                    values: number[];
                                } | undefined;
                            } | null | undefined;
                            shard_key?: string | number | Record<string, unknown> | null | undefined;
                        }[][] | undefined;
                    };
                };
            };
            default: {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
            "4XX": {
                content: {
                    "application/json": {
                        time?: number | undefined;
                        status?: {
                            error?: string | undefined;
                        } | undefined;
                        result?: Record<string, unknown> | null | undefined;
                    };
                };
            };
        };
    }>;
};
