import { queryBuilder, mappings, text, keyword, float, type Infer } from 'elasticlink';

// Define field types once — this is the single source of truth
const productMappings = mappings({
  name: text(),
  description: text(),
  price: float(),
  category: keyword()
});

// Derive a TS type from mappings (optional, for use elsewhere in your application)
type Product = Infer<typeof productMappings>;

// Build a type-safe query — field constraints are enforced at compile time
const elasticQuery = queryBuilder(productMappings)
  .match('name', 'laptop') // ✅ 'name' is a text field
  .range('price', { gte: 500, lte: 2000 })
  .sort('price', 'asc')
  .from(0)
  .size(20)
  .build();

// Send to Elasticsearch
const response = await client.search({ index: 'products', ...elasticQuery });

const facetedSearch = queryBuilder(productMappings)
  .bool()
  .must((q) => q.match('name', 'gaming laptop', { operator: 'and' }))
  .filter((q) => q.term('category', 'electronics'))
  .filter((q) => q.range('price', { gte: 800, lte: 2000 }))
  .aggs((agg) => agg.terms('by_category', 'category', { size: 10 }).avg('avg_price', 'price'))
  .highlight(['name', 'description'])
  .size(20)
  .build();

queryBuilder(productMappings).match('category', 'electronics');
//                           ^^^^^^^^^^
// TypeScript error: 'category' is a keyword field — use term(), not match()

queryBuilder(productMappings).term('category', 'electronics'); // ✅ Correct

const ecommerceMappings = mappings({
  name: text(),
  description: text(),
  category: keyword(),
  price: float(),
  tags: keyword(),
  in_stock: boolean()
});

const searchTerm = 'gaming laptop';
const category = 'electronics';
const minPrice = 800;
const maxPrice = 2000;

const result = queryBuilder(ecommerceMappings)
  .bool()
  .must((q) => q.match('name', searchTerm, { operator: 'and', boost: 2 }))
  .should((q) => q.fuzzy('description', searchTerm, { fuzziness: 'AUTO' }))
  .filter((q) => q.term('category', category))
  .filter((q) => q.range('price', { gte: minPrice, lte: maxPrice }))
  .filter((q) => q.term('in_stock', true))
  .minimumShouldMatch(1)
  .aggs((agg) =>
    agg.terms('by_category', 'category', { size: 10 }).range('price_ranges', 'price', {
      ranges: [{ to: 800 }, { from: 800, to: 1500 }, { from: 1500 }]
    })
  )
  .highlight(['name', 'description'], {
    fragment_size: 150,
    pre_tags: ['<mark>'],
    post_tags: ['</mark>']
  })
  ._source(['name', 'price', 'category', 'tags'])
  .timeout('5s')
  .from(0)
  .size(20)
  .sort('_score', 'desc')
  .build();

const buildDynamicQuery = (filters: SearchFilters) => {
  return queryBuilder(productMappings)
    .bool()
    .when(filters.searchTerm, (q) => q.must((q2) => q2.match('name', filters.searchTerm!, { boost: 2 })))
    .when(filters.category, (q) => q.filter((q2) => q2.term('category', filters.category!)))
    .when(filters.minPrice != null && filters.maxPrice != null, (q) =>
      q.filter((q2) => q2.range('price', { gte: filters.minPrice!, lte: filters.maxPrice! }))
    )
    .from(filters.offset || 0)
    .size(filters.limit || 20)
    .build();
};

const instrumentMappings = mappings({
  name: text(),
  asset_class: keyword(),
  sector: keyword(),
  price: float(),
  yield_rate: float(),
  listed_date: date()
});

const result = queryBuilder(instrumentMappings)
  .bool()
  .filter((q) => q.term('asset_class', 'fixed-income'))
  .filter((q) => q.range('yield_rate', { gte: 3.0 }))
  .aggs((agg) =>
    agg
      .terms('by_sector', 'sector', { size: 10 })
      .subAgg((sub) => sub.avg('avg_yield', 'yield_rate').max('max_price', 'price'))
      .dateHistogram('listings_over_time', 'listed_date', {
        interval: 'quarter',
        min_doc_count: 1
      })
      .subAgg((sub) => sub.percentiles('yield_percentiles', 'yield_rate', { percents: [25, 50, 75, 95] }))
  )
  .size(0)
  .build();

const restaurantMappings = mappings({
  name: text(),
  cuisine: keyword(),
  location: geoPoint(),
  rating: float()
});

const result = queryBuilder(restaurantMappings)
  .bool()
  .filter((q) => q.term('cuisine', 'italian'))
  .filter((q) => q.geoDistance('location', { lat: 40.7128, lon: -74.006 }, { distance: '5km' }))
  .sort('rating', 'desc')
  .size(20)
  .build();

import { queryBuilder, mappings, text, keyword, integer, type Infer } from 'elasticlink';

const userMappings = mappings({
  name: text(),
  email: keyword(),
  age: integer()
});

type User = Infer<typeof userMappings>;
// => { name: string; email: string; age: number }

// ✅ 'name' is a text field — match() accepts it
const q1 = queryBuilder(userMappings).match('name', 'John').build();

// ❌ TypeScript error: 'email' is keyword, not text — use term() instead
const q2 = queryBuilder(userMappings).match('email', 'john@example.com').build();

// ✅ Correct: use term() for keyword fields
const q3 = queryBuilder(userMappings).term('email', 'john@example.com').build();

import { indexBuilder, productionSearchSettings, indexSortSettings, fastIngestSettings } from 'elasticlink';

// Create index with production settings
const indexConfig = indexBuilder().mappings(myMappings).settings(productionSearchSettings()).build();

// Index-time sort for compression and early termination
const sortedConfig = indexBuilder()
  .mappings(myMappings)
  .settings({
    ...productionSearchSettings(),
    index: indexSortSettings({ timestamp: 'desc', status: 'asc' })
  })
  .build();

// Before bulk ingest — disables refresh, removes replicas, async translog
await client.indices.putSettings({ index: 'my-index', body: fastIngestSettings() });

// Perform bulk ingest...

// Restore production settings afterward
await client.indices.putSettings({ index: 'my-index', body: productionSearchSettings() });
await client.indices.refresh({ index: 'my-index' });

queryBuilder(productMappings)
  .bool()
  .must((q) => q.match('name', 'laptop'))
  .filter((q) => q.range('price', { gte: 500 }))
  .should((q) => q.term('category', 'featured'))
  .mustNot((q) => q.term('category', 'discontinued'))
  .minimumShouldMatch(1)
  .build();

const searchTerm: string | undefined = param.searchTerm;
const minPrice: number | undefined = param.minPrice;

queryBuilder(productMappings)
  .bool()
  .when(searchTerm, (q) => q.must((q2) => q2.match('name', searchTerm!)))
  .when(minPrice, (q) => q.filter((q2) => q2.range('price', { gte: minPrice! })))
  .build();

queryBuilder(productMappings)
  .match('name', 'laptop')
  .from(0) // Pagination offset
  .size(20) // Results per page
  .sort('price', 'asc') // Sort by field
  ._source(['name', 'price']) // Which fields to return
  .timeout('5s') // Query timeout
  .trackScores(true) // Enable scoring in filter context
  .trackTotalHits(true) // Track total hit count (or pass a number threshold)
  .explain(true) // Return scoring explanation
  .minScore(10) // Minimum relevance score
  .version(true) // Include document version in results
  .seqNoPrimaryTerm(true) // Include seq_no and primary_term for optimistic concurrency
  .highlight(['name', 'description'], {
    fragment_size: 150,
    pre_tags: ['<mark>'],
    post_tags: ['</mark>']
  })
  .build();

import { queryBuilder, aggregations } from 'elasticlink';

// Inline aggregations (most common)
const result = queryBuilder(productMappings)
  .term('category', 'electronics')
  .aggs((agg) =>
    agg
      .terms('by_category', 'category', { size: 10 })
      .subAgg((sub) => sub.avg('avg_price', 'price').max('max_price', 'price'))
  )
  .size(20)
  .build();

// Aggregations-only (no query) — use queryBuilder(mappings, false)
const aggsOnly = queryBuilder(productMappings, false)
  .aggs((agg) => agg.terms('by_category', 'category'))
  .size(0)
  .build();

// Standalone aggregation builder (for manual composition)
const standaloneAgg = aggregations(productMappings)
  .avg('avg_price', 'price')
  .terms('by_category', 'category', { size: 10 })
  .build();

import { indexBuilder, mappings, keyword, integer, float, date, text } from 'elasticlink';

const matterMappings = mappings({
  title: text({ analyzer: 'english' }),
  practice_area: keyword(),
  billing_rate: integer(),
  risk_score: float(),
  opened_at: date()
});

const indexConfig = indexBuilder()
  .mappings(matterMappings)
  .settings({
    number_of_shards: 2,
    number_of_replicas: 1,
    refresh_interval: '5s'
  })
  .alias('matters-current', { is_write_index: true })
  .alias('matters-all')
  .build();

// PUT /matters-v1
await client.indices.create({ index: 'matters-v1', ...indexConfig });

import { mappings, text, keyword, float, integer, boolean, object, nested, type Infer } from 'elasticlink';

const productMappings = mappings({
  name: text(),
  in_stock: boolean(),
  address: object({
    // Single structured value — queried with dot-notation
    street: text(),
    city: keyword(),
    country: keyword()
  }),
  variants: nested({
    // Array of objects — cross-field accuracy preserved
    sku: keyword(),
    color: keyword(),
    price: float(),
    stock: integer()
  })
});

type Product = Infer<typeof productMappings>;
// { name: string; in_stock: boolean;
//   address: { street: string; city: string; country: string };
//   variants: Array<{ sku: string; color: string; price: number; stock: number }> }

// object sub-fields — query with dot-notation directly
queryBuilder(productMappings)
  .bool()
  .filter((q) => q.term('address.country', 'US'))
  .filter((q) => q.match('address.street', 'Main'))
  .build();

// nested sub-fields — must use .nested() wrapper; field names are relative
queryBuilder(productMappings)
  .nested('variants', (q) => q.term('color', 'black'))
  .build();

queryBuilder(productMappings)
  .nested('variants', (q) => q.range('price', { lte: 150 }), { score_mode: 'min' })
  .build();

// Shorthand — pass options or use defaults
keyword(); // { type: 'keyword' }
integer(); // { type: 'integer' }
text({ analyzer: 'english' }); // { type: 'text', analyzer: 'english' }
denseVector({ dims: 384, index: true, similarity: 'cosine' });

// Multi-fields carry type info — dot-notation paths work in queries
const m = mappings({
  name: text({ fields: { raw: keyword() } }),
  price: float({ fields: { string: keyword() } }),
});
const qb = queryBuilder(m);
qb.term('name.raw', 'exact match'); // ✓ name.raw is a KeywordFields<M> path
qb.match('name', 'full text');      // ✓ name is a TextFields<M> path

import { queryBuilder, suggest, mappings, text, keyword, completion } from 'elasticlink';

const searchableMappings = mappings({
  name: text(),
  description: text(),
  suggest_field: completion()
});

// Standalone suggest
const autocomplete = suggest(searchableMappings)
  .completion('autocomplete', 'lap', {
    field: 'suggest_field',
    size: 10,
    skip_duplicates: true,
    fuzzy: { fuzziness: 'AUTO', min_length: 3, prefix_length: 1 }
  })
  .build();

// Inline with query — search + spell-check in one request
const searchWithSuggestions = queryBuilder(searchableMappings)
  .match('name', 'laptpo')
  .suggest((s) =>
    s
      .completion('autocomplete', 'lap', { field: 'suggest_field', size: 5 })
      .term('spelling', 'laptpo', { field: 'name', size: 3, suggest_mode: 'popular' })
  )
  .size(20)
  .build();

import { queryBuilder, msearch } from 'elasticlink';

const laptopQuery = queryBuilder(productMappings).match('name', 'laptop').range('price', { gte: 500, lte: 2000 }).build();

const phoneQuery = queryBuilder(productMappings).match('name', 'smartphone').range('price', { gte: 300, lte: 1000 }).build();

// NDJSON string for Elasticsearch _msearch endpoint
const ndjson = msearch(productMappings)
  .addQuery(laptopQuery, { index: 'products', preference: '_local' })
  .addQuery(phoneQuery, { index: 'products', preference: '_local' })
  .build();

// Or as an array of objects
const array = msearch(productMappings)
  .addQuery(laptopQuery, { index: 'products' })
  .addQuery(phoneQuery, { index: 'products' })
  .buildArray();

import { bulk, mappings, keyword, text, float } from 'elasticlink';

const productMappings = mappings({
  id: keyword(),
  name: text(),
  price: float(),
  category: keyword()
});

const bulkOp = bulk(productMappings)
  .index({ id: '1', name: 'Laptop Pro', price: 1299, category: 'electronics' }, { _index: 'products', _id: '1' })
  .create({ id: '2', name: 'Wireless Mouse', price: 29, category: 'accessories' }, { _index: 'products', _id: '2' })
  .update({ _index: 'products', _id: '3', doc: { price: 999 } })
  .delete({ _index: 'products', _id: '4' })
  .build();

// POST /_bulk with Content-Type: application/x-ndjson

import { queryBuilder, mappings, text, keyword, float, denseVector } from 'elasticlink';

const productWithEmbeddingMappings = mappings({
  name: text(),
  description: text(),
  price: float(),
  category: keyword(),
  embedding: denseVector({ dims: 384 })
});

const searchEmbedding = [0.23, 0.45, 0.67, 0.12, 0.89]; // From your ML model

// Basic semantic search
const result = queryBuilder(productWithEmbeddingMappings)
  .knn('embedding', searchEmbedding, {
    k: 10,
    num_candidates: 100
  })
  .size(10)
  .build();

// Hybrid search — KNN + filters + aggregations
const hybridSearch = queryBuilder(productWithEmbeddingMappings)
  .knn('embedding', searchEmbedding, {
    k: 100,
    num_candidates: 1000,
    filter: { term: { category: 'electronics' } },
    boost: 1.2,
    similarity: 0.7
  })
  .aggs((agg) => agg.terms('categories', 'category', { size: 10 }))
  .size(20)
  .build();

import { queryBuilder, mappings, text, float, long } from 'elasticlink';

const scoredProductMappings = mappings({
  name: text(),
  price: float(),
  popularity: long()
});

// Script-based filtering
const filtered = queryBuilder(scoredProductMappings)
  .bool()
  .must((q) => q.match('name', 'laptop'))
  .filter((q) =>
    q.script({
      source: "doc['price'].value > params.threshold",
      params: { threshold: 500 }
    })
  )
  .build();

// Custom scoring with script_score
const customScored = queryBuilder(scoredProductMappings)
  .scriptScore((q) => q.match('name', 'smartphone'), {
    source: "_score * Math.log(2 + doc['popularity'].value)",
    lang: 'painless'
  })
  .size(20)
  .build();

import { queryBuilder, mappings, keyword, percolator } from 'elasticlink';

const alertRuleMappings = mappings({
  query: percolator(),
  name: keyword(),
  severity: keyword()
});

const alerts = queryBuilder(alertRuleMappings)
  .percolate({
    field: 'query',
    document: {
      level: 'ERROR',
      message: 'Database connection failed',
      timestamp: '2024-01-15T10:30:00Z'
    }
  })
  .size(100)
  .build();