Class QdrantTranslator<T>

A class that translates or converts StructuredQuery to equivalent Qdrant filters.

Example

const selfQueryRetriever = new SelfQueryRetriever({
  llm: new ChatOpenAI({ model: "gpt-4o-mini" }),
  vectorStore: new QdrantVectorStore(...),
  documentContents: "Brief summary of a movie",
  attributeInfo: [],
  structuredQueryTranslator: new QdrantTranslator(),
});

const relevantDocuments = await selfQueryRetriever.getRelevantDocuments(
  "Which movies are rated higher than 8.5?",
);

Type Parameters

T extends QdrantVectorStore

Hierarchy (view full)

BaseTranslator<T>
- QdrantTranslator

Index

Constructors

constructor

new QdrantTranslator<T>(): QdrantTranslator<T>
Type Parameters
- T extends QdrantVectorStore
Returns QdrantTranslator<T>
Inherited from BaseTranslator.constructor

Properties

VisitComparisonOutput

VisitComparisonOutput: {
    geo_bounding_box?: null | Record<string, unknown> | {
        bottom_right: {
            lat: number;
            lon: number;
        };
        top_left: {
            lat: number;
            lon: number;
        };
    };
    geo_polygon?: null | Record<string, unknown> | {
        exterior: {
            points: {
                lat: number;
                lon: number;
            }[];
        };
        interiors?: null | {
            points: {
                lat: number;
                lon: number;
            }[];
        }[];
    };
    geo_radius?: null | Record<string, unknown> | {
        center: {
            lat: number;
            lon: number;
        };
        radius: number;
    };
    is_empty?: null | boolean;
    is_null?: null | boolean;
    key: string;
    match?:
        | null
        | Record<string, unknown>
        | {
            value: string | number | boolean;
        }
        | {
            text: string;
        }
        | {
            phrase: string;
        }
        | {
            any: string[] | number[];
        }
        | {
            except: string[] | number[];
        };
    range?:
        | null
        | Record<string, unknown>
        | {
            gt?: null | number;
            gte?: null | number;
            lt?: null | number;
            lte?: null | number;
        }
        | {
            gt?: null | string;
            gte?: null | string;
            lt?: null | string;
            lte?: null | string;
        };
    values_count?: null | Record<string, unknown> | {
        gt?: null | number;
        gte?: null | number;
        lt?: null | number;
        lte?: null | number;
    };
}

Type declaration

Optionalgeo_bounding_box?: null | Record<string, unknown> | {
    bottom_right: {
        lat: number;
        lon: number;
    };
    top_left: {
        lat: number;
        lon: number;
    };
}
Description
Check if points geolocation lies in a given area
Optionalgeo_polygon?: null | Record<string, unknown> | {
    exterior: {
        points: {
            lat: number;
            lon: number;
        }[];
    };
    interiors?: null | {
        points: {
            lat: number;
            lon: number;
        }[];
    }[];
}
Description
Check if geo point is within a given polygon
Optionalgeo_radius?: null | Record<string, unknown> | {
    center: {
        lat: number;
        lon: number;
    };
    radius: number;
}
Description
Check if geo point is within a given radius
Optionalis_empty?: null | boolean
Description
Check that the field is empty, alternative syntax for is_empty: "field_name"
Optionalis_null?: null | boolean
Description
Check that the field is null, alternative syntax for is_null: "field_name"
key: string
Description
Payload key
Optionalmatch?:
    | null
    | Record<string, unknown>
    | {
        value: string | number | boolean;
    }
    | {
        text: string;
    }
    | {
        phrase: string;
    }
    | {
        any: string[] | number[];
    }
    | {
        except: string[] | number[];
    }
Description
Check if point has field with a given value
Optionalrange?:
    | null
    | Record<string, unknown>
    | {
        gt?: null | number;
        gte?: null | number;
        lt?: null | number;
        lte?: null | number;
    }
    | {
        gt?: null | string;
        gte?: null | string;
        lt?: null | string;
        lte?: null | string;
    }
Description
Check if points value lies in a given range
Optionalvalues_count?: null | Record<string, unknown> | {
    gt?: null | number;
    gte?: null | number;
    lt?: null | number;
    lte?: null | number;
}
Description
Check number of values of the field

VisitOperationOutput

VisitOperationOutput: {
    min_should?: null | Record<string, unknown> | {
        conditions: (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: ...;
                            lon: ...;
                        }[];
                    };
                    interiors?: null | {
                        points: ...;
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
        min_count: number;
    };
    must?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: number;
                            lon: number;
                        }[];
                    };
                    interiors?: null | {
                        points: (...)[];
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
    must_not?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: number;
                            lon: number;
                        }[];
                    };
                    interiors?: null | {
                        points: (...)[];
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
    should?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: number;
                            lon: number;
                        }[];
                    };
                    interiors?: null | {
                        points: (...)[];
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
}

Type declaration

Optionalmin_should?: null | Record<string, unknown> | {
    conditions: (
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: ...;
                        lon: ...;
                    }[];
                };
                interiors?: null | {
                    points: ...;
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        })[];
    min_count: number;
}
Description
At least minimum amount of given conditions should match
Optionalmust?:
    | null
    | Record<string, unknown>
    | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
    | {
        geo_bounding_box?: null | Record<string, unknown> | {
            bottom_right: {
                lat: number;
                lon: number;
            };
            top_left: {
                lat: number;
                lon: number;
            };
        };
        geo_polygon?: null | Record<string, unknown> | {
            exterior: {
                points: {
                    lat: number;
                    lon: number;
                }[];
            };
            interiors?: null | {
                points: {
                    lat: number;
                    lon: number;
                }[];
            }[];
        };
        geo_radius?: null | Record<string, unknown> | {
            center: {
                lat: number;
                lon: number;
            };
            radius: number;
        };
        is_empty?: null | boolean;
        is_null?: null | boolean;
        key: string;
        match?:
            | null
            | Record<string, unknown>
            | {
                value: string | number | boolean;
            }
            | {
                text: string;
            }
            | {
                phrase: string;
            }
            | {
                any: string[] | number[];
            }
            | {
                except: string[] | number[];
            };
        range?:
            | null
            | Record<string, unknown>
            | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            }
            | {
                gt?: null | string;
                gte?: null | string;
                lt?: null | string;
                lte?: null | string;
            };
        values_count?: null | Record<string, unknown> | {
            gt?: null | number;
            gte?: null | number;
            lt?: null | number;
            lte?: null | number;
        };
    }
    | {
        is_empty: {
            key: string;
        };
    }
    | {
        is_null: {
            key: string;
        };
    }
    | {
        has_id: (string | number)[];
    }
    | {
        has_vector: string;
    }
    | {
        nested: {
            filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
            key: string;
        };
    }
    | (
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: (...)[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        })[]
Description
All conditions must match

Default
```
null
```
Optionalmust_not?:
    | null
    | Record<string, unknown>
    | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
    | {
        geo_bounding_box?: null | Record<string, unknown> | {
            bottom_right: {
                lat: number;
                lon: number;
            };
            top_left: {
                lat: number;
                lon: number;
            };
        };
        geo_polygon?: null | Record<string, unknown> | {
            exterior: {
                points: {
                    lat: number;
                    lon: number;
                }[];
            };
            interiors?: null | {
                points: {
                    lat: number;
                    lon: number;
                }[];
            }[];
        };
        geo_radius?: null | Record<string, unknown> | {
            center: {
                lat: number;
                lon: number;
            };
            radius: number;
        };
        is_empty?: null | boolean;
        is_null?: null | boolean;
        key: string;
        match?:
            | null
            | Record<string, unknown>
            | {
                value: string | number | boolean;
            }
            | {
                text: string;
            }
            | {
                phrase: string;
            }
            | {
                any: string[] | number[];
            }
            | {
                except: string[] | number[];
            };
        range?:
            | null
            | Record<string, unknown>
            | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            }
            | {
                gt?: null | string;
                gte?: null | string;
                lt?: null | string;
                lte?: null | string;
            };
        values_count?: null | Record<string, unknown> | {
            gt?: null | number;
            gte?: null | number;
            lt?: null | number;
            lte?: null | number;
        };
    }
    | {
        is_empty: {
            key: string;
        };
    }
    | {
        is_null: {
            key: string;
        };
    }
    | {
        has_id: (string | number)[];
    }
    | {
        has_vector: string;
    }
    | {
        nested: {
            filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
            key: string;
        };
    }
    | (
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: (...)[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        })[]
Description
All conditions must NOT match

Default
```
null
```
Optionalshould?:
    | null
    | Record<string, unknown>
    | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
    | {
        geo_bounding_box?: null | Record<string, unknown> | {
            bottom_right: {
                lat: number;
                lon: number;
            };
            top_left: {
                lat: number;
                lon: number;
            };
        };
        geo_polygon?: null | Record<string, unknown> | {
            exterior: {
                points: {
                    lat: number;
                    lon: number;
                }[];
            };
            interiors?: null | {
                points: {
                    lat: number;
                    lon: number;
                }[];
            }[];
        };
        geo_radius?: null | Record<string, unknown> | {
            center: {
                lat: number;
                lon: number;
            };
            radius: number;
        };
        is_empty?: null | boolean;
        is_null?: null | boolean;
        key: string;
        match?:
            | null
            | Record<string, unknown>
            | {
                value: string | number | boolean;
            }
            | {
                text: string;
            }
            | {
                phrase: string;
            }
            | {
                any: string[] | number[];
            }
            | {
                except: string[] | number[];
            };
        range?:
            | null
            | Record<string, unknown>
            | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            }
            | {
                gt?: null | string;
                gte?: null | string;
                lt?: null | string;
                lte?: null | string;
            };
        values_count?: null | Record<string, unknown> | {
            gt?: null | number;
            gte?: null | number;
            lt?: null | number;
            lte?: null | number;
        };
    }
    | {
        is_empty: {
            key: string;
        };
    }
    | {
        is_null: {
            key: string;
        };
    }
    | {
        has_id: (string | number)[];
    }
    | {
        has_vector: string;
    }
    | {
        nested: {
            filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
            key: string;
        };
    }
    | (
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: (...)[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        })[]
Description
At least one of those conditions should match

Default
```
null
```

VisitStructuredQueryOutput

VisitStructuredQueryOutput: {
filter?: T["FilterType"];
}

allowedComparators

allowedComparators: Comparator[] = ...

allowedOperators

allowedOperators: Operator[] = ...

Methods

formatFunction

formatFunction(): string
Formats a given function (either an operator or a comparator) into a string.

Returns string
Formatted string representation of the function.
Overrides BaseTranslator.formatFunction
- Defined in libs/langchain-community/src/structured_query/qdrant.ts:185

mergeFilters

mergeFilters(defaultFilter, generatedFilter, mergeType?, forceDefaultFilter?): undefined | {
    min_should?: null | Record<string, unknown> | {
        conditions: (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: (...)[];
                    };
                    interiors?: null | (...)[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: (...)[] | (...)[];
                    }
                    | {
                        except: (...)[] | (...)[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
        min_count: number;
    };
    must?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: ...;
                        lon: ...;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: ...;
                            lon: ...;
                        }[];
                    };
                    interiors?: null | {
                        points: ...;
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
    must_not?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: ...;
                        lon: ...;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: ...;
                            lon: ...;
                        }[];
                    };
                    interiors?: null | {
                        points: ...;
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
    should?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: ...;
                        lon: ...;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: ...;
                            lon: ...;
                        }[];
                    };
                    interiors?: null | {
                        points: ...;
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
}
Merges two filters into one. If both filters are empty, returns undefined. If one filter is empty or the merge type is 'replace', returns the other filter. If the merge type is 'and' or 'or', returns a new filter with the merged results. Throws an error for unknown merge types.
Parameters
- defaultFilter: undefined | {
      min_should?: null | Record<string, unknown> | {
          conditions: (
              | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
              | {
                  geo_bounding_box?: null | Record<string, unknown> | {
                      bottom_right: {
                          lat: number;
                          lon: number;
                      };
                      top_left: {
                          lat: number;
                          lon: number;
                      };
                  };
                  geo_polygon?: null | Record<string, unknown> | {
                      exterior: {
                          points: (...)[];
                      };
                      interiors?: null | (...)[];
                  };
                  geo_radius?: null | Record<string, unknown> | {
                      center: {
                          lat: number;
                          lon: number;
                      };
                      radius: number;
                  };
                  is_empty?: null | boolean;
                  is_null?: null | boolean;
                  key: string;
                  match?:
                      | null
                      | Record<string, unknown>
                      | {
                          value: string | number | boolean;
                      }
                      | {
                          text: string;
                      }
                      | {
                          phrase: string;
                      }
                      | {
                          any: (...)[] | (...)[];
                      }
                      | {
                          except: (...)[] | (...)[];
                      };
                  range?:
                      | null
                      | Record<string, unknown>
                      | {
                          gt?: null | number;
                          gte?: null | number;
                          lt?: null | number;
                          lte?: null | number;
                      }
                      | {
                          gt?: null | string;
                          gte?: null | string;
                          lt?: null | string;
                          lte?: null | string;
                      };
                  values_count?: null | Record<string, unknown> | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  };
              }
              | {
                  is_empty: {
                      key: string;
                  };
              }
              | {
                  is_null: {
                      key: string;
                  };
              }
              | {
                  has_id: (string | number)[];
              }
              | {
                  has_vector: string;
              }
              | {
                  nested: {
                      filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                      key: string;
                  };
              })[];
          min_count: number;
      };
      must?:
          | null
          | Record<string, unknown>
          | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
          | {
              geo_bounding_box?: null | Record<string, unknown> | {
                  bottom_right: {
                      lat: number;
                      lon: number;
                  };
                  top_left: {
                      lat: number;
                      lon: number;
                  };
              };
              geo_polygon?: null | Record<string, unknown> | {
                  exterior: {
                      points: {
                          lat: number;
                          lon: number;
                      }[];
                  };
                  interiors?: null | {
                      points: {
                          lat: ...;
                          lon: ...;
                      }[];
                  }[];
              };
              geo_radius?: null | Record<string, unknown> | {
                  center: {
                      lat: number;
                      lon: number;
                  };
                  radius: number;
              };
              is_empty?: null | boolean;
              is_null?: null | boolean;
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: string;
                  }
                  | {
                      phrase: string;
                  }
                  | {
                      any: string[] | number[];
                  }
                  | {
                      except: string[] | number[];
                  };
              range?:
                  | null
                  | Record<string, unknown>
                  | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  }
                  | {
                      gt?: null | string;
                      gte?: null | string;
                      lt?: null | string;
                      lte?: null | string;
                  };
              values_count?: null | Record<string, unknown> | {
                  gt?: null | number;
                  gte?: null | number;
                  lt?: null | number;
                  lte?: null | number;
              };
          }
          | {
              is_empty: {
                  key: string;
              };
          }
          | {
              is_null: {
                  key: string;
              };
          }
          | {
              has_id: (string | number)[];
          }
          | {
              has_vector: string;
          }
          | {
              nested: {
                  filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                  key: string;
              };
          }
          | (
              | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
              | {
                  geo_bounding_box?: null | Record<string, unknown> | {
                      bottom_right: {
                          lat: number;
                          lon: number;
                      };
                      top_left: {
                          lat: number;
                          lon: number;
                      };
                  };
                  geo_polygon?: null | Record<string, unknown> | {
                      exterior: {
                          points: {
                              lat: ...;
                              lon: ...;
                          }[];
                      };
                      interiors?: null | {
                          points: ...;
                      }[];
                  };
                  geo_radius?: null | Record<string, unknown> | {
                      center: {
                          lat: number;
                          lon: number;
                      };
                      radius: number;
                  };
                  is_empty?: null | boolean;
                  is_null?: null | boolean;
                  key: string;
                  match?:
                      | null
                      | Record<string, unknown>
                      | {
                          value: string | number | boolean;
                      }
                      | {
                          text: string;
                      }
                      | {
                          phrase: string;
                      }
                      | {
                          any: string[] | number[];
                      }
                      | {
                          except: string[] | number[];
                      };
                  range?:
                      | null
                      | Record<string, unknown>
                      | {
                          gt?: null | number;
                          gte?: null | number;
                          lt?: null | number;
                          lte?: null | number;
                      }
                      | {
                          gt?: null | string;
                          gte?: null | string;
                          lt?: null | string;
                          lte?: null | string;
                      };
                  values_count?: null | Record<string, unknown> | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  };
              }
              | {
                  is_empty: {
                      key: string;
                  };
              }
              | {
                  is_null: {
                      key: string;
                  };
              }
              | {
                  has_id: (string | number)[];
              }
              | {
                  has_vector: string;
              }
              | {
                  nested: {
                      filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                      key: string;
                  };
              })[];
      must_not?:
          | null
          | Record<string, unknown>
          | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
          | {
              geo_bounding_box?: null | Record<string, unknown> | {
                  bottom_right: {
                      lat: number;
                      lon: number;
                  };
                  top_left: {
                      lat: number;
                      lon: number;
                  };
              };
              geo_polygon?: null | Record<string, unknown> | {
                  exterior: {
                      points: {
                          lat: number;
                          lon: number;
                      }[];
                  };
                  interiors?: null | {
                      points: {
                          lat: ...;
                          lon: ...;
                      }[];
                  }[];
              };
              geo_radius?: null | Record<string, unknown> | {
                  center: {
                      lat: number;
                      lon: number;
                  };
                  radius: number;
              };
              is_empty?: null | boolean;
              is_null?: null | boolean;
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: string;
                  }
                  | {
                      phrase: string;
                  }
                  | {
                      any: string[] | number[];
                  }
                  | {
                      except: string[] | number[];
                  };
              range?:
                  | null
                  | Record<string, unknown>
                  | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  }
                  | {
                      gt?: null | string;
                      gte?: null | string;
                      lt?: null | string;
                      lte?: null | string;
                  };
              values_count?: null | Record<string, unknown> | {
                  gt?: null | number;
                  gte?: null | number;
                  lt?: null | number;
                  lte?: null | number;
              };
          }
          | {
              is_empty: {
                  key: string;
              };
          }
          | {
              is_null: {
                  key: string;
              };
          }
          | {
              has_id: (string | number)[];
          }
          | {
              has_vector: string;
          }
          | {
              nested: {
                  filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                  key: string;
              };
          }
          | (
              | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
              | {
                  geo_bounding_box?: null | Record<string, unknown> | {
                      bottom_right: {
                          lat: number;
                          lon: number;
                      };
                      top_left: {
                          lat: number;
                          lon: number;
                      };
                  };
                  geo_polygon?: null | Record<string, unknown> | {
                      exterior: {
                          points: {
                              lat: ...;
                              lon: ...;
                          }[];
                      };
                      interiors?: null | {
                          points: ...;
                      }[];
                  };
                  geo_radius?: null | Record<string, unknown> | {
                      center: {
                          lat: number;
                          lon: number;
                      };
                      radius: number;
                  };
                  is_empty?: null | boolean;
                  is_null?: null | boolean;
                  key: string;
                  match?:
                      | null
                      | Record<string, unknown>
                      | {
                          value: string | number | boolean;
                      }
                      | {
                          text: string;
                      }
                      | {
                          phrase: string;
                      }
                      | {
                          any: string[] | number[];
                      }
                      | {
                          except: string[] | number[];
                      };
                  range?:
                      | null
                      | Record<string, unknown>
                      | {
                          gt?: null | number;
                          gte?: null | number;
                          lt?: null | number;
                          lte?: null | number;
                      }
                      | {
                          gt?: null | string;
                          gte?: null | string;
                          lt?: null | string;
                          lte?: null | string;
                      };
                  values_count?: null | Record<string, unknown> | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  };
              }
              | {
                  is_empty: {
                      key: string;
                  };
              }
              | {
                  is_null: {
                      key: string;
                  };
              }
              | {
                  has_id: (string | number)[];
              }
              | {
                  has_vector: string;
              }
              | {
                  nested: {
                      filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                      key: string;
                  };
              })[];
      should?:
          | null
          | Record<string, unknown>
          | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
          | {
              geo_bounding_box?: null | Record<string, unknown> | {
                  bottom_right: {
                      lat: number;
                      lon: number;
                  };
                  top_left: {
                      lat: number;
                      lon: number;
                  };
              };
              geo_polygon?: null | Record<string, unknown> | {
                  exterior: {
                      points: {
                          lat: number;
                          lon: number;
                      }[];
                  };
                  interiors?: null | {
                      points: {
                          lat: ...;
                          lon: ...;
                      }[];
                  }[];
              };
              geo_radius?: null | Record<string, unknown> | {
                  center: {
                      lat: number;
                      lon: number;
                  };
                  radius: number;
              };
              is_empty?: null | boolean;
              is_null?: null | boolean;
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: string;
                  }
                  | {
                      phrase: string;
                  }
                  | {
                      any: string[] | number[];
                  }
                  | {
                      except: string[] | number[];
                  };
              range?:
                  | null
                  | Record<string, unknown>
                  | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  }
                  | {
                      gt?: null | string;
                      gte?: null | string;
                      lt?: null | string;
                      lte?: null | string;
                  };
              values_count?: null | Record<string, unknown> | {
                  gt?: null | number;
                  gte?: null | number;
                  lt?: null | number;
                  lte?: null | number;
              };
          }
          | {
              is_empty: {
                  key: string;
              };
          }
          | {
              is_null: {
                  key: string;
              };
          }
          | {
              has_id: (string | number)[];
          }
          | {
              has_vector: string;
          }
          | {
              nested: {
                  filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                  key: string;
              };
          }
          | (
              | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
              | {
                  geo_bounding_box?: null | Record<string, unknown> | {
                      bottom_right: {
                          lat: number;
                          lon: number;
                      };
                      top_left: {
                          lat: number;
                          lon: number;
                      };
                  };
                  geo_polygon?: null | Record<string, unknown> | {
                      exterior: {
                          points: {
                              lat: ...;
                              lon: ...;
                          }[];
                      };
                      interiors?: null | {
                          points: ...;
                      }[];
                  };
                  geo_radius?: null | Record<string, unknown> | {
                      center: {
                          lat: number;
                          lon: number;
                      };
                      radius: number;
                  };
                  is_empty?: null | boolean;
                  is_null?: null | boolean;
                  key: string;
                  match?:
                      | null
                      | Record<string, unknown>
                      | {
                          value: string | number | boolean;
                      }
                      | {
                          text: string;
                      }
                      | {
                          phrase: string;
                      }
                      | {
                          any: string[] | number[];
                      }
                      | {
                          except: string[] | number[];
                      };
                  range?:
                      | null
                      | Record<string, unknown>
                      | {
                          gt?: null | number;
                          gte?: null | number;
                          lt?: null | number;
                          lte?: null | number;
                      }
                      | {
                          gt?: null | string;
                          gte?: null | string;
                          lt?: null | string;
                          lte?: null | string;
                      };
                  values_count?: null | Record<string, unknown> | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  };
              }
              | {
                  is_empty: {
                      key: string;
                  };
              }
              | {
                  is_null: {
                      key: string;
                  };
              }
              | {
                  has_id: (string | number)[];
              }
              | {
                  has_vector: string;
              }
              | {
                  nested: {
                      filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                      key: string;
                  };
              })[];
  }
  The default filter to merge.
- generatedFilter: undefined | {
      min_should?: null | Record<string, unknown> | {
          conditions: (
              | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
              | {
                  geo_bounding_box?: null | Record<string, unknown> | {
                      bottom_right: {
                          lat: number;
                          lon: number;
                      };
                      top_left: {
                          lat: number;
                          lon: number;
                      };
                  };
                  geo_polygon?: null | Record<string, unknown> | {
                      exterior: {
                          points: (...)[];
                      };
                      interiors?: null | (...)[];
                  };
                  geo_radius?: null | Record<string, unknown> | {
                      center: {
                          lat: number;
                          lon: number;
                      };
                      radius: number;
                  };
                  is_empty?: null | boolean;
                  is_null?: null | boolean;
                  key: string;
                  match?:
                      | null
                      | Record<string, unknown>
                      | {
                          value: string | number | boolean;
                      }
                      | {
                          text: string;
                      }
                      | {
                          phrase: string;
                      }
                      | {
                          any: (...)[] | (...)[];
                      }
                      | {
                          except: (...)[] | (...)[];
                      };
                  range?:
                      | null
                      | Record<string, unknown>
                      | {
                          gt?: null | number;
                          gte?: null | number;
                          lt?: null | number;
                          lte?: null | number;
                      }
                      | {
                          gt?: null | string;
                          gte?: null | string;
                          lt?: null | string;
                          lte?: null | string;
                      };
                  values_count?: null | Record<string, unknown> | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  };
              }
              | {
                  is_empty: {
                      key: string;
                  };
              }
              | {
                  is_null: {
                      key: string;
                  };
              }
              | {
                  has_id: (string | number)[];
              }
              | {
                  has_vector: string;
              }
              | {
                  nested: {
                      filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                      key: string;
                  };
              })[];
          min_count: number;
      };
      must?:
          | null
          | Record<string, unknown>
          | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
          | {
              geo_bounding_box?: null | Record<string, unknown> | {
                  bottom_right: {
                      lat: number;
                      lon: number;
                  };
                  top_left: {
                      lat: number;
                      lon: number;
                  };
              };
              geo_polygon?: null | Record<string, unknown> | {
                  exterior: {
                      points: {
                          lat: number;
                          lon: number;
                      }[];
                  };
                  interiors?: null | {
                      points: {
                          lat: ...;
                          lon: ...;
                      }[];
                  }[];
              };
              geo_radius?: null | Record<string, unknown> | {
                  center: {
                      lat: number;
                      lon: number;
                  };
                  radius: number;
              };
              is_empty?: null | boolean;
              is_null?: null | boolean;
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: string;
                  }
                  | {
                      phrase: string;
                  }
                  | {
                      any: string[] | number[];
                  }
                  | {
                      except: string[] | number[];
                  };
              range?:
                  | null
                  | Record<string, unknown>
                  | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  }
                  | {
                      gt?: null | string;
                      gte?: null | string;
                      lt?: null | string;
                      lte?: null | string;
                  };
              values_count?: null | Record<string, unknown> | {
                  gt?: null | number;
                  gte?: null | number;
                  lt?: null | number;
                  lte?: null | number;
              };
          }
          | {
              is_empty: {
                  key: string;
              };
          }
          | {
              is_null: {
                  key: string;
              };
          }
          | {
              has_id: (string | number)[];
          }
          | {
              has_vector: string;
          }
          | {
              nested: {
                  filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                  key: string;
              };
          }
          | (
              | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
              | {
                  geo_bounding_box?: null | Record<string, unknown> | {
                      bottom_right: {
                          lat: number;
                          lon: number;
                      };
                      top_left: {
                          lat: number;
                          lon: number;
                      };
                  };
                  geo_polygon?: null | Record<string, unknown> | {
                      exterior: {
                          points: {
                              lat: ...;
                              lon: ...;
                          }[];
                      };
                      interiors?: null | {
                          points: ...;
                      }[];
                  };
                  geo_radius?: null | Record<string, unknown> | {
                      center: {
                          lat: number;
                          lon: number;
                      };
                      radius: number;
                  };
                  is_empty?: null | boolean;
                  is_null?: null | boolean;
                  key: string;
                  match?:
                      | null
                      | Record<string, unknown>
                      | {
                          value: string | number | boolean;
                      }
                      | {
                          text: string;
                      }
                      | {
                          phrase: string;
                      }
                      | {
                          any: string[] | number[];
                      }
                      | {
                          except: string[] | number[];
                      };
                  range?:
                      | null
                      | Record<string, unknown>
                      | {
                          gt?: null | number;
                          gte?: null | number;
                          lt?: null | number;
                          lte?: null | number;
                      }
                      | {
                          gt?: null | string;
                          gte?: null | string;
                          lt?: null | string;
                          lte?: null | string;
                      };
                  values_count?: null | Record<string, unknown> | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  };
              }
              | {
                  is_empty: {
                      key: string;
                  };
              }
              | {
                  is_null: {
                      key: string;
                  };
              }
              | {
                  has_id: (string | number)[];
              }
              | {
                  has_vector: string;
              }
              | {
                  nested: {
                      filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                      key: string;
                  };
              })[];
      must_not?:
          | null
          | Record<string, unknown>
          | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
          | {
              geo_bounding_box?: null | Record<string, unknown> | {
                  bottom_right: {
                      lat: number;
                      lon: number;
                  };
                  top_left: {
                      lat: number;
                      lon: number;
                  };
              };
              geo_polygon?: null | Record<string, unknown> | {
                  exterior: {
                      points: {
                          lat: number;
                          lon: number;
                      }[];
                  };
                  interiors?: null | {
                      points: {
                          lat: ...;
                          lon: ...;
                      }[];
                  }[];
              };
              geo_radius?: null | Record<string, unknown> | {
                  center: {
                      lat: number;
                      lon: number;
                  };
                  radius: number;
              };
              is_empty?: null | boolean;
              is_null?: null | boolean;
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: string;
                  }
                  | {
                      phrase: string;
                  }
                  | {
                      any: string[] | number[];
                  }
                  | {
                      except: string[] | number[];
                  };
              range?:
                  | null
                  | Record<string, unknown>
                  | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  }
                  | {
                      gt?: null | string;
                      gte?: null | string;
                      lt?: null | string;
                      lte?: null | string;
                  };
              values_count?: null | Record<string, unknown> | {
                  gt?: null | number;
                  gte?: null | number;
                  lt?: null | number;
                  lte?: null | number;
              };
          }
          | {
              is_empty: {
                  key: string;
              };
          }
          | {
              is_null: {
                  key: string;
              };
          }
          | {
              has_id: (string | number)[];
          }
          | {
              has_vector: string;
          }
          | {
              nested: {
                  filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                  key: string;
              };
          }
          | (
              | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
              | {
                  geo_bounding_box?: null | Record<string, unknown> | {
                      bottom_right: {
                          lat: number;
                          lon: number;
                      };
                      top_left: {
                          lat: number;
                          lon: number;
                      };
                  };
                  geo_polygon?: null | Record<string, unknown> | {
                      exterior: {
                          points: {
                              lat: ...;
                              lon: ...;
                          }[];
                      };
                      interiors?: null | {
                          points: ...;
                      }[];
                  };
                  geo_radius?: null | Record<string, unknown> | {
                      center: {
                          lat: number;
                          lon: number;
                      };
                      radius: number;
                  };
                  is_empty?: null | boolean;
                  is_null?: null | boolean;
                  key: string;
                  match?:
                      | null
                      | Record<string, unknown>
                      | {
                          value: string | number | boolean;
                      }
                      | {
                          text: string;
                      }
                      | {
                          phrase: string;
                      }
                      | {
                          any: string[] | number[];
                      }
                      | {
                          except: string[] | number[];
                      };
                  range?:
                      | null
                      | Record<string, unknown>
                      | {
                          gt?: null | number;
                          gte?: null | number;
                          lt?: null | number;
                          lte?: null | number;
                      }
                      | {
                          gt?: null | string;
                          gte?: null | string;
                          lt?: null | string;
                          lte?: null | string;
                      };
                  values_count?: null | Record<string, unknown> | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  };
              }
              | {
                  is_empty: {
                      key: string;
                  };
              }
              | {
                  is_null: {
                      key: string;
                  };
              }
              | {
                  has_id: (string | number)[];
              }
              | {
                  has_vector: string;
              }
              | {
                  nested: {
                      filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                      key: string;
                  };
              })[];
      should?:
          | null
          | Record<string, unknown>
          | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
          | {
              geo_bounding_box?: null | Record<string, unknown> | {
                  bottom_right: {
                      lat: number;
                      lon: number;
                  };
                  top_left: {
                      lat: number;
                      lon: number;
                  };
              };
              geo_polygon?: null | Record<string, unknown> | {
                  exterior: {
                      points: {
                          lat: number;
                          lon: number;
                      }[];
                  };
                  interiors?: null | {
                      points: {
                          lat: ...;
                          lon: ...;
                      }[];
                  }[];
              };
              geo_radius?: null | Record<string, unknown> | {
                  center: {
                      lat: number;
                      lon: number;
                  };
                  radius: number;
              };
              is_empty?: null | boolean;
              is_null?: null | boolean;
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: string;
                  }
                  | {
                      phrase: string;
                  }
                  | {
                      any: string[] | number[];
                  }
                  | {
                      except: string[] | number[];
                  };
              range?:
                  | null
                  | Record<string, unknown>
                  | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  }
                  | {
                      gt?: null | string;
                      gte?: null | string;
                      lt?: null | string;
                      lte?: null | string;
                  };
              values_count?: null | Record<string, unknown> | {
                  gt?: null | number;
                  gte?: null | number;
                  lt?: null | number;
                  lte?: null | number;
              };
          }
          | {
              is_empty: {
                  key: string;
              };
          }
          | {
              is_null: {
                  key: string;
              };
          }
          | {
              has_id: (string | number)[];
          }
          | {
              has_vector: string;
          }
          | {
              nested: {
                  filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                  key: string;
              };
          }
          | (
              | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
              | {
                  geo_bounding_box?: null | Record<string, unknown> | {
                      bottom_right: {
                          lat: number;
                          lon: number;
                      };
                      top_left: {
                          lat: number;
                          lon: number;
                      };
                  };
                  geo_polygon?: null | Record<string, unknown> | {
                      exterior: {
                          points: {
                              lat: ...;
                              lon: ...;
                          }[];
                      };
                      interiors?: null | {
                          points: ...;
                      }[];
                  };
                  geo_radius?: null | Record<string, unknown> | {
                      center: {
                          lat: number;
                          lon: number;
                      };
                      radius: number;
                  };
                  is_empty?: null | boolean;
                  is_null?: null | boolean;
                  key: string;
                  match?:
                      | null
                      | Record<string, unknown>
                      | {
                          value: string | number | boolean;
                      }
                      | {
                          text: string;
                      }
                      | {
                          phrase: string;
                      }
                      | {
                          any: string[] | number[];
                      }
                      | {
                          except: string[] | number[];
                      };
                  range?:
                      | null
                      | Record<string, unknown>
                      | {
                          gt?: null | number;
                          gte?: null | number;
                          lt?: null | number;
                          lte?: null | number;
                      }
                      | {
                          gt?: null | string;
                          gte?: null | string;
                          lt?: null | string;
                          lte?: null | string;
                      };
                  values_count?: null | Record<string, unknown> | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  };
              }
              | {
                  is_empty: {
                      key: string;
                  };
              }
              | {
                  is_null: {
                      key: string;
                  };
              }
              | {
                  has_id: (string | number)[];
              }
              | {
                  has_vector: string;
              }
              | {
                  nested: {
                      filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                      key: string;
                  };
              })[];
  }
  The generated filter to merge.
- mergeType: string = "and"
  The type of merge to perform. Can be 'and', 'or', or 'replace'. Defaults to 'and'.
- forceDefaultFilter: boolean = false
  If true, the default filter is always returned if the generated filter is empty. Defaults to false.
Returns undefined | {
    min_should?: null | Record<string, unknown> | {
        conditions: (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: (...)[];
                    };
                    interiors?: null | (...)[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: (...)[] | (...)[];
                    }
                    | {
                        except: (...)[] | (...)[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
        min_count: number;
    };
    must?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: ...;
                        lon: ...;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: ...;
                            lon: ...;
                        }[];
                    };
                    interiors?: null | {
                        points: ...;
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
    must_not?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: ...;
                        lon: ...;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: ...;
                            lon: ...;
                        }[];
                    };
                    interiors?: null | {
                        points: ...;
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
    should?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: ...;
                        lon: ...;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: ...;
                            lon: ...;
                        }[];
                    };
                    interiors?: null | {
                        points: ...;
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
}
A merged QdrantFilter, or undefined if both filters are empty.
Overrides BaseTranslator.mergeFilters
- Defined in libs/langchain-community/src/structured_query/qdrant.ts:148

visitComparison

visitComparison(comparison): {
    geo_bounding_box?: null | Record<string, unknown> | {
        bottom_right: {
            lat: number;
            lon: number;
        };
        top_left: {
            lat: number;
            lon: number;
        };
    };
    geo_polygon?: null | Record<string, unknown> | {
        exterior: {
            points: {
                lat: number;
                lon: number;
            }[];
        };
        interiors?: null | {
            points: {
                lat: number;
                lon: number;
            }[];
        }[];
    };
    geo_radius?: null | Record<string, unknown> | {
        center: {
            lat: number;
            lon: number;
        };
        radius: number;
    };
    is_empty?: null | boolean;
    is_null?: null | boolean;
    key: string;
    match?:
        | null
        | Record<string, unknown>
        | {
            value: string | number | boolean;
        }
        | {
            text: string;
        }
        | {
            phrase: string;
        }
        | {
            any: string[] | number[];
        }
        | {
            except: string[] | number[];
        };
    range?:
        | null
        | Record<string, unknown>
        | {
            gt?: null | number;
            gte?: null | number;
            lt?: null | number;
            lte?: null | number;
        }
        | {
            gt?: null | string;
            gte?: null | string;
            lt?: null | string;
            lte?: null | string;
        };
    values_count?: null | Record<string, unknown> | {
        gt?: null | number;
        gte?: null | number;
        lt?: null | number;
        lte?: null | number;
    };
}
Visits a comparison and returns a QdrantCondition. The value is casted to the correct type. The attribute is prefixed with "metadata.", since metadata is nested in the Qdrant payload.
Parameters
- comparison: Comparison<string | number>
  The comparison to visit.
Returns {
    geo_bounding_box?: null | Record<string, unknown> | {
        bottom_right: {
            lat: number;
            lon: number;
        };
        top_left: {
            lat: number;
            lon: number;
        };
    };
    geo_polygon?: null | Record<string, unknown> | {
        exterior: {
            points: {
                lat: number;
                lon: number;
            }[];
        };
        interiors?: null | {
            points: {
                lat: number;
                lon: number;
            }[];
        }[];
    };
    geo_radius?: null | Record<string, unknown> | {
        center: {
            lat: number;
            lon: number;
        };
        radius: number;
    };
    is_empty?: null | boolean;
    is_null?: null | boolean;
    key: string;
    match?:
        | null
        | Record<string, unknown>
        | {
            value: string | number | boolean;
        }
        | {
            text: string;
        }
        | {
            phrase: string;
        }
        | {
            any: string[] | number[];
        }
        | {
            except: string[] | number[];
        };
    range?:
        | null
        | Record<string, unknown>
        | {
            gt?: null | number;
            gte?: null | number;
            lt?: null | number;
            lte?: null | number;
        }
        | {
            gt?: null | string;
            gte?: null | string;
            lt?: null | string;
            lte?: null | string;
        };
    values_count?: null | Record<string, unknown> | {
        gt?: null | number;
        gte?: null | number;
        lt?: null | number;
        lte?: null | number;
    };
}
A QdrantCondition.
- Optionalgeo_bounding_box?: null | Record<string, unknown> | {
      bottom_right: {
          lat: number;
          lon: number;
      };
      top_left: {
          lat: number;
          lon: number;
      };
  }
  Description
  Check if points geolocation lies in a given area
- Optionalgeo_polygon?: null | Record<string, unknown> | {
      exterior: {
          points: {
              lat: number;
              lon: number;
          }[];
      };
      interiors?: null | {
          points: {
              lat: number;
              lon: number;
          }[];
      }[];
  }
  Description
  Check if geo point is within a given polygon
- Optionalgeo_radius?: null | Record<string, unknown> | {
      center: {
          lat: number;
          lon: number;
      };
      radius: number;
  }
  Description
  Check if geo point is within a given radius
- Optionalis_empty?: null | boolean
  Description
  Check that the field is empty, alternative syntax for is_empty: "field_name"
- Optionalis_null?: null | boolean
  Description
  Check that the field is null, alternative syntax for is_null: "field_name"
- key: string
  Description
  Payload key
- Optionalmatch?:
      | null
      | Record<string, unknown>
      | {
          value: string | number | boolean;
      }
      | {
          text: string;
      }
      | {
          phrase: string;
      }
      | {
          any: string[] | number[];
      }
      | {
          except: string[] | number[];
      }
  Description
  Check if point has field with a given value
- Optionalrange?:
      | null
      | Record<string, unknown>
      | {
          gt?: null | number;
          gte?: null | number;
          lt?: null | number;
          lte?: null | number;
      }
      | {
          gt?: null | string;
          gte?: null | string;
          lt?: null | string;
          lte?: null | string;
      }
  Description
  Check if points value lies in a given range
- Optionalvalues_count?: null | Record<string, unknown> | {
      gt?: null | number;
      gte?: null | number;
      lt?: null | number;
      lte?: null | number;
  }
  Description
  Check number of values of the field
Overrides BaseTranslator.visitComparison
- Defined in libs/langchain-community/src/structured_query/qdrant.ts:85

visitOperation

visitOperation(operation): {
    min_should?: null | Record<string, unknown> | {
        conditions: (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: ...;
                            lon: ...;
                        }[];
                    };
                    interiors?: null | {
                        points: ...;
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
        min_count: number;
    };
    must?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: number;
                            lon: number;
                        }[];
                    };
                    interiors?: null | {
                        points: (...)[];
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
    must_not?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: number;
                            lon: number;
                        }[];
                    };
                    interiors?: null | {
                        points: (...)[];
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
    should?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: number;
                            lon: number;
                        }[];
                    };
                    interiors?: null | {
                        points: (...)[];
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
}
Visits an operation and returns a QdrantFilter.
Parameters
- operation: Operation
  The operation to visit.
Returns {
    min_should?: null | Record<string, unknown> | {
        conditions: (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: ...;
                            lon: ...;
                        }[];
                    };
                    interiors?: null | {
                        points: ...;
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
        min_count: number;
    };
    must?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: number;
                            lon: number;
                        }[];
                    };
                    interiors?: null | {
                        points: (...)[];
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
    must_not?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: number;
                            lon: number;
                        }[];
                    };
                    interiors?: null | {
                        points: (...)[];
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
    should?:
        | null
        | Record<string, unknown>
        | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
        | {
            geo_bounding_box?: null | Record<string, unknown> | {
                bottom_right: {
                    lat: number;
                    lon: number;
                };
                top_left: {
                    lat: number;
                    lon: number;
                };
            };
            geo_polygon?: null | Record<string, unknown> | {
                exterior: {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                };
                interiors?: null | {
                    points: {
                        lat: number;
                        lon: number;
                    }[];
                }[];
            };
            geo_radius?: null | Record<string, unknown> | {
                center: {
                    lat: number;
                    lon: number;
                };
                radius: number;
            };
            is_empty?: null | boolean;
            is_null?: null | boolean;
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: string;
                }
                | {
                    phrase: string;
                }
                | {
                    any: string[] | number[];
                }
                | {
                    except: string[] | number[];
                };
            range?:
                | null
                | Record<string, unknown>
                | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                }
                | {
                    gt?: null | string;
                    gte?: null | string;
                    lt?: null | string;
                    lte?: null | string;
                };
            values_count?: null | Record<string, unknown> | {
                gt?: null | number;
                gte?: null | number;
                lt?: null | number;
                lte?: null | number;
            };
        }
        | {
            is_empty: {
                key: string;
            };
        }
        | {
            is_null: {
                key: string;
            };
        }
        | {
            has_id: (string | number)[];
        }
        | {
            has_vector: string;
        }
        | {
            nested: {
                filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                key: string;
            };
        }
        | (
            | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
            | {
                geo_bounding_box?: null | Record<string, unknown> | {
                    bottom_right: {
                        lat: number;
                        lon: number;
                    };
                    top_left: {
                        lat: number;
                        lon: number;
                    };
                };
                geo_polygon?: null | Record<string, unknown> | {
                    exterior: {
                        points: {
                            lat: number;
                            lon: number;
                        }[];
                    };
                    interiors?: null | {
                        points: (...)[];
                    }[];
                };
                geo_radius?: null | Record<string, unknown> | {
                    center: {
                        lat: number;
                        lon: number;
                    };
                    radius: number;
                };
                is_empty?: null | boolean;
                is_null?: null | boolean;
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: string;
                    }
                    | {
                        phrase: string;
                    }
                    | {
                        any: string[] | number[];
                    }
                    | {
                        except: string[] | number[];
                    };
                range?:
                    | null
                    | Record<string, unknown>
                    | {
                        gt?: null | number;
                        gte?: null | number;
                        lt?: null | number;
                        lte?: null | number;
                    }
                    | {
                        gt?: null | string;
                        gte?: null | string;
                        lt?: null | string;
                        lte?: null | string;
                    };
                values_count?: null | Record<string, unknown> | {
                    gt?: null | number;
                    gte?: null | number;
                    lt?: null | number;
                    lte?: null | number;
                };
            }
            | {
                is_empty: {
                    key: string;
                };
            }
            | {
                is_null: {
                    key: string;
                };
            }
            | {
                has_id: (string | number)[];
            }
            | {
                has_vector: string;
            }
            | {
                nested: {
                    filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                    key: string;
                };
            })[];
}
A QdrantFilter.
- Optionalmin_should?: null | Record<string, unknown> | {
      conditions: (
          | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
          | {
              geo_bounding_box?: null | Record<string, unknown> | {
                  bottom_right: {
                      lat: number;
                      lon: number;
                  };
                  top_left: {
                      lat: number;
                      lon: number;
                  };
              };
              geo_polygon?: null | Record<string, unknown> | {
                  exterior: {
                      points: {
                          lat: ...;
                          lon: ...;
                      }[];
                  };
                  interiors?: null | {
                      points: ...;
                  }[];
              };
              geo_radius?: null | Record<string, unknown> | {
                  center: {
                      lat: number;
                      lon: number;
                  };
                  radius: number;
              };
              is_empty?: null | boolean;
              is_null?: null | boolean;
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: string;
                  }
                  | {
                      phrase: string;
                  }
                  | {
                      any: string[] | number[];
                  }
                  | {
                      except: string[] | number[];
                  };
              range?:
                  | null
                  | Record<string, unknown>
                  | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  }
                  | {
                      gt?: null | string;
                      gte?: null | string;
                      lt?: null | string;
                      lte?: null | string;
                  };
              values_count?: null | Record<string, unknown> | {
                  gt?: null | number;
                  gte?: null | number;
                  lt?: null | number;
                  lte?: null | number;
              };
          }
          | {
              is_empty: {
                  key: string;
              };
          }
          | {
              is_null: {
                  key: string;
              };
          }
          | {
              has_id: (string | number)[];
          }
          | {
              has_vector: string;
          }
          | {
              nested: {
                  filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                  key: string;
              };
          })[];
      min_count: number;
  }
  Description
  At least minimum amount of given conditions should match
- Optionalmust?:
      | null
      | Record<string, unknown>
      | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
      | {
          geo_bounding_box?: null | Record<string, unknown> | {
              bottom_right: {
                  lat: number;
                  lon: number;
              };
              top_left: {
                  lat: number;
                  lon: number;
              };
          };
          geo_polygon?: null | Record<string, unknown> | {
              exterior: {
                  points: {
                      lat: number;
                      lon: number;
                  }[];
              };
              interiors?: null | {
                  points: {
                      lat: number;
                      lon: number;
                  }[];
              }[];
          };
          geo_radius?: null | Record<string, unknown> | {
              center: {
                  lat: number;
                  lon: number;
              };
              radius: number;
          };
          is_empty?: null | boolean;
          is_null?: null | boolean;
          key: string;
          match?:
              | null
              | Record<string, unknown>
              | {
                  value: string | number | boolean;
              }
              | {
                  text: string;
              }
              | {
                  phrase: string;
              }
              | {
                  any: string[] | number[];
              }
              | {
                  except: string[] | number[];
              };
          range?:
              | null
              | Record<string, unknown>
              | {
                  gt?: null | number;
                  gte?: null | number;
                  lt?: null | number;
                  lte?: null | number;
              }
              | {
                  gt?: null | string;
                  gte?: null | string;
                  lt?: null | string;
                  lte?: null | string;
              };
          values_count?: null | Record<string, unknown> | {
              gt?: null | number;
              gte?: null | number;
              lt?: null | number;
              lte?: null | number;
          };
      }
      | {
          is_empty: {
              key: string;
          };
      }
      | {
          is_null: {
              key: string;
          };
      }
      | {
          has_id: (string | number)[];
      }
      | {
          has_vector: string;
      }
      | {
          nested: {
              filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
              key: string;
          };
      }
      | (
          | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
          | {
              geo_bounding_box?: null | Record<string, unknown> | {
                  bottom_right: {
                      lat: number;
                      lon: number;
                  };
                  top_left: {
                      lat: number;
                      lon: number;
                  };
              };
              geo_polygon?: null | Record<string, unknown> | {
                  exterior: {
                      points: {
                          lat: number;
                          lon: number;
                      }[];
                  };
                  interiors?: null | {
                      points: (...)[];
                  }[];
              };
              geo_radius?: null | Record<string, unknown> | {
                  center: {
                      lat: number;
                      lon: number;
                  };
                  radius: number;
              };
              is_empty?: null | boolean;
              is_null?: null | boolean;
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: string;
                  }
                  | {
                      phrase: string;
                  }
                  | {
                      any: string[] | number[];
                  }
                  | {
                      except: string[] | number[];
                  };
              range?:
                  | null
                  | Record<string, unknown>
                  | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  }
                  | {
                      gt?: null | string;
                      gte?: null | string;
                      lt?: null | string;
                      lte?: null | string;
                  };
              values_count?: null | Record<string, unknown> | {
                  gt?: null | number;
                  gte?: null | number;
                  lt?: null | number;
                  lte?: null | number;
              };
          }
          | {
              is_empty: {
                  key: string;
              };
          }
          | {
              is_null: {
                  key: string;
              };
          }
          | {
              has_id: (string | number)[];
          }
          | {
              has_vector: string;
          }
          | {
              nested: {
                  filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                  key: string;
              };
          })[]
  Description
  All conditions must match
  
  Default
```
null
```
- Optionalmust_not?:
      | null
      | Record<string, unknown>
      | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
      | {
          geo_bounding_box?: null | Record<string, unknown> | {
              bottom_right: {
                  lat: number;
                  lon: number;
              };
              top_left: {
                  lat: number;
                  lon: number;
              };
          };
          geo_polygon?: null | Record<string, unknown> | {
              exterior: {
                  points: {
                      lat: number;
                      lon: number;
                  }[];
              };
              interiors?: null | {
                  points: {
                      lat: number;
                      lon: number;
                  }[];
              }[];
          };
          geo_radius?: null | Record<string, unknown> | {
              center: {
                  lat: number;
                  lon: number;
              };
              radius: number;
          };
          is_empty?: null | boolean;
          is_null?: null | boolean;
          key: string;
          match?:
              | null
              | Record<string, unknown>
              | {
                  value: string | number | boolean;
              }
              | {
                  text: string;
              }
              | {
                  phrase: string;
              }
              | {
                  any: string[] | number[];
              }
              | {
                  except: string[] | number[];
              };
          range?:
              | null
              | Record<string, unknown>
              | {
                  gt?: null | number;
                  gte?: null | number;
                  lt?: null | number;
                  lte?: null | number;
              }
              | {
                  gt?: null | string;
                  gte?: null | string;
                  lt?: null | string;
                  lte?: null | string;
              };
          values_count?: null | Record<string, unknown> | {
              gt?: null | number;
              gte?: null | number;
              lt?: null | number;
              lte?: null | number;
          };
      }
      | {
          is_empty: {
              key: string;
          };
      }
      | {
          is_null: {
              key: string;
          };
      }
      | {
          has_id: (string | number)[];
      }
      | {
          has_vector: string;
      }
      | {
          nested: {
              filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
              key: string;
          };
      }
      | (
          | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
          | {
              geo_bounding_box?: null | Record<string, unknown> | {
                  bottom_right: {
                      lat: number;
                      lon: number;
                  };
                  top_left: {
                      lat: number;
                      lon: number;
                  };
              };
              geo_polygon?: null | Record<string, unknown> | {
                  exterior: {
                      points: {
                          lat: number;
                          lon: number;
                      }[];
                  };
                  interiors?: null | {
                      points: (...)[];
                  }[];
              };
              geo_radius?: null | Record<string, unknown> | {
                  center: {
                      lat: number;
                      lon: number;
                  };
                  radius: number;
              };
              is_empty?: null | boolean;
              is_null?: null | boolean;
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: string;
                  }
                  | {
                      phrase: string;
                  }
                  | {
                      any: string[] | number[];
                  }
                  | {
                      except: string[] | number[];
                  };
              range?:
                  | null
                  | Record<string, unknown>
                  | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  }
                  | {
                      gt?: null | string;
                      gte?: null | string;
                      lt?: null | string;
                      lte?: null | string;
                  };
              values_count?: null | Record<string, unknown> | {
                  gt?: null | number;
                  gte?: null | number;
                  lt?: null | number;
                  lte?: null | number;
              };
          }
          | {
              is_empty: {
                  key: string;
              };
          }
          | {
              is_null: {
                  key: string;
              };
          }
          | {
              has_id: (string | number)[];
          }
          | {
              has_vector: string;
          }
          | {
              nested: {
                  filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                  key: string;
              };
          })[]
  Description
  All conditions must NOT match
  
  Default
```
null
```
- Optionalshould?:
      | null
      | Record<string, unknown>
      | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
      | {
          geo_bounding_box?: null | Record<string, unknown> | {
              bottom_right: {
                  lat: number;
                  lon: number;
              };
              top_left: {
                  lat: number;
                  lon: number;
              };
          };
          geo_polygon?: null | Record<string, unknown> | {
              exterior: {
                  points: {
                      lat: number;
                      lon: number;
                  }[];
              };
              interiors?: null | {
                  points: {
                      lat: number;
                      lon: number;
                  }[];
              }[];
          };
          geo_radius?: null | Record<string, unknown> | {
              center: {
                  lat: number;
                  lon: number;
              };
              radius: number;
          };
          is_empty?: null | boolean;
          is_null?: null | boolean;
          key: string;
          match?:
              | null
              | Record<string, unknown>
              | {
                  value: string | number | boolean;
              }
              | {
                  text: string;
              }
              | {
                  phrase: string;
              }
              | {
                  any: string[] | number[];
              }
              | {
                  except: string[] | number[];
              };
          range?:
              | null
              | Record<string, unknown>
              | {
                  gt?: null | number;
                  gte?: null | number;
                  lt?: null | number;
                  lte?: null | number;
              }
              | {
                  gt?: null | string;
                  gte?: null | string;
                  lt?: null | string;
                  lte?: null | string;
              };
          values_count?: null | Record<string, unknown> | {
              gt?: null | number;
              gte?: null | number;
              lt?: null | number;
              lte?: null | number;
          };
      }
      | {
          is_empty: {
              key: string;
          };
      }
      | {
          is_null: {
              key: string;
          };
      }
      | {
          has_id: (string | number)[];
      }
      | {
          has_vector: string;
      }
      | {
          nested: {
              filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
              key: string;
          };
      }
      | (
          | ({ should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......)
          | {
              geo_bounding_box?: null | Record<string, unknown> | {
                  bottom_right: {
                      lat: number;
                      lon: number;
                  };
                  top_left: {
                      lat: number;
                      lon: number;
                  };
              };
              geo_polygon?: null | Record<string, unknown> | {
                  exterior: {
                      points: {
                          lat: number;
                          lon: number;
                      }[];
                  };
                  interiors?: null | {
                      points: (...)[];
                  }[];
              };
              geo_radius?: null | Record<string, unknown> | {
                  center: {
                      lat: number;
                      lon: number;
                  };
                  radius: number;
              };
              is_empty?: null | boolean;
              is_null?: null | boolean;
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: string;
                  }
                  | {
                      phrase: string;
                  }
                  | {
                      any: string[] | number[];
                  }
                  | {
                      except: string[] | number[];
                  };
              range?:
                  | null
                  | Record<string, unknown>
                  | {
                      gt?: null | number;
                      gte?: null | number;
                      lt?: null | number;
                      lte?: null | number;
                  }
                  | {
                      gt?: null | string;
                      gte?: null | string;
                      lt?: null | string;
                      lte?: null | string;
                  };
              values_count?: null | Record<string, unknown> | {
                  gt?: null | number;
                  gte?: null | number;
                  lt?: null | number;
                  lte?: null | number;
              };
          }
          | {
              is_empty: {
                  key: string;
              };
          }
          | {
              is_null: {
                  key: string;
              };
          }
          | {
              has_id: (string | number)[];
          }
          | {
              has_vector: string;
          }
          | {
              nested: {
                  filter: { should?: Record<string, unknown> | ... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { ...; } | null | undefined; ... 6 more ...; is_null?: boolean | ... 1 more ... | undefined; } | ... 7 more ......;
                  key: string;
              };
          })[]
  Description
  At least one of those conditions should match
  
  Default
```
null
```
Overrides BaseTranslator.visitOperation
- Defined in libs/langchain-community/src/structured_query/qdrant.ts:63

visitStructuredQuery

visitStructuredQuery(query): {
filter?: T["FilterType"];
}
Visits a structured query and returns a VisitStructuredQueryOutput. If the query has a filter, it is visited.
Parameters
- query: StructuredQuery
  The structured query to visit.
Returns {
filter?: T["FilterType"];
}
An instance of VisitStructuredQueryOutput.
- Optionalfilter?: T["FilterType"]
Overrides BaseTranslator.visitStructuredQuery
- Defined in libs/langchain-community/src/structured_query/qdrant.ts:124

Class QdrantTranslator<T>

Example

Type Parameters

Hierarchy (view full)

Index

Constructors

Properties

Methods

Constructors

constructor

Type Parameters

Returns QdrantTranslator<T>

Properties

VisitComparisonOutput

Type declaration

Optionalgeo_bounding_box?: null | Record<string, unknown> | { bottom_right: { lat: number; lon: number; }; top_left: { lat: number; lon: number; }; }

Description

Optionalgeo_polygon?: null | Record<string, unknown> | { exterior: { points: { lat: number; lon: number; }[]; }; interiors?: null | { points: { lat: number; lon: number; }[]; }[]; }

Description

Optionalgeo_radius?: null | Record<string, unknown> | { center: { lat: number; lon: number; }; radius: number; }

Description

Optionalis_empty?: null | boolean

Description

Optionalis_null?: null | boolean

Description

key: string

Description

Optionalmatch?: | null | Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { except: string[] | number[]; }

Description

Optionalrange?: | null | Record<string, unknown> | { gt?: null | number; gte?: null | number; lt?: null | number; lte?: null | number; } | { gt?: null | string; gte?: null | string; lt?: null | string; lte?: null | string; }

Description

Optionalvalues_count?: null | Record<string, unknown> | { gt?: null | number; gte?: null | number; lt?: null | number; lte?: null | number; }

Description

VisitOperationOutput

Type declaration

Description

Description

Default

Description

Default

Description

Default

VisitStructuredQueryOutput

allowedComparators

allowedOperators

Methods

formatFunction

Returns string

mergeFilters

Parameters

visitComparison

Parameters

Optionalgeo_bounding_box?: null | Record<string, unknown> | { bottom_right: { lat: number; lon: number; }; top_left: { lat: number; lon: number; }; }

Description

Optionalgeo_polygon?: null | Record<string, unknown> | { exterior: { points: { lat: number; lon: number; }[]; }; interiors?: null | { points: { lat: number; lon: number; }[]; }[]; }

Description

Optionalgeo_radius?: null | Record<string, unknown> | { center: { lat: number; lon: number; }; radius: number; }

Description

Optionalis_empty?: null | boolean

Description

Optionalis_null?: null | boolean

Description

key: string

Description

Optionalmatch?: | null | Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { phrase: string; } | { any: string[] | number[]; } | { except: string[] | number[]; }

Description

Optionalrange?: | null | Record<string, unknown> | { gt?: null | number; gte?: null | number; lt?: null | number; lte?: null | number; } | { gt?: null | string; gte?: null | string; lt?: null | string; lte?: null | string; }

Description

Optionalvalues_count?: null | Record<string, unknown> | { gt?: null | number; gte?: null | number; lt?: null | number; lte?: null | number; }

Description

visitOperation

Parameters

Description

Description

Default

Description

Default

Description

Default

visitStructuredQuery

`Optional`geo_bounding_box?: null | Record<string, unknown> | {
bottom_right: {
lat: number;
lon: number;
};
top_left: {
lat: number;
lon: number;
};
}

`Optional`geo_polygon?: null | Record<string, unknown> | {
exterior: {
points: {
lat: number;
lon: number;
}[];
};
interiors?: null | {
points: {
lat: number;
lon: number;
}[];
}[];
}

`Optional`geo_radius?: null | Record<string, unknown> | {
center: {
lat: number;
lon: number;
};
radius: number;
}

`Optional`is_empty?: null | boolean

`Optional`is_null?: null | boolean

`Optional`match?:
| null
| Record<string, unknown>
| {
value: string | number | boolean;
}
| {
text: string;
}
| {
phrase: string;
}
| {
any: string[] | number[];
}
| {
except: string[] | number[];
}

`Optional`range?:
| null
| Record<string, unknown>
| {
gt?: null | number;
gte?: null | number;
lt?: null | number;
lte?: null | number;
}
| {
gt?: null | string;
gte?: null | string;
lt?: null | string;
lte?: null | string;
}

`Optional`values_count?: null | Record<string, unknown> | {
gt?: null | number;
gte?: null | number;
lt?: null | number;
lte?: null | number;
}

`Optional`geo_bounding_box?: null | Record<string, unknown> | {
bottom_right: {
lat: number;
lon: number;
};
top_left: {
lat: number;
lon: number;
};
}

`Optional`geo_polygon?: null | Record<string, unknown> | {
exterior: {
points: {
lat: number;
lon: number;
}[];
};
interiors?: null | {
points: {
lat: number;
lon: number;
}[];
}[];
}

`Optional`geo_radius?: null | Record<string, unknown> | {
center: {
lat: number;
lon: number;
};
radius: number;
}

`Optional`is_empty?: null | boolean

`Optional`is_null?: null | boolean

`Optional`match?:
| null
| Record<string, unknown>
| {
value: string | number | boolean;
}
| {
text: string;
}
| {
phrase: string;
}
| {
any: string[] | number[];
}
| {
except: string[] | number[];
}

`Optional`range?:
| null
| Record<string, unknown>
| {
gt?: null | number;
gte?: null | number;
lt?: null | number;
lte?: null | number;
}
| {
gt?: null | string;
gte?: null | string;
lt?: null | string;
lte?: null | string;
}

`Optional`values_count?: null | Record<string, unknown> | {
gt?: null | number;
gte?: null | number;
lt?: null | number;
lte?: null | number;
}

Returns {
filter?: T["FilterType"];
}

`Optional`filter?: T["FilterType"]