@empathyco/x-types

import type { Result } from '@empathyco/x-types'

interface Result extends Identifiable {
  id: string
  modelName: 'Result'
  name?: string
  description?: string
  images?: string[]
  url?: string
  price?: {
    value: number
    currency?: string
  }
  rating?: {
    value: number
  }
  isWishlisted?: boolean
  // Additional custom fields
  [key: string]: unknown
}

import type { Facet, Filter } from '@empathyco/x-types'

interface Facet extends Identifiable {
  id: string
  modelName: 'Facet'
  label?: string
  filters: Filter[]
}

interface Filter extends Identifiable {
  id: string
  modelName: string
  facetId: string
  label?: string
  totalResults?: number
  selected: boolean
}

import type { SearchRequest } from '@empathyco/x-types'

interface SearchRequest {
  query: string
  rows?: number
  start?: number
  filters?: Record<string, string[]>
  sort?: string
  extraParams?: Record<string, unknown>
}

import type { SearchResponse, Result, Facet, Banner } from '@empathyco/x-types'

interface SearchResponse {
  results: Result[]
  facets: Facet[]
  totalResults: number
  banners?: Banner[]
  promoteds?: Result[]
  partialResults?: Result[]
  redirections?: Redirection[]
  spellcheck?: string
  queryTagging?: TaggingInfo
  displayTagging?: TaggingInfo
}

import { isFacetFilter, isHierarchicalFilter } from '@empathyco/x-types'

if (isFacetFilter(filter)) {
  // TypeScript knows filter has facetId property
  console.log(filter.facetId)
}

if (isHierarchicalFilter(filter)) {
  // TypeScript knows filter has children property
  console.log(filter.children)
}

import type { UserInfo } from '@empathyco/x-types'

interface UserInfo {
  userId?: string
  sessionId?: string
  [key: string]: unknown
}

import type { Sort } from '@empathyco/x-types'

type Sort = string

import type { Stats } from '@empathyco/x-types'

interface Stats {
  queryTime?: number
  totalTime?: number
  numFound?: number
}

import { defineComponent } from 'vue'
import type { Result, Facet } from '@empathyco/x-types'
import type { SearchState } from '@empathyco/x-components'

export default defineComponent({
  computed: {
    results(): Result[] {
      return this.$store.state.x.search.results
    },
    facets(): Facet[] {
      return this.$store.state.x.facets.facets
    }
  }
})

import type { SearchRequest, SearchResponse } from '@empathyco/x-types'
import { endpointAdapterFactory } from '@empathyco/x-adapter'

const searchAdapter = endpointAdapterFactory<SearchRequest, SearchResponse>({
  endpoint: '/api/search',
  requestMapper: (request) => ({
    q: request.query,
    size: request.rows || 24,
    filters: request.filters
  }),
  responseMapper: (response) => ({
    results: response.results,
    facets: response.facets,
    totalResults: response.totalResults
  })
})

import type { XComponentsAdapter } from '@empathyco/x-types'

interface XComponentsAdapter {
  search: EndpointAdapter<SearchRequest, SearchResponse>
  recommendations: EndpointAdapter<RecommendationsRequest, RecommendationsResponse>
  relatedTags: EndpointAdapter<RelatedTagsRequest, RelatedTagsResponse>
  // ... other endpoints
}

import type { Result } from '@empathyco/x-types'

interface CustomResult extends Result {
  availability: 'in_stock' | 'out_of_stock'
  brand: string
  categories: string[]
  customField: string
}