@onyx.dev/onyx-database 1.0.3 → 1.2.0

package/dist/{aggregates-BGXzij4U.d.ts → aggregates-LoteczVS.d.ts}

@@ -7,6 +7,11 @@
  * ```
  */
 type QueryCriteriaOperator = 'EQUAL' | 'NOT_EQUAL' | 'IN' | 'NOT_IN' | 'GREATER_THAN' | 'GREATER_THAN_EQUAL' | 'LESS_THAN' | 'LESS_THAN_EQUAL' | 'MATCHES' | 'NOT_MATCHES' | 'BETWEEN' | 'LIKE' | 'NOT_LIKE' | 'CONTAINS' | 'CONTAINS_IGNORE_CASE' | 'NOT_CONTAINS' | 'NOT_CONTAINS_IGNORE_CASE' | 'STARTS_WITH' | 'NOT_STARTS_WITH' | 'IS_NULL' | 'NOT_NULL';
+/** Value payload for full-text (Lucene) searches. */
+interface FullTextQuery {
+    queryText: string;
+    minScore: number | null;
+}
 /** Logical operator used to join conditions in a query. */
 type LogicalOperator = 'AND' | 'OR';
 /**
@@ -133,6 +138,7 @@ type QueryCondition = {
  */
 interface SelectQuery {
     type: 'SelectQuery';
+    table?: string | null;
     fields?: string[] | null;
     conditions?: QueryCondition | null;
     sort?: Sort[] | null;
@@ -473,6 +479,16 @@ interface IQueryBuilder<T = unknown> {
      * ```
      */
     resolve(...values: Array<string | string[]>): IQueryBuilder<T>;
+    /**
+     * Adds a Lucene full-text search predicate.
+     * @example
+     * ```ts
+     * const results = await db.from('User').search('hello world', 4.4).list();
+     * ```
+     * @param queryText - Text to match against `__full_text__`.
+     * @param minScore - Optional minimum score; serializes as `null` when omitted.
+     */
+    search(queryText: string, minScore?: number | null): IQueryBuilder<T>;
     /**
      * Adds a filter condition.
      * @example
@@ -798,6 +814,10 @@ interface RetryOptions {
 }
 interface OnyxConfig {
     baseUrl?: string;
+    /**
+     * Base URL for AI endpoints. Defaults to https://ai.onyx.dev.
+     */
+    aiBaseUrl?: string;
     databaseId?: string;
     apiKey?: string;
     apiSecret?: string;
@@ -824,7 +844,187 @@ interface OnyxConfig {
      */
     retry?: RetryOptions;
 }
+interface AiRequestOptions {
+    /**
+     * Optional database scope for AI calls. Defaults to the configured databaseId.
+     */
+    databaseId?: string;
+}
+type AiChatRole = 'system' | 'user' | 'assistant' | 'tool';
+interface AiToolCallFunction {
+    name: string;
+    arguments: string;
+}
+interface AiToolCall {
+    id?: string | null;
+    type?: string | null;
+    function: AiToolCallFunction;
+}
+interface AiChatMessage {
+    role: AiChatRole;
+    content?: string | null;
+    tool_calls?: AiToolCall[] | null;
+    tool_call_id?: string | null;
+    name?: string | null;
+}
+interface AiToolFunction {
+    name: string;
+    description?: string | null;
+    parameters?: Record<string, unknown> | null;
+}
+interface AiTool {
+    type: string;
+    function: AiToolFunction;
+}
+type AiToolChoice = 'none' | 'auto' | {
+    type: 'function';
+    function: {
+        name: string;
+    };
+} | null;
+interface AiChatCompletionRequest {
+    model: string;
+    messages: AiChatMessage[];
+    stream?: boolean;
+    temperature?: number | null;
+    top_p?: number | null;
+    max_tokens?: number | null;
+    metadata?: Record<string, unknown>;
+    tools?: AiTool[];
+    tool_choice?: AiToolChoice;
+    user?: string | null;
+}
+interface AiChatCompletionUsage {
+    prompt_tokens?: number | null;
+    completion_tokens?: number | null;
+    total_tokens?: number | null;
+}
+interface AiChatCompletionChoice {
+    index: number;
+    message: AiChatMessage;
+    finish_reason?: string | null;
+}
+interface AiChatCompletionResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: AiChatCompletionChoice[];
+    usage?: AiChatCompletionUsage;
+}
+interface AiChatCompletionChunkDelta {
+    role?: AiChatRole | null;
+    content?: string | null;
+    tool_calls?: AiToolCall[] | null;
+    tool_call_id?: string | null;
+    name?: string | null;
+}
+interface AiChatCompletionChunkChoice {
+    index: number;
+    delta: AiChatCompletionChunkDelta;
+    finish_reason?: string | null;
+}
+interface AiChatCompletionChunk {
+    id: string;
+    object: string;
+    created: number;
+    model?: string | null;
+    choices: AiChatCompletionChunkChoice[];
+}
+interface AiChatCompletionStream extends AsyncIterable<AiChatCompletionChunk> {
+    cancel(): void;
+}
+interface AiChatClient {
+    create(request: AiChatCompletionRequest & {
+        stream?: false;
+    }, options?: AiRequestOptions): Promise<AiChatCompletionResponse>;
+    create(request: AiChatCompletionRequest & {
+        stream: true;
+    }, options?: AiRequestOptions): Promise<AiChatCompletionStream>;
+    create(request: AiChatCompletionRequest, options?: AiRequestOptions): Promise<AiChatCompletionResponse | AiChatCompletionStream>;
+}
+interface AiScriptApprovalRequest {
+    script: string;
+}
+interface AiScriptApprovalResponse {
+    normalizedScript: string;
+    expiresAtIso: string;
+    requiresApproval: boolean;
+    findings?: string;
+}
+interface AiModelsResponse {
+    object: string;
+    data: AiModel[];
+}
+interface AiModel {
+    id: string;
+    object: string;
+    created: number;
+    owned_by: string;
+}
+interface AiErrorResponse {
+    error?: string | {
+        message?: string;
+        [key: string]: unknown;
+    } | null;
+}
 interface IOnyxDatabase<Schema = Record<string, unknown>> {
+    /**
+     * Access OpenAI-compatible chat completions.
+     *
+     * @example
+     * ```ts
+     * const chat = db.chat();
+     * const completion = await chat.create({
+     *   model: 'onyx-chat',
+     *   messages: [{ role: 'user', content: 'Summarize last week.' }],
+     * });
+     * ```
+     *
+     * @example
+     * ```ts
+     * const stream = await db
+     *   .chat()
+     *   .create({
+     *     model: 'onyx-chat',
+     *     stream: true,
+     *     messages: [{ role: 'user', content: 'Draft an onboarding checklist.' }],
+     *   });
+     * for await (const chunk of stream) {
+     *   process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
+     * }
+     * ```
+     */
+    chat(): AiChatClient;
+    /**
+     * List available AI models.
+     *
+     * @example
+     * ```ts
+     * const models = await db.getModels();
+     * ```
+     */
+    getModels(): Promise<AiModelsResponse>;
+    /**
+     * Retrieve a single AI model by ID.
+     *
+     * @example
+     * ```ts
+     * const model = await db.getModel('onyx-chat');
+     * ```
+     */
+    getModel(modelId: string): Promise<AiModel>;
+    /**
+     * Request mutation approval for a script.
+     *
+     * @example
+     * ```ts
+     * const approval = await db.requestScriptApproval({
+     *   script: "db.save({ id: 'u1', email: 'a@b.com' })"
+     * });
+     * ```
+     */
+    requestScriptApproval(input: AiScriptApprovalRequest): Promise<AiScriptApprovalResponse>;
     /**
      * Begin a query against a table.
      *
@@ -861,6 +1061,18 @@ interface IOnyxDatabase<Schema = Record<string, unknown>> {
      * @param fields Field names to project; omit to select all.
      */
     select(...fields: string[]): IQueryBuilder<Record<string, unknown>>;
+    /**
+     * Run a Lucene full-text search across all tables.
+     *
+     * @example
+     * ```ts
+     * const results = await db.search('hello world', 4.4).list();
+     * ```
+     *
+     * @param queryText Text to match against `__full_text__`.
+     * @param minScore Optional minimum score; serialized as `null` when omitted.
+     */
+    search(queryText: string, minScore?: number | null): IQueryBuilder<Record<string, unknown>>;
     /**
      * Include related records in the next save or delete.
      *
@@ -1395,6 +1607,7 @@ declare const gte: (field: string, value: unknown) => ConditionBuilderImpl;
 declare const lt: (field: string, value: unknown) => ConditionBuilderImpl;
 declare const lte: (field: string, value: unknown) => ConditionBuilderImpl;
 declare const matches: (field: string, regex: string) => ConditionBuilderImpl;
+declare const search: (queryText: string, minScore?: number | null) => ConditionBuilderImpl;
 declare const notMatches: (field: string, regex: string) => ConditionBuilderImpl;
 declare const like: (field: string, pattern: string) => ConditionBuilderImpl;
 declare const notLike: (field: string, pattern: string) => ConditionBuilderImpl;
@@ -1421,4 +1634,4 @@ declare const substring: (attribute: string, from: number, length: number) => st
 declare const replace: (attribute: string, pattern: string, repl: string) => string;
 declare const percentile: (attribute: string, p: number) => string;
 
-export { within as $, type QueryCriteriaOperator as A, type Sort as B, type StreamAction as C, type OnyxDocument as D, type FetchImpl as E, type FetchResponse as F, type QueryCriteria as G, type QueryCondition as H, type IOnyxDatabase as I, type SelectQuery as J, type QueryPage as K, type LogicalOperator as L, type IConditionBuilder as M, type IQueryBuilder as N, type OnyxFacade as O, type ISaveBuilder as P, QueryResults as Q, type RetryOptions as R, type SecretMetadata as S, type ICascadeBuilder as T, type UpdateQuery as U, type ICascadeRelationshipBuilder as V, asc as W, desc as X, eq as Y, neq as Z, inOp as _, type QueryResultsPromise as a, notIn as a0, notWithin as a1, between as a2, gt as a3, gte as a4, lt as a5, lte as a6, matches as a7, notMatches as a8, like as a9, notLike as aa, contains as ab, containsIgnoreCase as ac, notContains as ad, notContainsIgnoreCase as ae, startsWith as af, notStartsWith as ag, isNull as ah, notNull as ai, avg as aj, sum as ak, count as al, min as am, max as an, std as ao, variance as ap, median as aq, upper as ar, lower as as, substring as at, replace as au, percentile as av, type OnyxConfig as b, type SecretRecord as c, type SecretsListResponse as d, type SecretSaveRequest as e, type SchemaDataType as f, type SchemaIdentifierGenerator as g, type SchemaIdentifier as h, type SchemaAttribute as i, type SchemaIndexType as j, type SchemaIndex as k, type SchemaResolver as l, type SchemaTriggerEvent as m, type SchemaTrigger as n, type SchemaEntity as o, type SchemaRevisionMetadata as p, type SchemaRevision as q, type SchemaHistoryEntry as r, type SchemaUpsertRequest as s, type SchemaValidationResult as t, type SchemaAttributeChange as u, type SchemaIndexChange as v, type SchemaResolverChange as w, type SchemaTriggerChange as x, type SchemaTableDiff as y, type SchemaDiff as z };
+export { type SchemaDiff as $, type AiRequestOptions as A, type SchemaDataType as B, type SchemaIdentifierGenerator as C, type SchemaIdentifier as D, type SchemaAttribute as E, type FullTextQuery as F, type SchemaIndexType as G, type SchemaIndex as H, type IOnyxDatabase as I, type SchemaResolver as J, type SchemaTriggerEvent as K, type SchemaTrigger as L, type SchemaEntity as M, type SchemaRevisionMetadata as N, type OnyxFacade as O, type SchemaRevision as P, QueryResults as Q, type RetryOptions as R, type SecretMetadata as S, type SchemaHistoryEntry as T, type SchemaUpsertRequest as U, type SchemaValidationResult as V, type SchemaAttributeChange as W, type SchemaIndexChange as X, type SchemaResolverChange as Y, type SchemaTriggerChange as Z, type SchemaTableDiff as _, type QueryResultsPromise as a, type QueryCriteriaOperator as a0, type LogicalOperator as a1, type Sort as a2, type StreamAction as a3, type OnyxDocument as a4, type FetchResponse as a5, type FetchImpl as a6, type QueryCriteria as a7, type QueryCondition as a8, type SelectQuery as a9, containsIgnoreCase as aA, notContains as aB, notContainsIgnoreCase as aC, startsWith as aD, notStartsWith as aE, isNull as aF, notNull as aG, avg as aH, sum as aI, count as aJ, min as aK, max as aL, std as aM, variance as aN, median as aO, upper as aP, lower as aQ, substring as aR, replace as aS, percentile as aT, type UpdateQuery as aa, type QueryPage as ab, type IConditionBuilder as ac, type IQueryBuilder as ad, type ISaveBuilder as ae, type ICascadeBuilder as af, type ICascadeRelationshipBuilder as ag, asc as ah, desc as ai, eq as aj, neq as ak, inOp as al, within as am, notIn as an, notWithin as ao, between as ap, gt as aq, gte as ar, lt as as, lte as at, matches as au, search as av, notMatches as aw, like as ax, notLike as ay, contains as az, type OnyxConfig as b, type AiChatRole as c, type AiToolCallFunction as d, type AiToolCall as e, type AiChatMessage as f, type AiToolFunction as g, type AiTool as h, type AiToolChoice as i, type AiChatCompletionRequest as j, type AiChatCompletionUsage as k, type AiChatCompletionChoice as l, type AiChatCompletionResponse as m, type AiChatCompletionChunkDelta as n, type AiChatCompletionChunkChoice as o, type AiChatCompletionChunk as p, type AiChatCompletionStream as q, type AiChatClient as r, type AiScriptApprovalRequest as s, type AiScriptApprovalResponse as t, type AiModelsResponse as u, type AiModel as v, type AiErrorResponse as w, type SecretRecord as x, type SecretsListResponse as y, type SecretSaveRequest as z };

package/dist/edge.cjs

@@ -2,6 +2,7 @@
 
 // src/config/defaults.ts
 var DEFAULT_BASE_URL = "https://api.onyx.dev";
+var DEFAULT_AI_BASE_URL = "https://ai.onyx.dev";
 var sanitizeBaseUrl = (u) => u.replace(/\/+$/, "");
 
 // src/errors/config-error.ts
@@ -53,6 +54,7 @@ function readEnv(targetId) {
   if (targetId && envId !== targetId) return {};
   const res = dropUndefined({
     baseUrl: pick("ONYX_DATABASE_BASE_URL"),
+    aiBaseUrl: pick("ONYX_AI_BASE_URL"),
     databaseId: envId,
     apiKey: pick("ONYX_DATABASE_API_KEY"),
     apiSecret: pick("ONYX_DATABASE_API_SECRET")
@@ -71,11 +73,13 @@ async function resolveConfig(input) {
   const env = readEnv(input?.databaseId);
   const merged = {
     baseUrl: DEFAULT_BASE_URL,
+    aiBaseUrl: DEFAULT_AI_BASE_URL,
     ...dropUndefined(env),
     ...dropUndefined(input)
   };
   dbg("merged (pre-validate):", mask(merged));
   const baseUrl = sanitizeBaseUrl(merged.baseUrl ?? DEFAULT_BASE_URL);
+  const aiBaseUrl = sanitizeBaseUrl(merged.aiBaseUrl ?? DEFAULT_AI_BASE_URL);
   const databaseId = merged.databaseId ?? "";
   const apiKey = merged.apiKey ?? "";
   const apiSecret = merged.apiSecret ?? "";
@@ -100,6 +104,7 @@ async function resolveConfig(input) {
   }
   const resolved = {
     baseUrl,
+    aiBaseUrl,
     databaseId,
     apiKey,
     apiSecret,
@@ -1120,6 +1125,7 @@ var OnyxDatabaseImpl = class {
   cfgPromise;
   resolved = null;
   http = null;
+  aiHttp = null;
   streams = /* @__PURE__ */ new Set();
   requestLoggingEnabled;
   responseLoggingEnabled;
@@ -1154,6 +1160,30 @@ var OnyxDatabaseImpl = class {
       databaseId: this.resolved.databaseId
     };
   }
+  async ensureAiClient() {
+    if (!this.resolved) {
+      this.resolved = await this.cfgPromise;
+    }
+    if (!this.aiHttp) {
+      this.aiHttp = new HttpClient({
+        baseUrl: this.resolved.aiBaseUrl,
+        apiKey: this.resolved.apiKey,
+        apiSecret: this.resolved.apiSecret,
+        fetchImpl: this.resolved.fetch,
+        requestLoggingEnabled: this.requestLoggingEnabled,
+        responseLoggingEnabled: this.responseLoggingEnabled,
+        retryEnabled: this.resolved.retryEnabled,
+        maxRetries: this.resolved.maxRetries,
+        retryInitialDelayMs: this.resolved.retryInitialDelayMs
+      });
+    }
+    return {
+      http: this.aiHttp,
+      fetchImpl: this.resolved.fetch,
+      aiBaseUrl: this.resolved.aiBaseUrl,
+      databaseId: this.resolved.databaseId
+    };
+  }
   registerStream(handle) {
     this.streams.add(handle);
     return {
@@ -1166,7 +1196,34 @@ var OnyxDatabaseImpl = class {
       }
     };
   }
+  getRequestLoggingEnabled() {
+    return this.requestLoggingEnabled;
+  }
+  getResponseLoggingEnabled() {
+    return this.responseLoggingEnabled;
+  }
   /** -------- IOnyxDatabase -------- */
+  chat() {
+    return new AiChatClientImpl(
+      () => this.ensureAiClient(),
+      (handle) => this.registerStream(handle),
+      () => this.requestLoggingEnabled,
+      () => this.responseLoggingEnabled
+    );
+  }
+  async getModels() {
+    const { http } = await this.ensureAiClient();
+    return http.request("GET", "/v1/models");
+  }
+  async getModel(modelId) {
+    const { http } = await this.ensureAiClient();
+    const path = `/v1/models/${encodeURIComponent(modelId)}`;
+    return http.request("GET", path);
+  }
+  async requestScriptApproval(input) {
+    const { http } = await this.ensureAiClient();
+    return http.request("POST", "/api/script-approvals", input);
+  }
   from(table) {
     return new QueryBuilderImpl(this, String(table), this.defaultPartition);
   }
@@ -1179,6 +1236,14 @@ var OnyxDatabaseImpl = class {
     qb.select(...fields);
     return qb;
   }
+  search(queryText, minScore) {
+    const qb = new QueryBuilderImpl(
+      this,
+      "ALL",
+      this.defaultPartition
+    );
+    return qb.search(queryText, minScore);
+  }
   cascade(...relationships) {
     const cb = new CascadeBuilderImpl(this);
     return cb.cascade(...relationships);
@@ -1465,6 +1530,7 @@ var QueryBuilderImpl = class {
   toSelectQuery() {
     return {
       type: "SelectQuery",
+      table: this.table,
       fields: this.fields,
       conditions: this.serializableConditions(),
       sort: this.sort,
@@ -1504,6 +1570,13 @@ var QueryBuilderImpl = class {
     this.resolvers = flat.length > 0 ? flat : null;
     return this;
   }
+  search(queryText, minScore) {
+    return this.and({
+      field: "__full_text__",
+      operator: "MATCHES",
+      value: { queryText, minScore: minScore ?? null }
+    });
+  }
   where(condition) {
     const c2 = toCondition(condition);
     if (!this.conditions) {
@@ -1700,6 +1773,153 @@ var CascadeBuilderImpl = class {
     return this.db.delete(table, primaryKey, opts);
   }
 };
+var AiChatClientImpl = class {
+  constructor(resolveAiClient, registerStream, requestLoggingEnabled, responseLoggingEnabled) {
+    this.resolveAiClient = resolveAiClient;
+    this.registerStream = registerStream;
+    this.requestLoggingEnabled = requestLoggingEnabled;
+    this.responseLoggingEnabled = responseLoggingEnabled;
+  }
+  normalizeEventData(rawEvent) {
+    const lines = rawEvent.split("\n");
+    const dataLines = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith(":")) continue;
+      if (trimmed.startsWith("data:")) {
+        dataLines.push(trimmed.slice(5).trim());
+      } else {
+        dataLines.push(trimmed);
+      }
+    }
+    if (!dataLines.length) return null;
+    const joined = dataLines.join("\n").trim();
+    return joined.length > 0 ? joined : null;
+  }
+  logRequest(url, body, headers) {
+    if (!this.requestLoggingEnabled()) return;
+    console.log(`POST ${url}`);
+    if (body != null) {
+      const serialized = typeof body === "string" ? body : JSON.stringify(body);
+      console.log(serialized);
+    }
+    const headerLog = { ...headers };
+    if (headerLog["x-onyx-secret"]) headerLog["x-onyx-secret"] = "[REDACTED]";
+    console.log("Headers:", headerLog);
+  }
+  logResponse(status, statusText, raw) {
+    if (!this.responseLoggingEnabled()) return;
+    const statusLine = `${status} ${statusText}`.trim();
+    console.log(statusLine);
+    if (raw && raw.trim().length > 0) {
+      console.log(raw);
+    }
+  }
+  toOnyxError(status, statusText, raw) {
+    let parsed = raw;
+    try {
+      parsed = parseJsonAllowNaN(raw);
+    } catch {
+    }
+    const message = typeof parsed === "object" && parsed !== null && "error" in parsed && typeof parsed.error === "object" && typeof parsed.error?.message === "string" ? String(parsed.error.message) : `${status} ${statusText}`;
+    return new OnyxHttpError(message, status, statusText, parsed, raw);
+  }
+  async create(request, options) {
+    const body = { ...request, stream: !!request.stream };
+    const { http, fetchImpl, aiBaseUrl, databaseId } = await this.resolveAiClient();
+    const params = new URLSearchParams();
+    const scopedDb = options?.databaseId ?? databaseId;
+    if (scopedDb) params.append("databaseId", scopedDb);
+    const path = `/v1/chat/completions${params.size ? `?${params.toString()}` : ""}`;
+    if (!body.stream) {
+      return http.request("POST", path, body);
+    }
+    const url = `${aiBaseUrl}${path}`;
+    const headers = http.headers({ Accept: "text/event-stream" });
+    this.logRequest(url, body, headers);
+    const res = await fetchImpl(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const raw = await res.text();
+      this.logResponse(res.status, res.statusText, raw);
+      throw this.toOnyxError(res.status, res.statusText, raw);
+    }
+    this.logResponse(res.status, res.statusText);
+    const bodyStream = res.body;
+    const reader = bodyStream && typeof bodyStream.getReader === "function" ? bodyStream.getReader() : null;
+    if (!reader) {
+      throw new OnyxHttpError(
+        "Streaming response body is not readable",
+        res.status,
+        res.statusText,
+        null,
+        ""
+      );
+    }
+    let canceled = false;
+    const handle = {
+      cancel: () => {
+        if (canceled) return;
+        canceled = true;
+        try {
+          reader.cancel?.();
+        } catch {
+        }
+      }
+    };
+    const registered = this.registerStream(handle);
+    const normalizeEvent = (rawEvent) => this.normalizeEventData(rawEvent);
+    const stream = {
+      async *[Symbol.asyncIterator]() {
+        const decoder = new TextDecoder("utf-8");
+        let buffer = "";
+        try {
+          while (!canceled) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            if (value) {
+              buffer += decoder.decode(value, { stream: true });
+            }
+            let splitIndex = buffer.indexOf("\n\n");
+            while (splitIndex !== -1) {
+              const rawEvent = buffer.slice(0, splitIndex);
+              buffer = buffer.slice(splitIndex + 2);
+              const data = normalizeEvent(rawEvent);
+              if (data === "[DONE]") return;
+              if (data) {
+                try {
+                  yield parseJsonAllowNaN(data);
+                } catch {
+                }
+              }
+              splitIndex = buffer.indexOf("\n\n");
+            }
+          }
+          buffer += decoder.decode();
+          const remaining = buffer.trim();
+          if (remaining && remaining !== "[DONE]") {
+            const data = normalizeEvent(remaining);
+            if (data && data !== "[DONE]") {
+              try {
+                yield parseJsonAllowNaN(data);
+              } catch {
+              }
+            }
+          }
+        } finally {
+          registered.cancel();
+        }
+      },
+      cancel() {
+        registered.cancel();
+      }
+    };
+    return stream;
+  }
+};
 function createOnyxFacade(resolveConfig2) {
   let cachedCfg = null;
   function resolveConfigWithCache(config) {
@@ -1855,6 +2075,10 @@ var ConditionBuilderImpl = class {
 
 // src/helpers/conditions.ts
 var c = (field, operator, value) => new ConditionBuilderImpl({ field, operator, value });
+var fullText = (queryText, minScore) => ({
+  queryText,
+  minScore: minScore ?? null
+});
 var eq = (field, value) => c(field, "EQUAL", value);
 var neq = (field, value) => c(field, "NOT_EQUAL", value);
 function inOp(field, values) {
@@ -1877,6 +2101,7 @@ var gte = (field, value) => c(field, "GREATER_THAN_EQUAL", value);
 var lt = (field, value) => c(field, "LESS_THAN", value);
 var lte = (field, value) => c(field, "LESS_THAN_EQUAL", value);
 var matches = (field, regex) => c(field, "MATCHES", regex);
+var search = (queryText, minScore) => c("__full_text__", "MATCHES", fullText(queryText, minScore));
 var notMatches = (field, regex) => c(field, "NOT_MATCHES", regex);
 var like = (field, pattern) => c(field, "LIKE", pattern);
 var notLike = (field, pattern) => c(field, "NOT_LIKE", pattern);
@@ -1943,6 +2168,7 @@ exports.percentile = percentile;
 exports.replace = replace;
 exports.sdkName = sdkName;
 exports.sdkVersion = sdkVersion;
+exports.search = search;
 exports.startsWith = startsWith;
 exports.std = std;
 exports.substring = substring;