Options
All
  • Public
  • Public/Protected
  • All
Menu

Module shopperDiscoverySearch

Index

Classes

Type aliases

Type aliases

AsyncCreated

AsyncCreated: {}

Type declaration

  • [key: string]: any

AttributeGrouping

AttributeGrouping: { attributeId: string; groupType: string; returnedAttributes?: Array<string> }

Type declaration

  • attributeId: string
  • groupType: string
  • Optional returnedAttributes?: Array<string>

AttributeSorting

AttributeSorting: { attributeId: string; direction: string; sortType: string }

Type declaration

  • attributeId: string
  • direction: string
  • sortType: string

AttributesQuery

AttributesQuery: { correctableAttributes?: CorrectableAttributes; highlighting?: Highlighting; queryType: string; value: { attributes: Array<string>; phrase: string } & {} }

Type declaration

  • Optional correctableAttributes?: CorrectableAttributes
  • Optional highlighting?: Highlighting
  • queryType: string
  • value: { attributes: Array<string>; phrase: string } & {}

AuthenticationFailure

AuthenticationFailure: {}

Type declaration

AuthorizationFailure

AuthorizationFailure: {}

Type declaration

BadRequest

BadRequest: {}

Type declaration

BaseError

BaseError: { detail?: undefined | string; instance?: undefined | string; title?: undefined | string; type: string }

Type declaration

  • Optional detail?: undefined | string
  • Optional instance?: undefined | string
  • Optional title?: undefined | string
  • type: string

BoolFilter

BoolFilter: { filters?: Array<any>; operator: string } & {}

BoolQuery

BoolQuery: { must?: Array<any>; mustNot?: Array<any>; should?: Array<any> } & {}

ClosedObject

ClosedObject: {} & {}

CommonErrors

CommonErrors: {}

Type declaration

  • [key: string]: any

CorrectableAttributes

CorrectableAttributes: { attributes: Array<string> } & {}

DateConditionalRequest

DateConditionalRequest: {}

Type declaration

  • [key: string]: any

ErrorResponse

ErrorResponse: { detail?: undefined | string; instance?: undefined | string; title?: undefined | string; type: string } & {}

EtagConditionalRequest

EtagConditionalRequest: {}

Type declaration

  • [key: string]: any

EtagResponse

EtagResponse: {}

Type declaration

  • [key: string]: any

ExpansionAttribute

ExpansionAttribute: { attributeId: string; path: string; value: any } & {}

FacetInput

FacetInput: { attributeId: string; facetType: string } & {}

FacetOutput

FacetOutput: { attributeId: string; facetType: string } & {}

FacetRequest

FacetRequest: { facetLimit?: any; facets?: Array<FacetInput> } & {}

Filter

Filter: { boolFilter?: BoolFilter; queryFilter?: QueryFilter; range2Filter?: Range2Filter; rangeFilter?: RangeFilter; termFilter?: TermFilter } & {}

Filterable

Filterable: {}

Type declaration

  • [key: string]: any

FilteredQuery

FilteredQuery: { filter: any; query: any } & {}

Grouping

Grouping: { groupType: string } & {}

Highlight

Highlight: { attributeId: string; value: string } & {}

Highlighting

Highlighting: { attributes: Array<string> } & {}

InternalServerError

InternalServerError: {}

Type declaration

InvalidRequest

InvalidRequest: {}

Type declaration

ItemReference

ItemReference: { attributes?: Array<ExpansionAttribute>; itemId: string } & {}

MatchAllQuery

MatchAllQuery: {} & {}

Money

Money: { currencyMnemonic?: undefined | string; value?: undefined | number } & {}

MoneyMnemonic

MoneyMnemonic: { currencyMnemonic?: undefined | string; value?: undefined | number } & {}

NestedQuery

NestedQuery: { path: string; query: any; scoreMode?: undefined | string } & {}

NoPropertiesAllowed

NoPropertiesAllowed: {}

Type declaration

NonReadableHttpMessage

NonReadableHttpMessage: {}

Type declaration

NotFound

NotFound: {}

Type declaration

OffsetPaginated

OffsetPaginated: {}

Type declaration

  • [key: string]: any

OpenObject

OpenObject: {} & {}

PaginatedSearchResult

PaginatedSearchResult: { hits?: Array<object>; limit: number; offset: any; query: any; sorts?: Array<Sort>; total: any } & {}

PaginatedSearchResultBase

PaginatedSearchResultBase: { hits?: Array<object>; limit: number; offset: any; query: any; sorts?: Array<Sort>; total: any } & {}

Pagination

Pagination: { next?: Self; prev?: Self; self: Self }

Type declaration

PaginationLinks

PaginationLinks: { next?: Self; prev?: Self; self: Self } & {}

PhraseQuery

PhraseQuery: { correctableAttributes?: CorrectableAttributes; highlighting?: Highlighting; queryType: string; value: string }

Type declaration

Query

Query: { boolQuery?: BoolQuery; filteredQuery?: FilteredQuery; matchAllQuery?: MatchAllQuery; nestedQuery?: NestedQuery; termQuery?: TermQuery; textQuery?: TextQuery } & {}

QueryFilter

QueryFilter: { query: any } & {}

QueryInput

QueryInput: { facetRequest?: FacetRequest; facets?: Array<FacetInput>; grouping?: Grouping; query?: Query; refinements?: Array<Refinement>; returnedAttributes?: Array<string>; sorting: Sorting }

Type declaration

QueryOutput

QueryOutput: { facets?: Array<FacetOutput>; hits: Array<Result>; limit: number; links: PaginationLinks; offset: any; total: any }

Type declaration

QueryParamsLimit

QueryParamsLimit: {}

Type declaration

  • [key: string]: any

QueryParamsOffset

QueryParamsOffset: {}

Type declaration

  • [key: string]: any

Range2Filter

Range2Filter: { filterMode?: undefined | string; fromField: string; fromInclusive?: undefined | false | true; fromValue?: any; toField: string; toInclusive?: undefined | false | true; toValue?: any } & {}

RangeFacetInput

RangeFacetInput: {}

Type declaration

RangeFacetOutput

RangeFacetOutput: { attributeId: string; facetType: string; max: any; min: any }

Type declaration

  • attributeId: string
  • facetType: string
  • max: any
  • min: any

RangeFilter

RangeFilter: { field: string; from?: any; fromInclusive?: undefined | false | true; to?: any; toInclusive?: undefined | false | true } & {}

RangeRefinement

RangeRefinement: { attributeId: string; max: any; min: any; refinementType: string }

Type declaration

  • attributeId: string
  • max: any
  • min: any
  • refinementType: string

RateLimitExceeded

RateLimitExceeded: { detail?: undefined | string; instance?: undefined | string; requestLimit: any; title?: undefined | string; type: string }

Type declaration

  • Optional detail?: undefined | string
  • Optional instance?: undefined | string
  • requestLimit: any
  • Optional title?: undefined | string
  • type: string

RateLimited

RateLimited: {}

Type declaration

  • [key: string]: any

RateLimited2

RateLimited2: {}

Type declaration

  • [key: string]: any

RateLimited3

RateLimited3: {}

Type declaration

  • [key: string]: any

RateLimited4

RateLimited4: {}

Type declaration

  • [key: string]: any

RateLimited5

RateLimited5: {}

Type declaration

  • [key: string]: any

Refinement

Refinement: { attributeId: string; refinementType: string } & {}

RelevanceSorting

RelevanceSorting: {}

Type declaration

ResourceBadRequest

ResourceBadRequest: {}

Type declaration

  • [key: string]: any

ResourceCommonErrors

ResourceCommonErrors: {}

Type declaration

  • [key: string]: any

ResourceInvalidRequest

ResourceInvalidRequest: {}

Type declaration

ResourceLink

ResourceLink: { self: Self } & {}

ResourceNonReadableHttpMessage

ResourceNonReadableHttpMessage: {}

Type declaration

Result

Result: { groupId?: undefined | string; groupedItems?: Array<ItemReference>; highlights?: Array<Highlight>; matchedItem: ItemReference; totalGroupedItems?: any }

Type declaration

  • Optional groupId?: undefined | string
  • Optional groupedItems?: Array<ItemReference>
  • Optional highlights?: Array<Highlight>
  • matchedItem: ItemReference
  • Optional totalGroupedItems?: any

SearchRequest

SearchRequest: { limit?: undefined | number; offset?: any; query: any; sorts?: Array<Sort> } & {}

SearchRequestBase

SearchRequestBase: { limit?: undefined | number; offset?: any; query: any; sorts?: Array<Sort> } & {}

Self

Self: { href: string }

Type declaration

  • href: string

SelfResourceLink

SelfResourceLink: { self: Self }

Type declaration

ServiceUnavailable

ServiceUnavailable: {}

Type declaration

ShopperDiscoverySearchParameters

ShopperDiscoverySearchParameters: ShopperDiscoverySearchPathParameters & BaseUriParameters & ShopperDiscoverySearchQueryParameters

All parameters that are used by ShopperDiscoverySearch.

ShopperDiscoverySearchPathParameters

ShopperDiscoverySearchPathParameters: { channelId?: undefined | string; organizationId?: undefined | string }

All path parameters that are used by at least one ShopperDiscoverySearch method.

Type declaration

  • Optional channelId?: undefined | string
  • Optional organizationId?: undefined | string

ShopperDiscoverySearchQueryParameters

ShopperDiscoverySearchQueryParameters: { limit?: undefined | number; locale?: undefined | string; offset?: any; searchText?: undefined | string; suggestionTypes?: Array<string> }

All query parameters that are used by at least one ShopperDiscoverySearch method.

Type declaration

  • Optional limit?: undefined | number
  • Optional locale?: undefined | string
  • Optional offset?: any
  • Optional searchText?: undefined | string
  • Optional suggestionTypes?: Array<string>

SimpleSearchResult

SimpleSearchResult: { hits?: Array<object>; limit: number; offset: any; total: any } & {}

SimpleSearchResultBase

SimpleSearchResultBase: { hits?: Array<object>; limit: number; offset: any; total: any } & {}

SiteSpecific

SiteSpecific: {}

Type declaration

  • [key: string]: any

Sort

Sort: { field: string; sortOrder?: undefined | string } & {}

Sorting

Sorting: { sortType: string } & {}

SpecifiedPropertiesAllowed

SpecifiedPropertiesAllowed: {} & {}

Suggestion

Suggestion: { phrase: string }

Type declaration

  • phrase: string

Suggestions

Suggestions: { popularSearchPhrases?: Array<Suggestion>; recentSearchPhrases?: Array<Suggestion>; suggestedSearchPhrases?: Array<Suggestion> }

Type declaration

  • Optional popularSearchPhrases?: Array<Suggestion>
  • Optional recentSearchPhrases?: Array<Suggestion>
  • Optional suggestedSearchPhrases?: Array<Suggestion>

SyncCreated

SyncCreated: {}

Type declaration

  • [key: string]: any

TermFilter

TermFilter: { field: string; operator: string; values?: Array<any> } & {}

TermQuery

TermQuery: { fields: Array<string>; operator: string; values?: Array<any> } & {}

TextQuery

TextQuery: { fields: Array<string>; searchPhrase: string } & {}

Traceable

Traceable: {}

Type declaration

  • [key: string]: any

ValueFacetInput

ValueFacetInput: { attributeId: string; facetType: string; mask?: Array<string> }

Type declaration

  • attributeId: string
  • facetType: string
  • Optional mask?: Array<string>

ValueFacetOutput

ValueFacetOutput: { attributeId: string; facetType: string; values?: Array<ValueFacetOutputEntity> }

Type declaration

ValueFacetOutputEntity

ValueFacetOutputEntity: { count: any; value: string } & {}

ValueRefinement

ValueRefinement: { attributeId: string; refinementType: string; values: Array<any> }

Type declaration

  • attributeId: string
  • refinementType: string
  • values: Array<any>

Generated using TypeDoc