@venizia/ignis 0.1.1-9 → 0.2.0-0

package/dist/connectors/search/controllers/definition.d.ts

@@ -1,263 +0,0 @@
-import type { TAuthMode, TAuthStrategy } from '../../../components/auth/authenticate/common/constants';
-import type { IAuthorizationSpec } from '../../../components/auth/authorize/common/types';
-import { z } from '@hono/zod-openapi';
-export declare const defineSearchRouteConfigs: (opts: {
-    selectSchema: z.ZodTypeAny;
-    authenticate?: {
-        strategies?: TAuthStrategy[];
-        mode?: TAuthMode;
-    };
-    authorize?: IAuthorizationSpec | IAuthorizationSpec[];
-}) => {
-    readonly SEARCH: {
-        readonly method: "post";
-        readonly path: "/search";
-        readonly description: "Single-collection search (keyword, semantic, hybrid, or raw passthrough)";
-        readonly authenticate: {
-            strategies?: TAuthStrategy[];
-            mode?: TAuthMode;
-        };
-        readonly authorize: IAuthorizationSpec<import("hono").Env, string, string> | IAuthorizationSpec<import("hono").Env, string, string>[] | undefined;
-        readonly request: {
-            readonly body: {
-                description: string;
-                content: {
-                    'application/json': {
-                        schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                            facetBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                            facetQuery: z.ZodOptional<z.ZodString>;
-                            maxFacetValues: z.ZodOptional<z.ZodNumber>;
-                            highlightFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                            highlightFullFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                            highlightStartTag: z.ZodOptional<z.ZodString>;
-                            highlightEndTag: z.ZodOptional<z.ZodString>;
-                            snippetThreshold: z.ZodOptional<z.ZodNumber>;
-                            groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                            groupLimit: z.ZodOptional<z.ZodNumber>;
-                            groupMissingValues: z.ZodOptional<z.ZodBoolean>;
-                            queryByWeights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-                            engineParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                            mode: z.ZodLiteral<"keyword">;
-                            query: z.ZodOptional<z.ZodString>;
-                            queryBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                            filter: z.ZodOptional<z.ZodObject<{
-                                where: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<any, string>>, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>]>>;
-                                fields: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodArray<z.ZodString>]>>;
-                                order: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                                limit: z.ZodOptional<z.ZodNumber>;
-                                offset: z.ZodOptional<z.ZodNumber>;
-                                skip: z.ZodOptional<z.ZodNumber>;
-                            }, z.core.$strip>>;
-                        }, z.core.$strip>, z.ZodObject<{
-                            distanceThreshold: z.ZodOptional<z.ZodNumber>;
-                            ef: z.ZodOptional<z.ZodNumber>;
-                            facetBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                            facetQuery: z.ZodOptional<z.ZodString>;
-                            maxFacetValues: z.ZodOptional<z.ZodNumber>;
-                            highlightFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                            highlightFullFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                            highlightStartTag: z.ZodOptional<z.ZodString>;
-                            highlightEndTag: z.ZodOptional<z.ZodString>;
-                            snippetThreshold: z.ZodOptional<z.ZodNumber>;
-                            groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                            groupLimit: z.ZodOptional<z.ZodNumber>;
-                            groupMissingValues: z.ZodOptional<z.ZodBoolean>;
-                            queryByWeights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-                            engineParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                            mode: z.ZodLiteral<"semantic">;
-                            vectorField: z.ZodString;
-                            nearVector: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-                            queryText: z.ZodOptional<z.ZodString>;
-                            k: z.ZodOptional<z.ZodNumber>;
-                            filter: z.ZodOptional<z.ZodObject<{
-                                where: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<any, string>>, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>]>>;
-                                fields: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodArray<z.ZodString>]>>;
-                                order: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                                limit: z.ZodOptional<z.ZodNumber>;
-                                offset: z.ZodOptional<z.ZodNumber>;
-                                skip: z.ZodOptional<z.ZodNumber>;
-                            }, z.core.$strip>>;
-                        }, z.core.$strip>, z.ZodObject<{
-                            distanceThreshold: z.ZodOptional<z.ZodNumber>;
-                            ef: z.ZodOptional<z.ZodNumber>;
-                            facetBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                            facetQuery: z.ZodOptional<z.ZodString>;
-                            maxFacetValues: z.ZodOptional<z.ZodNumber>;
-                            highlightFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                            highlightFullFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                            highlightStartTag: z.ZodOptional<z.ZodString>;
-                            highlightEndTag: z.ZodOptional<z.ZodString>;
-                            snippetThreshold: z.ZodOptional<z.ZodNumber>;
-                            groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                            groupLimit: z.ZodOptional<z.ZodNumber>;
-                            groupMissingValues: z.ZodOptional<z.ZodBoolean>;
-                            queryByWeights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-                            engineParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                            mode: z.ZodLiteral<"hybrid">;
-                            query: z.ZodString;
-                            queryBy: z.ZodArray<z.ZodString>;
-                            vectorField: z.ZodString;
-                            nearVector: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-                            alpha: z.ZodOptional<z.ZodNumber>;
-                            k: z.ZodOptional<z.ZodNumber>;
-                            filter: z.ZodOptional<z.ZodObject<{
-                                where: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<any, string>>, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>]>>;
-                                fields: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodArray<z.ZodString>]>>;
-                                order: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                                limit: z.ZodOptional<z.ZodNumber>;
-                                offset: z.ZodOptional<z.ZodNumber>;
-                                skip: z.ZodOptional<z.ZodNumber>;
-                            }, z.core.$strip>>;
-                        }, z.core.$strip>, z.ZodObject<{
-                            mode: z.ZodLiteral<"raw">;
-                            params: z.ZodRecord<z.ZodString, z.ZodAny>;
-                        }, z.core.$strip>], "mode">;
-                    };
-                };
-                required: boolean | undefined;
-            };
-        };
-        readonly responses: {
-            200: {
-                description: string;
-                content: {
-                    'application/json': {
-                        schema: z.ZodObject<{
-                            found: z.ZodNumber;
-                            isFoundExact: z.ZodBoolean;
-                            hits: z.ZodArray<z.ZodObject<{
-                                document: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-                            }, z.core.$strip>>;
-                        }, z.core.$strip>;
-                    };
-                };
-                required: boolean | undefined;
-            } | {
-                headers: never;
-                description: string;
-                content: {
-                    'application/json': {
-                        schema: z.ZodObject<{
-                            found: z.ZodNumber;
-                            isFoundExact: z.ZodBoolean;
-                            hits: z.ZodArray<z.ZodObject<{
-                                document: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-                            }, z.core.$strip>>;
-                        }, z.core.$strip>;
-                    };
-                };
-                required: boolean | undefined;
-            };
-            "4xx | 5xx": {
-                description: string;
-                content: {
-                    'application/json': {
-                        schema: z.ZodObject<{
-                            statusCode: z.ZodOptional<z.ZodNumber>;
-                            message: z.ZodString;
-                            normalized: z.ZodOptional<z.ZodObject<{
-                                text: z.ZodString;
-                                code: z.ZodString;
-                                args: z.ZodRecord<z.ZodString, z.ZodAny>;
-                            }, z.core.$strip>>;
-                            extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                            requestId: z.ZodOptional<z.ZodString>;
-                            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                        }, z.core.$strip>;
-                    };
-                };
-                required: boolean | undefined;
-            };
-        };
-    };
-    readonly MULTI_SEARCH: {
-        readonly method: "post";
-        readonly path: "/multi-search";
-        readonly description: "Cross-collection search, forwarded verbatim to the search engine";
-        readonly authenticate: {
-            strategies?: TAuthStrategy[];
-            mode?: TAuthMode;
-        };
-        readonly authorize: IAuthorizationSpec<import("hono").Env, string, string> | IAuthorizationSpec<import("hono").Env, string, string>[] | undefined;
-        readonly request: {
-            readonly body: {
-                description: string;
-                content: {
-                    'application/json': {
-                        schema: z.ZodObject<{
-                            searches: z.ZodArray<z.ZodObject<{
-                                facetBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                                facetQuery: z.ZodOptional<z.ZodString>;
-                                maxFacetValues: z.ZodOptional<z.ZodNumber>;
-                                highlightFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                                highlightFullFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                                highlightStartTag: z.ZodOptional<z.ZodString>;
-                                highlightEndTag: z.ZodOptional<z.ZodString>;
-                                snippetThreshold: z.ZodOptional<z.ZodNumber>;
-                                groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                                groupLimit: z.ZodOptional<z.ZodNumber>;
-                                groupMissingValues: z.ZodOptional<z.ZodBoolean>;
-                                queryByWeights: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-                                engineParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                                collection: z.ZodString;
-                                query: z.ZodOptional<z.ZodString>;
-                                queryBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                                filterBy: z.ZodOptional<z.ZodString>;
-                                sortBy: z.ZodOptional<z.ZodString>;
-                                page: z.ZodOptional<z.ZodNumber>;
-                                perPage: z.ZodOptional<z.ZodNumber>;
-                                offset: z.ZodOptional<z.ZodNumber>;
-                                includeFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                                excludeFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                                vectorQuery: z.ZodOptional<z.ZodString>;
-                            }, z.core.$strip>>;
-                            union: z.ZodOptional<z.ZodBoolean>;
-                        }, z.core.$strip>;
-                    };
-                };
-                required: boolean | undefined;
-            };
-        };
-        readonly responses: {
-            200: {
-                description: string;
-                content: {
-                    'application/json': {
-                        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                    };
-                };
-                required: boolean | undefined;
-            } | {
-                headers: never;
-                description: string;
-                content: {
-                    'application/json': {
-                        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                    };
-                };
-                required: boolean | undefined;
-            };
-            "4xx | 5xx": {
-                description: string;
-                content: {
-                    'application/json': {
-                        schema: z.ZodObject<{
-                            statusCode: z.ZodOptional<z.ZodNumber>;
-                            message: z.ZodString;
-                            normalized: z.ZodOptional<z.ZodObject<{
-                                text: z.ZodString;
-                                code: z.ZodString;
-                                args: z.ZodRecord<z.ZodString, z.ZodAny>;
-                            }, z.core.$strip>>;
-                            extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                            requestId: z.ZodOptional<z.ZodString>;
-                            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-                        }, z.core.$strip>;
-                    };
-                };
-                required: boolean | undefined;
-            };
-        };
-    };
-};
-//# sourceMappingURL=definition.d.ts.map

package/dist/connectors/search/controllers/definition.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../../src/connectors/search/controllers/definition.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AAChG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AACnF,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAItC,eAAO,MAAM,wBAAwB,GAAI,MAAM;IAC7C,YAAY,EAAE,CAAC,CAAC,UAAU,CAAC;IAC3B,YAAY,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,CAAA;KAAE,CAAC;IAClE,SAAS,CAAC,EAAE,kBAAkB,GAAG,kBAAkB,EAAE,CAAC;CACvD;;;;;;yBAF+B,aAAa,EAAE;mBAAS,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAjC,aAAa,EAAE;mBAAS,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDhE,CAAC"}

package/dist/connectors/search/controllers/definition.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineSearchRouteConfigs = void 0;
-const models_1 = require("../../../base/models");
-const zod_openapi_1 = require("@hono/zod-openapi");
-const ignis_helpers_1 = require("@venizia/ignis-helpers");
-const common_1 = require("../../../connectors/search/repositories/common");
-const defineSearchRouteConfigs = (opts) => {
-    const { selectSchema, authenticate, authorize } = opts;
-    const searchResponseSchema = zod_openapi_1.z.object({
-        found: zod_openapi_1.z.number(),
-        isFoundExact: zod_openapi_1.z
-            .boolean()
-            .openapi({ description: 'False when the engine reports `found` as an estimate.' }),
-        hits: zod_openapi_1.z.array(zod_openapi_1.z.object({ document: selectSchema })),
-    });
-    const multiSearchResponseSchema = zod_openapi_1.z.record(zod_openapi_1.z.string(), zod_openapi_1.z.unknown());
-    const resolvedAuthenticate = authenticate ?? {};
-    return {
-        SEARCH: {
-            method: ignis_helpers_1.HTTP.Methods.POST,
-            path: '/search',
-            description: 'Single-collection search (keyword, semantic, hybrid, or raw passthrough)',
-            authenticate: resolvedAuthenticate,
-            authorize,
-            request: {
-                body: (0, models_1.jsonContent)({
-                    description: 'Search input, discriminated by mode',
-                    schema: common_1.SearchInputSchema,
-                }),
-            },
-            responses: (0, models_1.jsonResponse)({
-                description: 'Search results',
-                schema: searchResponseSchema,
-            }),
-        },
-        MULTI_SEARCH: {
-            method: ignis_helpers_1.HTTP.Methods.POST,
-            path: '/multi-search',
-            description: 'Cross-collection search, forwarded verbatim to the search engine',
-            authenticate: resolvedAuthenticate,
-            authorize,
-            request: {
-                body: (0, models_1.jsonContent)({
-                    description: 'Multi-search input - one or more per-collection native search params',
-                    schema: common_1.MultiSearchInputSchema,
-                }),
-            },
-            responses: (0, models_1.jsonResponse)({
-                description: 'Federated (or, when union is true, merged) search results',
-                schema: multiSearchResponseSchema,
-            }),
-        },
-    };
-};
-exports.defineSearchRouteConfigs = defineSearchRouteConfigs;
-//# sourceMappingURL=definition.js.map

package/dist/connectors/search/controllers/definition.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../../src/connectors/search/controllers/definition.ts"],"names":[],"mappings":";;;AAAA,0CAA0D;AAG1D,mDAAsC;AACtC,0DAA8C;AAC9C,oEAAoG;AAE7F,MAAM,wBAAwB,GAAG,CAAC,IAIxC,EAAE,EAAE;IACH,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAEvD,MAAM,oBAAoB,GAAG,eAAC,CAAC,MAAM,CAAC;QACpC,KAAK,EAAE,eAAC,CAAC,MAAM,EAAE;QACjB,YAAY,EAAE,eAAC;aACZ,OAAO,EAAE;aACT,OAAO,CAAC,EAAE,WAAW,EAAE,uDAAuD,EAAE,CAAC;QACpF,IAAI,EAAE,eAAC,CAAC,KAAK,CAAC,eAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC,CAAC;KACpD,CAAC,CAAC;IAEH,MAAM,yBAAyB,GAAG,eAAC,CAAC,MAAM,CAAC,eAAC,CAAC,MAAM,EAAE,EAAE,eAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAEpE,MAAM,oBAAoB,GAAG,YAAY,IAAI,EAAE,CAAC;IAEhD,OAAO;QACL,MAAM,EAAE;YACN,MAAM,EAAE,oBAAI,CAAC,OAAO,CAAC,IAAI;YACzB,IAAI,EAAE,SAAS;YACf,WAAW,EAAE,0EAA0E;YACvF,YAAY,EAAE,oBAAoB;YAClC,SAAS;YACT,OAAO,EAAE;gBACP,IAAI,EAAE,IAAA,oBAAW,EAAC;oBAChB,WAAW,EAAE,qCAAqC;oBAClD,MAAM,EAAE,0BAAiB;iBAC1B,CAAC;aACH;YACD,SAAS,EAAE,IAAA,qBAAY,EAAC;gBACtB,WAAW,EAAE,gBAAgB;gBAC7B,MAAM,EAAE,oBAAoB;aAC7B,CAAC;SACH;QAED,YAAY,EAAE;YACZ,MAAM,EAAE,oBAAI,CAAC,OAAO,CAAC,IAAI;YACzB,IAAI,EAAE,eAAe;YACrB,WAAW,EAAE,kEAAkE;YAC/E,YAAY,EAAE,oBAAoB;YAClC,SAAS;YACT,OAAO,EAAE;gBACP,IAAI,EAAE,IAAA,oBAAW,EAAC;oBAChB,WAAW,EAAE,sEAAsE;oBACnF,MAAM,EAAE,+BAAsB;iBAC/B,CAAC;aACH;YACD,SAAS,EAAE,IAAA,qBAAY,EAAC;gBACtB,WAAW,EAAE,2DAA2D;gBACxE,MAAM,EAAE,yBAAyB;aAClC,CAAC;SACH;KACO,CAAC;AACb,CAAC,CAAC;AAxDW,QAAA,wBAAwB,4BAwDnC"}

package/dist/connectors/search/controllers/factory.d.ts

@@ -1,113 +0,0 @@
-import type { TEntityDataObject } from '../../../base/controllers';
-import type { AbstractEntity } from '../../../base/models';
-import type { TAuthMode, TAuthStrategy } from '../../../components/auth/authenticate/common/constants';
-import type { IAuthorizationSpec } from '../../../components/auth/authorize/common/types';
-import type { TAnyObjectSchema } from '../../../utilities/schema.utility';
-import type { TClass, TResolver, ValueOrPromise } from '@venizia/ignis-helpers';
-import { BaseHelper } from '@venizia/ignis-helpers';
-import type { Env, Schema } from 'hono';
-import type { ReadableSearchRepository } from '../repositories/core/readable';
-/** Per-route enable/disable switches for the generated search controller. */
-export interface ISearchCustomizableRoutes {
-    search?: {
-        enabled?: boolean;
-    };
-    multiSearch?: {
-        enabled?: boolean;
-    };
-}
-/** Configuration options for creating a search controller via SearchControllerFactory.defineSearchController. */
-export interface ISearchControllerOptions<TEntity extends AbstractEntity<TAnyObjectSchema> = AbstractEntity<TAnyObjectSchema>> {
-    /** Entity class or resolver returning it; its SELECT schema drives the `hits[].document` shape in the generated route's response. */
-    entity: TClass<TEntity> | TResolver<TClass<TEntity>>;
-    repository: {
-        name: string;
-    };
-    controller: {
-        name: string;
-        basePath: string;
-        isStrict?: boolean;
-    };
-    /** Authentication config applied to both generated routes. */
-    authenticate?: {
-        strategies?: TAuthStrategy[];
-        mode?: TAuthMode;
-    };
-    /** Authorization config applied to both generated routes. */
-    authorize?: IAuthorizationSpec | IAuthorizationSpec[];
-    /** Per-route enable/disable configuration. */
-    routes?: ISearchCustomizableRoutes;
-}
-/** Factory for generating turnkey search controllers (single-collection + cross-collection) from entity definitions. */
-export declare class SearchControllerFactory extends BaseHelper {
-    constructor();
-    /** Creates a search controller with two endpoints: `POST {basePath}/search` via `repository.search()`, and `POST {basePath}/multi-search` via `repository.dataSource.multiSearch()`. */
-    static defineSearchController<TEntity extends AbstractEntity<TAnyObjectSchema> = AbstractEntity<TAnyObjectSchema>, RouteEnv extends Env = Env, RouteSchema extends Schema = {}, BasePath extends string = '/', ConfigurableOptions extends object = {}, TDataObject extends object = TEntityDataObject<TEntity>>(defOpts: ISearchControllerOptions<TEntity>): {
-        new (repository: ReadableSearchRepository<TDataObject>): {
-            /** Registers the search + multiSearch route handlers, honoring per-route enable flags. */
-            binding(): ValueOrPromise<void>;
-            repository: ReadableSearchRepository<TDataObject, import("..").AbstractSearchDataSource<{}>>;
-            search(opts: {
-                context: import("../../../base/controllers").TRouteContext<RouteEnv>;
-            }): Promise<import("../../../base/controllers").TJsonResponse<unknown, 200>>;
-            multiSearch(opts: {
-                context: import("../../../base/controllers").TRouteContext<RouteEnv>;
-            }): Promise<import("../../../base/controllers").TJsonResponse<unknown, 200>>;
-            measure<R>(opts: {
-                scope: string;
-                args: unknown;
-                task: () => Promise<R>;
-            }): Promise<any>;
-            toHonoHandler<ResponseType = unknown>(opts: {
-                handler: import("../../../base/controllers").TRouteHandler<ResponseType, RouteEnv>;
-            }): import("hono").Handler<RouteEnv, string, import("hono").Input, (Response | Promise<Response>) | (import("@hono/zod-openapi").RouteConfigToTypedResponse<import("@hono/zod-openapi").RouteConfig> | Promise<import("@hono/zod-openapi").RouteConfigToTypedResponse<import("@hono/zod-openapi").RouteConfig>>)>;
-            bindRoute<RouteConfig extends import("../../../base/controllers").IAuthRouteConfig>(opts: {
-                configs: RouteConfig;
-            }): import("../../../base/controllers").IBindRouteOptions<RouteConfig, RouteEnv, RouteSchema, BasePath>;
-            defineRoute<RouteConfig extends import("../../../base/controllers").IAuthRouteConfig, ResponseType = unknown>(opts: {
-                configs: RouteConfig;
-                handler: import("../../../base/controllers").TRouteHandler<ResponseType, RouteEnv>;
-                hook?: import("@hono/zod-openapi").Hook<any, RouteEnv, string, any> | undefined;
-            }): import("../../../base/controllers").IDefineRouteOptions<RouteConfig, RouteEnv, RouteSchema, BasePath>;
-            defineJSXRoute<RouteConfig extends import("../../../base/controllers").IAuthRouteConfig, ResponseType = unknown>(opts: {
-                configs: RouteConfig;
-                handler: import("../../../base/controllers").TRouteHandler<ResponseType, RouteEnv>;
-                hook?: import("@hono/zod-openapi").Hook<any, RouteEnv, string, any> | undefined;
-            }): import("../../../base/controllers").IDefineRouteOptions<RouteConfig, RouteEnv, RouteSchema, BasePath>;
-            isConfigured: boolean;
-            router: import("@hono/zod-openapi").OpenAPIHono<RouteEnv, RouteSchema, BasePath>;
-            path: string;
-            definitions: Record<string, import("../../../base/controllers").IAuthRouteConfig>;
-            getRouter(): import("@hono/zod-openapi").OpenAPIHono<RouteEnv, RouteSchema, BasePath>;
-            registerRoutesFromRegistry(opts?: {
-                paths?: "static" | "param" | "all";
-            }): void;
-            configure(opts?: ConfigurableOptions | undefined): Promise<import("@hono/zod-openapi").OpenAPIHono<RouteEnv, RouteSchema, BasePath>>;
-            buildRouteMiddlewares<RouteConfig extends import("../../../base/controllers").IAuthRouteConfig>(opts: {
-                configs: RouteConfig;
-            }): {
-                restConfig: Omit<RouteConfig, "authenticate" | "authorize">;
-                security: {
-                    [x: string]: never[];
-                }[];
-                mws: import("hono").MiddlewareHandler<Env>[];
-            };
-            getRouteConfigs<RouteConfig extends import("../../../base/controllers").IAuthRouteConfig>(opts: {
-                configs: RouteConfig;
-            }): RouteConfig & {
-                getRoutingPath(): RouteConfig["path"] extends infer T ? T extends RouteConfig["path"] ? T extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${/*elided*/ any}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : T : never : never;
-            };
-            getJSXRouteConfigs<RouteConfig extends import("../../../base/controllers").IAuthRouteConfig>(opts: {
-                configs: RouteConfig;
-            }): RouteConfig & {
-                getRoutingPath(): RouteConfig["path"] extends infer T ? T extends RouteConfig["path"] ? T extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${Tail extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${/*elided*/ any}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : Tail}` : T : never : never;
-            };
-            scope: string;
-            identifier: string;
-            logger: import("@venizia/ignis-helpers").ILogger;
-            getIdentifier(): string;
-            getLogger(): import("@venizia/ignis-helpers").ILogger;
-        };
-    };
-}
-//# sourceMappingURL=factory.d.ts.map

package/dist/connectors/search/controllers/factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/connectors/search/controllers/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AAChG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAChF,OAAO,EAAE,UAAU,EAAY,MAAM,wBAAwB,CAAC;AAE9D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACxC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAI9E,6EAA6E;AAC7E,MAAM,WAAW,yBAAyB;IACxC,MAAM,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC/B,WAAW,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACrC;AAED,iHAAiH;AACjH,MAAM,WAAW,wBAAwB,CACvC,OAAO,SAAS,cAAc,CAAC,gBAAgB,CAAC,GAAG,cAAc,CAAC,gBAAgB,CAAC;IAEnF,qIAAqI;IACrI,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IAErD,UAAU,EAAE;QACV,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IAEF,UAAU,EAAE;QACV,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB,CAAC;IAEF,8DAA8D;IAC9D,YAAY,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,SAAS,CAAA;KAAE,CAAC;IAElE,6DAA6D;IAC7D,SAAS,CAAC,EAAE,kBAAkB,GAAG,kBAAkB,EAAE,CAAC;IAEtD,8CAA8C;IAC9C,MAAM,CAAC,EAAE,yBAAyB,CAAC;CACpC;AAED,wHAAwH;AACxH,qBAAa,uBAAwB,SAAQ,UAAU;;IAKrD,wLAAwL;IACxL,MAAM,CAAC,sBAAsB,CAC3B,OAAO,SAAS,cAAc,CAAC,gBAAgB,CAAC,GAAG,cAAc,CAAC,gBAAgB,CAAC,EACnF,QAAQ,SAAS,GAAG,GAAG,GAAG,EAC1B,WAAW,SAAS,MAAM,GAAG,EAAE,EAC/B,QAAQ,SAAS,MAAM,GAAG,GAAG,EAC7B,mBAAmB,SAAS,MAAM,GAAG,EAAE,EACvC,WAAW,SAAS,MAAM,GAAG,iBAAiB,CAAC,OAAO,CAAC,EACvD,OAAO,EAAE,wBAAwB,CAAC,OAAO,CAAC;yBAwBhB,wBAAwB,CAAC,WAAW,CAAC;YAU7D,0FAA0F;uBACtE,cAAc,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAhCvC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDP"}

package/dist/connectors/search/controllers/factory.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SearchControllerFactory = void 0;
-const models_1 = require("../../../base/models");
-const ignis_helpers_1 = require("@venizia/ignis-helpers");
-const ignis_inversion_1 = require("@venizia/ignis-inversion");
-const abstract_1 = require("./abstract");
-const definition_1 = require("./definition");
-/** Factory for generating turnkey search controllers (single-collection + cross-collection) from entity definitions. */
-class SearchControllerFactory extends ignis_helpers_1.BaseHelper {
-    constructor() {
-        super({ scope: SearchControllerFactory.name });
-    }
-    /** Creates a search controller with two endpoints: `POST {basePath}/search` via `repository.search()`, and `POST {basePath}/multi-search` via `repository.dataSource.multiSearch()`. */
-    static defineSearchController(defOpts) {
-        const { controller, entity, authenticate, authorize, routes } = defOpts;
-        const { name, basePath = 'unknown_path', isStrict = true } = controller;
-        if (!basePath || basePath === 'unknown_path') {
-            throw (0, ignis_helpers_1.getError)({
-                message: `[defineSearchController] Invalid controller basePath | name: ${name} | basePath: ${basePath}`,
-            });
-        }
-        const entityClass = (0, ignis_inversion_1.isClass)(entity) ? entity : entity();
-        const entityInstance = new entityClass();
-        const selectSchema = entityInstance.getSchema({ type: models_1.SchemaTypes.SELECT });
-        const routeDefinitions = (0, definition_1.defineSearchRouteConfigs)({ selectSchema, authenticate, authorize });
-        const controllerClass = class extends abstract_1.AbstractSearchController {
-            constructor(repository) {
-                super({
-                    scope: name,
-                    path: basePath,
-                    isStrict,
-                    repository,
-                    definitions: routeDefinitions,
-                });
-            }
-            /** Registers the search + multiSearch route handlers, honoring per-route enable flags. */
-            binding() {
-                const isEnabled = (routeKey) => {
-                    return routes?.[routeKey]?.enabled !== false;
-                };
-                if (isEnabled('search')) {
-                    this.defineRoute({
-                        configs: routeDefinitions.SEARCH,
-                        handler: async (context) => this.search({ context }),
-                    });
-                }
-                if (isEnabled('multiSearch')) {
-                    this.defineRoute({
-                        configs: routeDefinitions.MULTI_SEARCH,
-                        handler: async (context) => this.multiSearch({ context }),
-                    });
-                }
-            }
-        };
-        Object.defineProperty(controllerClass, 'name', { value: name, configurable: true });
-        return controllerClass;
-    }
-}
-exports.SearchControllerFactory = SearchControllerFactory;
-//# sourceMappingURL=factory.js.map

package/dist/connectors/search/controllers/factory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../../../src/connectors/search/controllers/factory.ts"],"names":[],"mappings":";;;AAEA,0CAA4C;AAK5C,0DAA8D;AAC9D,8DAAmD;AAGnD,yCAAsD;AACtD,6CAAwD;AAmCxD,wHAAwH;AACxH,MAAa,uBAAwB,SAAQ,0BAAU;IACrD;QACE,KAAK,CAAC,EAAE,KAAK,EAAE,uBAAuB,CAAC,IAAI,EAAE,CAAC,CAAC;IACjD,CAAC;IAED,wLAAwL;IACxL,MAAM,CAAC,sBAAsB,CAO3B,OAA0C;QAC1C,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;QAExE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,cAAc,EAAE,QAAQ,GAAG,IAAI,EAAE,GAAG,UAAU,CAAC;QACxE,IAAI,CAAC,QAAQ,IAAI,QAAQ,KAAK,cAAc,EAAE,CAAC;YAC7C,MAAM,IAAA,wBAAQ,EAAC;gBACb,OAAO,EAAE,gEAAgE,IAAI,gBAAgB,QAAQ,EAAE;aACxG,CAAC,CAAC;QACL,CAAC;QAED,MAAM,WAAW,GAAG,IAAA,yBAAO,EAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QACxD,MAAM,cAAc,GAAG,IAAI,WAAW,EAAE,CAAC;QAEzC,MAAM,YAAY,GAAG,cAAc,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,oBAAW,CAAC,MAAM,EAAE,CAAC,CAAC;QAC5E,MAAM,gBAAgB,GAAG,IAAA,qCAAwB,EAAC,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,CAAC,CAAC;QAE7F,MAAM,eAAe,GAAG,KAAM,SAAQ,mCAOrC;YACC,YAAY,UAAiD;gBAC3D,KAAK,CAAC;oBACJ,KAAK,EAAE,IAAI;oBACX,IAAI,EAAE,QAAQ;oBACd,QAAQ;oBACR,UAAU;oBACV,WAAW,EAAE,gBAAgB;iBAC9B,CAAC,CAAC;YACL,CAAC;YAED,0FAA0F;YACjF,OAAO;gBACd,MAAM,SAAS,GAAG,CAAC,QAAyC,EAAE,EAAE;oBAC9D,OAAO,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,OAAO,KAAK,KAAK,CAAC;gBAC/C,CAAC,CAAC;gBAEF,IAAI,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACxB,IAAI,CAAC,WAAW,CAAC;wBACf,OAAO,EAAE,gBAAgB,CAAC,MAAM;wBAChC,OAAO,EAAE,KAAK,EAAC,OAAO,EAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;qBACnD,CAAC,CAAC;gBACL,CAAC;gBAED,IAAI,SAAS,CAAC,aAAa,CAAC,EAAE,CAAC;oBAC7B,IAAI,CAAC,WAAW,CAAC;wBACf,OAAO,EAAE,gBAAgB,CAAC,YAAY;wBACtC,OAAO,EAAE,KAAK,EAAC,OAAO,EAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,CAAC;qBACxD,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;SACF,CAAC;QAEF,MAAM,CAAC,cAAc,CAAC,eAAe,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;QACpF,OAAO,eAAe,CAAC;IACzB,CAAC;CACF;AAxED,0DAwEC"}

package/dist/connectors/search/datasources/abstract.d.ts

@@ -1,23 +0,0 @@
-import { AbstractDataSource } from '../../../base/datasources';
-import type { ISearchConnector } from '../../../connectors/search/connector';
-import type { ISearchCollectionDefinition, TSearchSchema } from '../../../connectors/search/models';
-import type { ISearchQueryDialect, TMultiSearchEntry } from '../../../connectors/search/repositories/common';
-/** Engine contract only (connector, dialect, collection compile/ensure) - mirrors AbstractPostgresDataSource. Discovery/provisioning lives on BaseSearchDataSource. */
-export declare abstract class AbstractSearchDataSource<Settings extends object = {}> extends AbstractDataSource<Settings, TSearchSchema> {
-    abstract getConnector(): ISearchConnector;
-    abstract getQueryDialect(): ISearchQueryDialect;
-    abstract compileCollection(opts: {
-        definition: ISearchCollectionDefinition;
-    }): unknown;
-    abstract ensureCollection(opts: {
-        definition: ISearchCollectionDefinition;
-    }): Promise<void>;
-    /** Cross-collection search. Return is `unknown` because each engine's envelope differs (Typesense union, Meilisearch federation) and a concrete datasource narrows it; declared here so a datasource-generic repository can read it. */
-    abstract multiSearch(opts: {
-        searches: TMultiSearchEntry[];
-        union?: boolean;
-        commonParams?: Omit<TMultiSearchEntry, 'collection'>;
-        options?: unknown;
-    }): Promise<unknown>;
-}
-//# sourceMappingURL=abstract.d.ts.map

package/dist/connectors/search/datasources/abstract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"abstract.d.ts","sourceRoot":"","sources":["../../../../src/connectors/search/datasources/abstract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,KAAK,EAAE,2BAA2B,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC7F,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,yCAAyC,CAAC;AAEjD,uKAAuK;AACvK,8BAAsB,wBAAwB,CAC5C,QAAQ,SAAS,MAAM,GAAG,EAAE,CAC5B,SAAQ,kBAAkB,CAAC,QAAQ,EAAE,aAAa,CAAC;IACnD,QAAQ,CAAC,YAAY,IAAI,gBAAgB;IAEzC,QAAQ,CAAC,eAAe,IAAI,mBAAmB;IAE/C,QAAQ,CAAC,iBAAiB,CAAC,IAAI,EAAE;QAAE,UAAU,EAAE,2BAA2B,CAAA;KAAE,GAAG,OAAO;IACtF,QAAQ,CAAC,gBAAgB,CAAC,IAAI,EAAE;QAAE,UAAU,EAAE,2BAA2B,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAE3F,wOAAwO;IACxO,QAAQ,CAAC,WAAW,CAAC,IAAI,EAAE;QACzB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;QAC9B,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,YAAY,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC;QACrD,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,GAAG,OAAO,CAAC,OAAO,CAAC;CACrB"}

package/dist/connectors/search/datasources/abstract.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractSearchDataSource = void 0;
-const datasources_1 = require("../../../base/datasources");
-/** Engine contract only (connector, dialect, collection compile/ensure) - mirrors AbstractPostgresDataSource. Discovery/provisioning lives on BaseSearchDataSource. */
-class AbstractSearchDataSource extends datasources_1.AbstractDataSource {
-}
-exports.AbstractSearchDataSource = AbstractSearchDataSource;
-//# sourceMappingURL=abstract.js.map

package/dist/connectors/search/datasources/abstract.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"abstract.js","sourceRoot":"","sources":["../../../../src/connectors/search/datasources/abstract.ts"],"names":[],"mappings":";;;AAAA,oDAAwD;AAQxD,uKAAuK;AACvK,MAAsB,wBAEpB,SAAQ,gCAA2C;CAepD;AAjBD,4DAiBC"}

package/dist/connectors/search/datasources/base.d.ts

@@ -1,47 +0,0 @@
-import type { ISearchConnector } from '../../../connectors/search/connector';
-import type { ISearchCollectionDefinition, TSearchSchema } from '../../../connectors/search/models';
-import type { ISearchDataSourceOptions } from '../../../connectors/search/datasources/common';
-import type { TMultiSearchEntry } from '../../../connectors/search/repositories/common';
-import { AbstractSearchDataSource } from './abstract';
-/** Collection discovery/provisioning + connector lifecycle, mirroring BasePostgresDataSource. Paradigm seam: the connector is held via the `ISearchConnector`-bounded generic, never an engine type - engines supply only `createConnector()`. */
-export declare abstract class BaseSearchDataSource<Settings extends object = {}, TConnector extends ISearchConnector = ISearchConnector> extends AbstractSearchDataSource<Settings> {
-    protected autoProvision: boolean;
-    protected hiddenFieldsByCollectionMap?: Record<string, string[]>;
-    protected connector?: TConnector;
-    private readonly injectedConnector?;
-    constructor(opts: ISearchDataSourceOptions<Settings> & {
-        connector?: TConnector;
-    });
-    /** The engine's connector instance - the ONLY engine-specific step of the lifecycle. */
-    protected abstract createConnector(): TConnector;
-    /** Builds the connector (unless injected, e.g. for tests), then provisions collections. Re-entrant-safe: a second call is a logged no-op, not a re-provision. */
-    configure(): Promise<void>;
-    getConnector(): TConnector;
-    /** Auto-discovers collections from repositories if not manually provided. */
-    getSchema(): TSearchSchema;
-    hasDiscoverableModels(): boolean;
-    /** Cross-collection, so it lives on the datasource, not a repository; the envelope is engine-specific, so the return is `unknown` and `TypesenseDataSource` narrows it. */
-    multiSearch(opts: {
-        searches: TMultiSearchEntry[];
-        union?: boolean;
-        commonParams?: Omit<TMultiSearchEntry, 'collection'>;
-        options?: unknown;
-    }): Promise<unknown>;
-    /** Reads `static searchCollection`, falling back to shape-guarded `static schema`; honors `@datasource({ autoDiscovery: false })` same as the postgres branch. */
-    protected discoverCollections(): TSearchSchema;
-    /** Reads a bound model class's collection definition - dual-schema `searchCollection` first, then shape-guarded `schema`; undefined when it carries neither. */
-    private readCollectionDefinition;
-    /** Collection name -> `@model` hiddenProperties for cross-collection operations. Collections with none are omitted, so callers own exclusion for absent entries; memoized per instance and never invalidated because the metadata is frozen after boot. */
-    protected hiddenFieldsByCollection(): Record<string, string[]>;
-    /** The registry/model walk behind `hiddenFieldsByCollection` - mirrors the `getSchema()` / `discoverCollections()` split. */
-    protected discoverHiddenFieldsByCollection(): Record<string, string[]>;
-    /** Unions a collection's hidden fields into one multiSearch entry's excludeFields; an entry whose collection is not a discovered definition passes through untouched - the caller owns exclusion there. */
-    private applyHiddenExclusion;
-    /** Provisions discovered collections via ensureCollection (additive-only; destructive migration is caller policy). Skipped if autoProvision is false; failures propagate so boot fails loudly. */
-    protected provisionCollections(): Promise<void>;
-    /** Engines expose synonyms as named linkable sets, a flat per-collection dictionary, or neither - both groups are optional on `ISearchConnector`, hence the branch. */
-    protected provisionSynonyms(opts: {
-        definition: ISearchCollectionDefinition;
-    }): Promise<void>;
-}
-//# sourceMappingURL=base.d.ts.map

package/dist/connectors/search/datasources/base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/connectors/search/datasources/base.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,KAAK,EAAE,2BAA2B,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE7F,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AACvF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yCAAyC,CAAC;AAGjF,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAkBtD,kPAAkP;AAClP,8BAAsB,oBAAoB,CACxC,QAAQ,SAAS,MAAM,GAAG,EAAE,EAC5B,UAAU,SAAS,gBAAgB,GAAG,gBAAgB,CACtD,SAAQ,wBAAwB,CAAC,QAAQ,CAAC;IAC1C,SAAS,CAAC,aAAa,EAAE,OAAO,CAAC;IACjC,SAAS,CAAC,2BAA2B,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACjE,SAAS,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC;IAEjC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAa;gBAEpC,IAAI,EAAE,wBAAwB,CAAC,QAAQ,CAAC,GAAG;QAAE,SAAS,CAAC,EAAE,UAAU,CAAA;KAAE;IAejF,wFAAwF;IACxF,SAAS,CAAC,QAAQ,CAAC,eAAe,IAAI,UAAU;IAEhD,iKAAiK;IAC3J,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAahC,YAAY,IAAI,UAAU;IAU1B,6EAA6E;IACpE,SAAS,IAAI,aAAa;IAOnC,qBAAqB,IAAI,OAAO;IAKhC,2KAA2K;IAC3K,WAAW,CAAC,IAAI,EAAE;QAChB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;QAC9B,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,YAAY,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC;QACrD,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,GAAG,OAAO,CAAC,OAAO,CAAC;IAwBpB,kKAAkK;IAClK,SAAS,CAAC,mBAAmB,IAAI,aAAa;IAO9C,gKAAgK;IAChK,OAAO,CAAC,wBAAwB;IAYhC,2PAA2P;IAC3P,SAAS,CAAC,wBAAwB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAK9D,6HAA6H;IAC7H,SAAS,CAAC,gCAAgC,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAoBtE,2MAA2M;IAC3M,OAAO,CAAC,oBAAoB;IAe5B,kMAAkM;cAClL,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC;IA0BrD,uKAAuK;cACvJ,iBAAiB,CAAC,IAAI,EAAE;QACtC,UAAU,EAAE,2BAA2B,CAAC;KACzC,GAAG,OAAO,CAAC,IAAI,CAAC;CA6BlB"}