Class QdrantTranslator<T>

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

Example

const selfQueryRetriever = new SelfQueryRetriever({
  llm: new ChatOpenAI(),
  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;
    };
    key: string;
    match?:
        | null
        | Record<string, unknown>
        | {
            value: string | number | boolean;
        }
        | {
            text: 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 geo location 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
key: string
Description
Payload key
Optionalmatch?:
    | null
    | Record<string, unknown>
    | {
        value: string | number | boolean;
    }
    | {
        text: 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?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
            | {
                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;
                };
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: 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)[];
            }
            | {
                nested: {
                    filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                    key: string;
                };
            })[];
        min_count: number;
    };
    must?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                key: string;
            };
        })[];
    must_not?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                key: string;
            };
        })[];
    should?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                key: string;
            };
        })[];
}

Type declaration

Optionalmin_should?: null | Record<string, unknown> | {
    conditions: (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                key: string;
            };
        })[];
    min_count: number;
}
Description
At least minimum amount of given conditions should match
Optionalmust?: null | (
    | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
    | {
        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;
        };
        key: string;
        match?:
            | null
            | Record<string, unknown>
            | {
                value: string | number | boolean;
            }
            | {
                text: 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)[];
    }
    | {
        nested: {
            filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
            key: string;
        };
    })[]
Description
All conditions must match
Optionalmust_not?: null | (
    | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
    | {
        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;
        };
        key: string;
        match?:
            | null
            | Record<string, unknown>
            | {
                value: string | number | boolean;
            }
            | {
                text: 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)[];
    }
    | {
        nested: {
            filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
            key: string;
        };
    })[]
Description
All conditions must NOT match
Optionalshould?: null | (
    | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
    | {
        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;
        };
        key: string;
        match?:
            | null
            | Record<string, unknown>
            | {
                value: string | number | boolean;
            }
            | {
                text: 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)[];
    }
    | {
        nested: {
            filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
            key: string;
        };
    })[]
Description
At least one of those conditions should match

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?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
            | {
                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;
                };
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: 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)[];
            }
            | {
                nested: {
                    filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                    key: string;
                };
            })[];
        min_count: number;
    };
    must?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                key: string;
            };
        })[];
    must_not?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                key: string;
            };
        })[];
    should?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                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?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
              | {
                  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;
                  };
                  key: string;
                  match?:
                      | null
                      | Record<string, unknown>
                      | {
                          value: string | number | boolean;
                      }
                      | {
                          text: 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)[];
              }
              | {
                  nested: {
                      filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                      key: string;
                  };
              })[];
          min_count: number;
      };
      must?: null | (
          | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
          | {
              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;
              };
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: 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)[];
          }
          | {
              nested: {
                  filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                  key: string;
              };
          })[];
      must_not?: null | (
          | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
          | {
              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;
              };
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: 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)[];
          }
          | {
              nested: {
                  filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                  key: string;
              };
          })[];
      should?: null | (
          | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
          | {
              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;
              };
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: 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)[];
          }
          | {
              nested: {
                  filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                  key: string;
              };
          })[];
  }
  The default filter to merge.
- generatedFilter: undefined | {
      min_should?: null | Record<string, unknown> | {
          conditions: (
              | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
              | {
                  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;
                  };
                  key: string;
                  match?:
                      | null
                      | Record<string, unknown>
                      | {
                          value: string | number | boolean;
                      }
                      | {
                          text: 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)[];
              }
              | {
                  nested: {
                      filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                      key: string;
                  };
              })[];
          min_count: number;
      };
      must?: null | (
          | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
          | {
              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;
              };
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: 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)[];
          }
          | {
              nested: {
                  filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                  key: string;
              };
          })[];
      must_not?: null | (
          | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
          | {
              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;
              };
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: 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)[];
          }
          | {
              nested: {
                  filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                  key: string;
              };
          })[];
      should?: null | (
          | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
          | {
              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;
              };
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: 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)[];
          }
          | {
              nested: {
                  filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                  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?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
            | {
                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;
                };
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: 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)[];
            }
            | {
                nested: {
                    filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                    key: string;
                };
            })[];
        min_count: number;
    };
    must?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                key: string;
            };
        })[];
    must_not?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                key: string;
            };
        })[];
    should?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                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;
    };
    key: string;
    match?:
        | null
        | Record<string, unknown>
        | {
            value: string | number | boolean;
        }
        | {
            text: 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
  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;
    };
    key: string;
    match?:
        | null
        | Record<string, unknown>
        | {
            value: string | number | boolean;
        }
        | {
            text: 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 geo location 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
- key: string
  Description
  Payload key
- Optionalmatch?:
      | null
      | Record<string, unknown>
      | {
          value: string | number | boolean;
      }
      | {
          text: 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?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
            | {
                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;
                };
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: 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)[];
            }
            | {
                nested: {
                    filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                    key: string;
                };
            })[];
        min_count: number;
    };
    must?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                key: string;
            };
        })[];
    must_not?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                key: string;
            };
        })[];
    should?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                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?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
            | {
                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;
                };
                key: string;
                match?:
                    | null
                    | Record<string, unknown>
                    | {
                        value: string | number | boolean;
                    }
                    | {
                        text: 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)[];
            }
            | {
                nested: {
                    filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                    key: string;
                };
            })[];
        min_count: number;
    };
    must?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                key: string;
            };
        })[];
    must_not?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                key: string;
            };
        })[];
    should?: null | (
        | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
        | {
            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;
            };
            key: string;
            match?:
                | null
                | Record<string, unknown>
                | {
                    value: string | number | boolean;
                }
                | {
                    text: 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)[];
        }
        | {
            nested: {
                filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                key: string;
            };
        })[];
}
A QdrantFilter.
- Optionalmin_should?: null | Record<string, unknown> | {
      conditions: (
          | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
          | {
              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;
              };
              key: string;
              match?:
                  | null
                  | Record<string, unknown>
                  | {
                      value: string | number | boolean;
                  }
                  | {
                      text: 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)[];
          }
          | {
              nested: {
                  filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
                  key: string;
              };
          })[];
      min_count: number;
  }
  Description
  At least minimum amount of given conditions should match
- Optionalmust?: null | (
      | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
      | {
          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;
          };
          key: string;
          match?:
              | null
              | Record<string, unknown>
              | {
                  value: string | number | boolean;
              }
              | {
                  text: 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)[];
      }
      | {
          nested: {
              filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
              key: string;
          };
      })[]
  Description
  All conditions must match
- Optionalmust_not?: null | (
      | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
      | {
          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;
          };
          key: string;
          match?:
              | null
              | Record<string, unknown>
              | {
                  value: string | number | boolean;
              }
              | {
                  text: 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)[];
      }
      | {
          nested: {
              filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
              key: string;
          };
      })[]
  Description
  All conditions must NOT match
- Optionalshould?: null | (
      | ({ should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...)
      | {
          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;
          };
          key: string;
          match?:
              | null
              | Record<string, unknown>
              | {
                  value: string | number | boolean;
              }
              | {
                  text: 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)[];
      }
      | {
          nested: {
              filter: { should?: (... | { key: string; match?: Record<string, unknown> | { value: string | number | boolean; } | { text: string; } | { any: string[] | number[]; } | { except: string[] | number[]; } | null | undefined; ... 4 more ...; values_count?: Record<...> | ... 2 more ... | undefined; } | { ...; } | { ...; } | { ...;...;
              key: string;
          };
      })[]
  Description
  At least one of those conditions should match
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

key: string

Description

Optionalmatch?: | null | Record<string, unknown> | { value: string | number | boolean; } | { text: 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

Description

Description

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

key: string

Description

Optionalmatch?: | null | Record<string, unknown> | { value: string | number | boolean; } | { text: 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

Description

Description

visitStructuredQuery

Parameters

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

Optionalfilter?: T["FilterType"]

Settings

On This Page

`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`match?:
| null
| Record<string, unknown>
| {
value: string | number | boolean;
}
| {
text: 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`match?:
| null
| Record<string, unknown>
| {
value: string | number | boolean;
}
| {
text: 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"]