---
schema_version: "1"
id: 9eb3314936d017a87c461da8e3194ac2c9b15cf52efb5771dcd48e16d0228795
title: Data Slot Configuration Search (deprecated)
collection: developer
version: current
locale: en-us
portal_url: https://docs.salesforce.com/developer/current/en-us/commerce-cloud/b2c-commerce/references/generated-api-specs/ocapi-data-slot-configuration-search.md
canonical_url: https://developer.salesforce.com/docs/commerce/b2c-commerce/references/ocapi-data-slot-configuration-search
source_site: developer.salesforce.com
content_type: documentation
content_hash: 08b605594433cb12c94c0996bdee24ed66146e81ef340f799fd17ab78fb6f86e
products:
  - B2C Commerce
  - Salesforce APIs
---
Data Slot Configuration Search (deprecated)

# Data Slot Configuration Search (deprecated)

Data API endpoints enable developers to build applications for merchants: Create, update, delete business objects, like products, customers, pricing and promotions or assignments. They typically provide read and write access and are designed for moderate usage.

**Version:** 25.6

## Servers

*   `https://{host}/s/-/dw/data/v25_6`

Protocols: https.

## Security

*   `oauth2_application` (oauth2) Authentication flow with client ID and password with account manager.
    *   OAuth flow application (tokenUrl: https://account.demandware.com:443/dwsso/oauth2/access\_token)
    *   Scope x-info: Scopes are NOT supported. This is just a dummy, because the 'scopes' field is required.
*   `client_id` (apiKey) Add client ID for application identification. Alternative as 'client\_id' query parameter.
    *   API key in header: x-dw-client-id

## Operations

### POST Search Slot Configurations

`POST /sites/{site_id}/slot_configuration_search`

Operation ID: `Search Slot Configurations`. Tags: sites. Security: oauth2\_application.

Searches for slot configurations.

The query attribute specifies a complex query that can be used to narrow down the search. Attributes are grouped into different buckets. These are the list of searchable attributes with their corresponding buckets:

Main:

*   configuration\_id - String
    
*   default - Boolean
    
*   description - String
    
*   enabled - Boolean
    

Slot:

*   context - String
    
*   slot\_id - String
    

Only fields in the same bucket can be joined using a disjunction (OR). For instance, when joining context and description above, only a conjunction is allowed (AND), whereas context and slot\_id can be joined to each other using a disjunction because they are in the same bucket. If the field is used in a disjunction (OR) that violates this rule, an exception will be thrown.

This endpoint may return the following faults:

*   400 - TypeMissmatchException - Indicates that the value to search with does not match the type of the search field.

#### Parameters

*   `site_id` (path, string, required) The site context.

#### Request body (required)

Media type: `application/json, text/xml`. Schema: `search_request`.

#### Responses

*   **400** `TypeMissmatchException` - Indicates that the value to search with does not match the type of the search field.
    
    Media type: `application/json, text/xml`. Schema: `fault`.
    
*   **default**
    
    Media type: `application/json, text/xml`. Schema: `slot_configuration_search_result`.
    

## Schemas

### search\_request

Document representing a search request for retrieving items within the Data API. The query is a potentially complex set of expressions. The fields that each query supports are defined within the search resource.

*   `count` (_integer (int32)_) The number of returned documents  
    Minimum: 1. Maximum: 200.
*   `db_start_record_` (_integer (int32)_) The zero-based index of the record that we want to start with, used to optimize special handling  
    Minimum: 0.
*   `expand` (_array of string_) List of expansions to be applied to each search results. Expands are optional
*   `query` (_query_, required) The query to apply
*   `select` (_string_) The field to be selected.
*   `sorts` (_array of sort_) The list of sort clauses configured for the search request. Sort clauses are optional.
*   `start` (_integer (int32)_) The zero-based index of the first search hit to include in the result.  
    Minimum: 0.

### fault

Document representing a fault message that is returned whenever the HTTP status code is greater than or equal to 400 (which indicates an error).

*   `arguments` (_object_)
    
    A map that provides fault arguments.
    
    Data can be used to provide error messages on the client side.
    
    Additional properties: `object`.
    
*   `cause` (_cause_)
*   `display_message_pattern` (_string_) The localized display message pattern, if the request parameter display\_locale was given
*   `message` (_string_) The message text of the java exception.
*   `stack_trace` (_string_)
*   `type` (_string_) The name of the java exception.

### slot\_configuration\_search\_result

Document representing a slot configuration search result.

*   `count` (_integer (int32)_) The number of returned documents
*   `data` (_array of object_)
*   `db_start_record_` (_integer (int32)_) The zero-based index of the record that we want to start with, used to optimize special handling  
    Minimum: 0.
*   `expand` (_array of string_) List of expansions to be applied to each search results. Expands are optional
*   `hits` (_array of slot\_configuration_) The sorted array of search hits. This array can be empty.
*   `next` (_result\_page_) The data that can be used (as parameters on the search request) to retrieve the next result page.
*   `previous` (_result\_page_) The data that can be used (as parameters on the search request) to retrieve the previous result page.
*   `query` (_query_) The query passed into the search
*   `select` (_string_) The field to be selected.
*   `sorts` (_array of sort_) The list of sort clauses configured for the search request. Sort clauses are optional.
*   `start` (_integer (int32)_) The zero-based index of the first search hit to include in the result.  
    Minimum: 0.
*   `total` (_integer (int32)_) The number of returned documents

_Example_

```
{
  "count": 1,
  "hits": [
    {
      "_resource_state": "860cde3040519cce439cd99e209f8a87c3ad0b7e2813edbf6f5501f763b73bd5",
      "callout_msg": {
        "de-DE": "Deutsche Nachricht",
        "default": "some message",
        "en-US": "US american message"
      },
      "configuration_id": "header_banner_html",
      "context": "category",
      "context_id": "men_shoes",
      "customer_groups": [
        "Administrators",
        "Registered"
      ],
      "default": true,
      "description": "slot configuration description",
      "enabled": true,
      "link": "https://example.com/s/-/dw/data/{version}/sites/SiteGenesis/slots/header-banner/slot_configurations/fsdoi43ofijwdf?context=category%3Dmen_shoes",
      "rank": 2,
      "schedule": {
        "end_date": "2022-03-28T23:21:00.000Z",
        "recurrence": {
          "day_of_week": [
            "monday",
            "sunday"
          ],
          "time_of_day": {
            "time_from": "00:00:00",
            "time_to": "23:59:00"
          }
        },
        "start_date": "2013-03-28T23:21:00.000Z"
      },
      "slot_content": {
        "body": {
          "de-DE": "<html>HTML Inhalt</html>",
          "default": "<html>HTML content</html>",
          "en-US": "<html>HTML content</html>"
        },
        "type": "html"
      },
      "slot_id": "header-banner"
    }
  ],
  "select": "(**)",
  "start": 0
}
```

### query

Document representing a query. A query contains a set of objects that define criteria used to select records. A query can contain one of the following:

*   match\_all\_query - returns all records.
    
*   term\_query - matches records where a field (or fields) exactly match some simple value (including null).
    
*   text\_query - matches records where a field (or fields) contain a search phrase.
    
*   boolean\_query - formulates a complex boolean expression using query objects as criteria.
    
*   filtered\_query - allows for filtering of records based on both a query and a filter.
    

Type: `any`.

### sort

Document representing a sort request.

*   `field` (_string_, required) The name of the field to sort on.
*   `sort_order` (_string_) The sort order to be applied when sorting. When omitted, the default sort order (ASC) is used.  
    Allowed values: `asc`, `desc`.

_Example_

```
{
  "field": "id",
  "sort_order": "asc"
}
```

### cause

*   `cause` (_cause_)
*   `message` (_string_)
*   `type` (_string_)

### slot\_configuration

Document representing a slot configuration.

*   `assignment_information` (_slot\_configuration\_assignment\_information_) Information about the assignments and assignment schedules of this slot configuration
*   `callout_msg` (_object (localized)_) The call out message.
    
    Additional properties: `markup_text`.
    
*   `configuration_id` (_string_) The id of this configuration.  
    Minimum length: 1. Maximum length: 256.
*   `context` (_string_) The context of the slot. Ignored in input documents.  
    Allowed values: `global`, `category`, `folder`.
*   `context_id` (_string_) When the context is _category_, this is a _category\_id_; when the context is _folder_, this is a _folder\_id_; and when the context is _global_, this is obsolete. This is ignored in input documents.
*   `creation_date` (_string (date-time)_, read-only) Returns the value of attribute 'creationDate'.
*   `customer_groups` (_array of string_) The customer groups ids.
*   `default` (_boolean_) A flag indicating whether the configuration is the default one for the slot.
*   `description` (_string_) The configuration description.  
    Maximum length: 4000.
*   `enabled` (_boolean_) A flag indicating whether the slot is enabled.
*   `last_modified` (_string (date-time)_, read-only) Returns the value of attribute 'lastModified'.
*   `link` (_string_) The link.
*   `rank` (_integer (int32)_) The rank of the slot configuration on its slot. This rank has nothing to do with the rank on any campaign-assignment, because these are completely different objects. These must be updated separately.  
    Allowed values: `10`, `20`, `30`, `40`, `50`, `60`, `70`, `80`, `90`, `100`. Minimum: 1.
*   `schedule` (_schedule_) The schedule for the slot.
*   `slot_content` (_slot\_content_, required) The content of the slot.
*   `slot_id` (_string_) The ID of the slot. Ignored in input documents.  
    Minimum length: 1. Maximum length: 256.
*   `template` (_string_) The template.  
    Maximum length: 256.
*   `uuid` (_string_, read-only) The uuid of the slot configuration. This property cannot be written and is ignored in input documents.  
    Minimum length: 1. Maximum length: 28.

_Example_

```
{
  "assigned_to_site": true,
  "callout_msg": {
    "default": "some message"
  },
  "configuration_id": "2015-06-24_16:33:18",
  "context": "global",
  "customer_groups": [
    "Administrators",
    "Registered"
  ],
  "default": true,
  "description": "slot configuration description",
  "enabled": true,
  "rank": 2,
  "schedule": {
    "end_date": "2022-03-28T23:21:00.000Z",
    "recurrence": {
      "day_of_week": [
        "monday",
        "sunday"
      ],
      "time_of_day": {
        "time_from": "00:00:00",
        "time_to": "23:59:00"
      }
    },
    "start_date": "2013-03-28T23:21:00.000Z"
  },
  "slot_content": {
    "body": {
      "default": "<html>HTML content</html>"
    },
    "type": "html"
  },
  "slot_id": "header-banner",
  "uuid": "fsdoi43ofijwdf"
}
```

### result\_page

Data that can be used to get the next and previous page of a Data API results object.

*   `count` (_integer (int32)_) The number of returned documents.
*   `db_start_record_` (_integer (int32)_) The zero-based index of the record that we want to start with, used to optimize special handling
*   `start` (_integer (int32)_) The zero-based index of the first search hit to include in the result.

### slot\_configuration\_assignment\_information

*   `abtest_id` (_string_) If there is only one assignment, and that assignment is an A/B test segment, the id of the A/B test the segment belongs to. Otherwise, empty.
*   `abtest_segment_id` (_string_) If there is only one assignment, and that assignment is an A/B test segment, the id of the A/B test segment. Otherwise, empty.
*   `active` (_boolean_) true if the individual assignment or the multiple assignments are currently active (applicable only for non default schedule assignments i.e. either campaign or A/B test schedule).
*   `active_abtest_assignments` (_array of slot\_configuration\_abtest\_group\_assignment_) A list of currently active A/B tests this is assigned to.
*   `active_campaign_assignments` (_array of slot\_configuration\_campaign\_assignment_) A list of currently active campaigns this is assigned to.
*   `campaign_id` (_string_) If there is only one assignment, and that assignment is a campaign, the id of the campaign. Otherwise, empty.
*   `enabled` (_boolean_)
*   `end_date` (_string (date-time)_) The end date of the container of the assignment (a Campaign or ABTest). If schedule\_type is schedule\_type : "multiple" or schedule\_type : "none", then then result will be null. Also, a null date will also return null.
*   `schedule` (_schedule_) The schedule of the assignment (a Campaign or ABTest). If schedule\_type is schedule\_type : "multiple" or schedule\_type : "none", then then result will be null.
*   `schedule_type` (_string_) If there is only one active assignment, or no active assignments and one upcoming assignment, this is that type of assignment (schedule\_type : "campaign" or schedule\_type : "abtest"). If there are no assignments, it will be schedule\_type : "none", otherwise, schedule\_type : "multiple".  
    Allowed values: `none`, `campaign`, `abtest`, `multiple`.
*   `start_date` (_string (date-time)_) The start date of the container of the assignment (a Campaign or ABTest). If schedule\_type is schedule\_type : "multiple" or schedule\_type : "none", then then result will be null. Also, a null date will also return null.
*   `upcoming_abtest_assignments` (_array of slot\_configuration\_abtest\_group\_assignment_) A list of upcoming A/B tests this is assigned to.
*   `upcoming_campaign_assignments` (_array of slot\_configuration\_campaign\_assignment_) A list of upcoming campaigns this is assigned to.

_Example_

```
{
  "active": false,
  "enabled": false,
  "schedule_type": "none"
}
```

### markup\_text

*   `markup` (_string_) The rendered HTML (read only)
*   `source` (_string_) The raw markup text (only this needs to be provided in update request)

### schedule

Document representing a time schedule for slots.

*   `end_date` (_string (date-time)_) The date to end of validity. ISO8601 date time format: yyyy-MM-dd'T'HH:mm:ssZ.
*   `recurrence` (_recurrence_) The recurrence of the schedule by day of week and time of day. Not all schedules will support a recurrence.
*   `start_date` (_string (date-time)_) The date to start validity. ISO8601 date time format: yyyy-MM-dd'T'HH:mm:ssZ.

_Example_

```
{
  "end_date": "2050-01-01T00:00:00.000Z",
  "start_date": "2000-01-01T00:00:00.000Z"
}
```

### slot\_content

Document representing the content type for a slot.

*   `body` (_object (localized)_) The HTML body (valid only for type 'html').
    
    Additional properties: `markup_text`.
    
*   `category_ids` (_array of string_) The category ids (valid only for type 'categories').
*   `content_asset_ids` (_array of string_) The content asset ids (valid only for type 'content\_assets').
*   `product_ids` (_array of string_) The product ids (valid only for type 'products').
*   `type` (_string_, required) The type of content in the slot.  
    Allowed values: `products`, `categories`, `content_assets`, `html`, `recommended_products`.

_Example_

```
{
  "type": "html"
}
```

### slot\_configuration\_abtest\_group\_assignment

Document representing a SlotConfiguration AB test group assignment

*   `abtest_description` (_string_) The description for the ABTest assigned to the slot configuration in the SlotConfiguration AB test group assignment.
*   `abtest_id` (_string_) The id for the ABTest assigned to the slot configuration in the SlotConfiguration AB test group assignment.
*   `enabled` (_boolean_) True if the ABTest is enabled
*   `schedule` (_schedule_) The schedule information for the ABTest. Recurrence information is not supported.
*   `segment_description` (_string_) The description for the ABTest segment assigned to the slot configuration in the SlotConfiguration AB test group assignment.
*   `segment_id` (_string_) The id for the ABTest segment assigned to the slot configuration in the SlotConfiguration AB test group assignment.

### slot\_configuration\_campaign\_assignment

Document representing a slot\_configuration\_campaign\_assignment

*   `campaign` (_campaign_) The campaign.
*   `campaign_id` (_string_) The id of the campaign that has the slot configuration assigned to it.  
    Minimum length: 1. Maximum length: 256.
*   `context` (_string_, required) The slot context.  
    Allowed values: `global`, `category`, `folder`.
*   `creation_date` (_string (date-time)_)
*   `customer_groups` (_array of string_) The list of customer groups.
*   `description` (_string_) The description of the slot configuration.  
    Maximum length: 4000.
*   `enabled` (_boolean_) True if the assignment resource is enabled
*   `last_modified` (_string (date-time)_)
*   `link` (_string_) The URL to the slot configuration-campaign assignment.
*   `rank` (_integer (int32)_) The rank of the slot confiuration-campaign assignment. This is different than the rank of the slot configuration.  
    Minimum: 1.
*   `schedule` (_schedule_) The schedule of the assignment resource
*   `slot_configuration` (_slot\_configuration_) The slotConfiguration
*   `slot_configuration_id` (_string_, required) The ID of the slot configuration.  
    Minimum length: 1. Maximum length: 256.
*   `slot_configuration_uuid` (_string_) The UUID of the slot configuration.  
    Maximum length: 28.
*   `slot_context_id` (_string_) The ID of the slot's context, for example, the category ID for a slot with category context.  
    Maximum length: 256.
*   `slot_id` (_string_, required) The ID of the slot.  
    Minimum length: 1. Maximum length: 256.

_Example_

```
{
  "campaign_id": "campaign-registered",
  "context": "global",
  "description": "Free Microsoft Zune With Purchase Of $500 Or More In Electronics",
  "enabled": true,
  "link": "https://example.com/s/-/dw/data/{version}/sites/SiteGenesis/slot_configuration_campaign_assignments/campaign-registered",
  "schedule": {},
  "slot_configuration": {
    "assignment_information": {
      "active": true,
      "active_campaign_assignments": {
        "campaign_id": "campaign-registered",
        "context": "global",
        "enabled": true,
        "rank": 40
      }
    }
  },
  "slot_configuration_id": "Promo Zune",
  "slot_configuration_uuid": "bdL6MiWcbpakEaaadkHwIhZj1N",
  "slot_id": "404-promo"
}
```

### recurrence

Document representing a schedule recurrence.

*   `day_of_week` (_array of string_) The days of week for recurrence.  
    Items: Allowed values: `monday`, `tuesday`, `wednesday`, `thursday`, `friday`, `saturday`, `sunday`. Allowed values: `monday`, `tuesday`, `wednesday`, `thursday`, `friday`, `saturday`, `sunday`.
*   `time_of_day` (_time\_of\_day_) The time of the day for recurrence.

_Example_

```
{
  "day_of_week": [
    "thursday",
    "sunday",
    "saturday"
  ],
  "time_of_day": {
    "time_from": "01:14:00",
    "time_to": "20:00:00"
  }
}
```

### campaign

Document representing a campaign.

*   `campaign_id` (_string_) The ID of the campaign.  
    Minimum length: 1. Maximum length: 256.
*   `coupons` (_array of string_) The array of assigned coupon IDs, not sorted
*   `creation_date` (_string (date-time)_, read-only) Returns the value of attribute 'creationDate'.
*   `customer_groups` (_array of string_) The array of assigned customer groups, not sorted
*   `description` (_string (text)_) The description of the campaign.  
    Maximum length: 4000.
*   `enabled` (_boolean_) The enabled flag for campaign.
*   `end_date` (_string (date-time)_) The date that the Scenario ends
*   `last_modified` (_string (date-time)_, read-only) Returns the value of attribute 'lastModified'.
*   `link` (_string_) link for convenience
*   `source_code_groups` (_array of string_) The array of assigned source code groups, not sorted
*   `start_date` (_string (date-time)_) The date that the Scenario begins

_Example_

```
{
  "coupons": [
    "testCoupon"
  ],
  "customer_groups": [
    "Registered"
  ],
  "description": "My Campaign",
  "enabled": true,
  "end_date": "2015-07-31T23:09:08.000Z",
  "link": "https://example.com/s/-/dw/data/{version}/sites/SiteGenesis/campaigns/my-campaign",
  "source_code_groups": [
    "WapiSourceCodeGroup1"
  ],
  "start_date": "2015-04-01T11:30:15.000Z"
}
```

### time\_of\_day

Document representing a time schedule within a single day.

*   `time_from` (_string (time)_) The time to start from. Time format: HH:mm:ss. Seconds are ignored and set to 0.
*   `time_to` (_string (time)_) The time to end on. Time format: HH:mm:ss. Seconds are ignored and set to 0.

_Example_

```
{
  "time_from": "01:14:00",
  "time_to": "20:00:00"
}
```

### bool\_filter

Document representing a boolean filter.

A boolean filter allows you to combine other filters into (possibly recursive) logical expression trees. A boolean filter is configured with a boolean operator (AND, OR, NOT) and a list of filters the operator relates to. If multiple filters are given to a boolean NOT operator, this is interpreted as a NOT upon a boolean OR of the given filters.

**Example:** (id="myId" AND coupon\_id="couponOne")

query: {
filtered\_query: {
query: { match\_all\_query: {} },
filter: {
bool\_filter: {
operator: "and",
filters: \[
{ term\_filter: { field: "id", operator: "is", values: \["myId"\] } },
{ term\_filter: { field: "coupon\_id", operator: "is", values: \["couponOne"\] } }
\]
}
}
}
}

**Example:** (id="holidaySale" OR redemption\_count BETWEEN(1, 20)

query: {
filtered\_query: {
query: { match\_all\_query: {} },
filter: {
bool\_filter: {
operator: "or",
filters: \[
{ term\_filter: { field: "id", operator: "is", values: \["holidaySale"\] } },
{ range\_filter: { field: "redemption\_count", from: 1, to: 20 } }
\]
}
}
}
}

**Example:** NOT(enabled=false OR coupon\_id="special")

query: {
filtered\_query: {
query: { match\_all\_query: {} },
filter: {
bool\_filter: {
operator: "not",
filters: \[
{ term\_filter: { field: "enabled", operator: "is", values: \[false\] } },
{ term\_filter: { field: "coupon\_id", operator: "is", values: \["special"\] } }
\]
}
}
}
}

*   `filters` (_array of filter_) A list of filters, which are logically combined by an operator.
*   `operator` (_string_, required) The logical operator the filters are combined with.  
    Allowed values: `and`, `or`, `not`.

### bool\_query

A boolean query allows construction of full logical expression trees consisting of other queries (usually term and text queries). A boolean query basically has 3 sets of clauses that 'must', 'should' and / or 'must not' match. If 'must', 'must\_not', or 'should' appear in the same boolean query, they are combined logically using the AND operator. The difference between must and should operators is that the must operator requires all subqueries to match whereas the should operator only requires one match

**Example:** (id = 'foo' AND description LIKE 'bar')

query: {
bool\_query: {
must: \[
{ term\_query: { fields: \["id"\], operator: "is", values: \["foo"\] } },
{ text\_query: { fields: \["description"\], search\_phrase: "bar" } }
\]
}
}

**Example:** (id = 'foo' OR description LIKE 'bar')

query: {
bool\_query: {
should: \[
{ term\_query: { fields: \["id"\], operator: "is", values: \["foo"\] } },
{ text\_query: { fields: \["description"\], search\_phrase: "bar" } }
\]
}
}

**Example:** (NOT (id = 'foo' AND description LIKE 'bar'))

query: {
bool\_query: {
must\_not: \[
{ term\_query: { fields: \["id"\], operator: "is", values: \["foo"\] } },
{ text\_query: { fields: \["description"\], search\_phrase: "bar" } }
\]
}
}

**Example:** ((coupon\_id LIKE "limit" AND description LIKE "limit per customer") AND NOT (enabled=false))

query: {
bool\_query: {
must: \[
{ text\_query: { fields: \[ "coupon\_id" \], search\_phrase: "limit" } },
{ text\_query: { fields: \[ "description" \], search\_phrase: "limit per customer" } }
\],
must\_not: \[
{ term\_query: { fields: \[ "enabled" \], operator: "is", values: \[false\] } }
\]
}
}

*   `must` (_array of query_) List of queries that must match.
*   `must_not` (_array of query_) List of queries that must not match.
*   `should` (_array of query_) List of queries that should match (i.e., at least one query must match).

### filter

Document representing a filter.

A filter contains a set of objects that define criteria used to select records. A filter can contain one of the following:

*   term\_filter - matches records where a field (or fields) exactly match some simple value (including null).
    
*   range\_filter - matches records where a field value lies in a specified range.
    
*   query\_filter - provides filtering based on a query.
    
*   bool\_filter - provides filtering of records using a set of filters combined with a specified operator.
    

Type: `any`.

### filtered\_query

A filtered query allows to filter the result of a (possibly complex) query using a (possibly complex) filter.

**Example:**

query : {
filtered\_query: {
query: {
text\_query: { fields: \["coupon\_id"\], search\_phrase: "disabled" }
},
filter: {
term\_filter: {
field: "enabled", operator: "is", values: \[ false \]
}
}
}
}

*   `filter` (_filter_, required) The (possibly complex) filter object.
*   `query` (_query_, required) The query object.

### match\_all\_query

A match all query simply matches all documents (namespace and document type). This query comes in handy if you just want to filter a search result or really do not have any constraints.

**Example:**

query: {
match\_all\_query: {}
}

Type: `any`.

### nested\_query

A nested query queries nested documents that are part of a larger document. The classical example is a product master with variants (in one big document) where you want to constrain a search to masters that have variants that match multiple constraints (like color = blue AND size = M). This query is not compatible with some search types. **Example:** finds all the documents that has firstname = "John" and lastname = "Doe"

{
"query": {
"bool\_query": {
"must": \[
{
"nested\_query": {
"path": "order.shipping\_addresses",
"query": {
"bool\_query": {
"must": \[
{
"bool\_query": {
"must": \[
{
"term\_query": {
"fields": \[ "order.shipping\_addresses.first\_name" \],
"operator": "is",
"values": \[ "John" \]
}
}
\]
}
},
{
"bool\_query": {
"must": \[
{
"term\_query": {
"fields": \[ "order.shipping\_addresses.last\_name" \],
"operator": "is",
"values": \[ "Doe" \]
}
}
\]
}
}
\]
}
},
"score\_mode": "avg"
}
}
\]
}
}
}

*   `path` (_string_, required)
*   `query` (_query_, required)
*   `score_mode` (_string_)  
    Allowed values: `avg`, `total`, `max`, `none`.

### query\_filter

Document representing a query filter. A query filter wraps any query and allows it to be used as a filter.

**Example:** (coupon\_id contains "disabled" AND (enabled=false OR active=false))

query : {
filtered\_query: {
query: { text\_query: { fields: \["coupon\_id"\], search\_phrase: "disabled" } },
filter: {
query\_filter: {
query: {
term\_query: { fields: \["enabled","active"\], operator: "is", values: \[ false \] }
}
}
}
}
}

*   `query` (_query_, required) The query to use as a filter.

### range2\_filter

Document representing a range comparison with a range filter, named Range2Filter.

A Range2Filter allows you to restrict a search result to hits where a range defined by specified attributes has a certain relationship to a specified range.

The first range (R1) is defined by a pair of attributes ("from\_field" and "to\_field") that specify the extent of a range, such as the attributes "valid\_from" and "valid\_to".

The second range (R2) is defined by "from\_value" and "to\_value".

The filter mode specifies the method used to compare the two ranges:

*   overlap: R1 overlaps fully or partially with R2
    
*   containing: R1 contains R2
    
*   contained: R1 is contained in R2
    

The range filter supports several value types, and relies on the natural sorting of the value type for range interpretation. Value ranges can be open-ended (at one end only). You can configure whether the lower and upper bounds are inclusive or exclusive.

A range 2 filter is useful for general restrictions that can be shared between searches (like a static date range) because the filter result is cached in memory. Range filters are not appropriate if the range is expected to be different for every query (for example, if the user controls the date range down to the hour via a UI control). Range filters are inclusive by default.

**Example:** (valid dates overlap with the range January 1, 2007 through January 1, 2017)

"query" : {
"filtered\_query": {
"filter": {
"range2\_filter": {
"from\_field": "valid\_from",
"to\_field": "valid\_to",
"filter\_mode":"overlap",
"from\_value": "2007-01-01T00:00:00.000Z",
"to\_value": "2017-01-01T00:00:00.000Z"
}
},
"query": { "match\_all\_query": {} }
}
}

*   `filter_mode` (_string_) Compare mode: overlap, containing, or contained. If not specified, the default is overlap.  
    Allowed values: `overlap`, `containing`, `contained`.
*   `from_field` (_string_, required) The field name of the field that starts the first range.
*   `from_inclusive` (_boolean_) Indicates whether the lower bound of the second range is inclusive. If not specified, the default is true. Set to false to make the lower bound exclusive.
*   `from_value` (_object_) The lower bound of the second range. If not specified, the range is open-ended with respect to the lower bound. You can't leave both the lower and upper bounds open-ended.
*   `to_field` (_string_, required) The field name of the field that ends the first range.
*   `to_inclusive` (_boolean_) Indicates whether the upper bound of the second range is inclusive. If not specified, the default is true. Set to false to make the lower bound exclusive.
*   `to_value` (_object_) The upper bound of the second range. If not specified, the range is open-ended with respect to the upper bound. You can't leave both the upper and lower bounds open-ended.

### range\_filter

Document representing a range filter.

A range filter allows you to restrict a search result to hits that have values for a given attribute that fall into a given value range. The range filter supports several value types, and relies on the natural sorting of the value type for range interpretation. Value ranges can be open-ended (at one end only). You can configure whether the lower and upper bounds are inclusive or exclusive.

A range filter is useful for general restrictions that can be shared between searches (like a static date range) because the filter result is cached in memory. Range filters are not appropriate if the range is expected to be different for every query (for example, if the user controls the date range down to the hour via a UI control). Range filters are inclusive by default.

**Example:** ( redemption\_count BETWEEN (0,10\] )

query: {
filtered\_query: {
query: { match\_all\_query: {} },
filter: {
range\_filter: {
field: "redemption\_count",
from: 0,
to: 10,
from\_inclusive: false
}
}
}
}

*   `field` (_string_, required) The search field.
*   `from` (_object_) The lower bound of the filter range. If not specified, the range is open-ended with respect to the lower bound. You can't leave both the lower and upper bounds open-ended.
*   `from_inclusive` (_boolean_) Indicates whether the lower bound of the range is inclusive. If not specified, the default is true. Set to false to make the lower bound exclusive.
*   `to` (_object_) The upper bound of the filter range. If not specified, the range is open-ended with respect to the upper bound. You can't leave both the upper and lower bounds open-ended.
*   `to_inclusive` (_boolean_) Indicates whether the upper bound of the range is inclusive. If not specified, the default is true. Set to false to made the upper bound exclusive.

### term\_filter

Document representing a term filter.

A term filter allows you to restrict a search result to hits that match (exactly) one of the values configured for the filter. A term filter is useful for general restrictions that can be shared between searches. Use term filters whenever the criterion you filter on is a shared property of multiple searches (for example, like filtering by an order status). Use term filters for fields that have a discrete and small set of values only.

**Example:** (id="my\_id")

query: {
filtered\_query: {
query: { match\_all\_query: {} },
filter: {
term\_filter: {
field: "id",
operator: "is",
values: \["my\_id"\]
}
}
}
}

**Example:** (id IN ("my\_id","other\_id"))

query: {
filtered\_query: {
query: { match\_all\_query: {} },
filter: {
term\_filter: {
field: "id",
operator: "one\_of",
values: \["my\_id","other\_id"\]
}
}
}
}

**Example:** (description=NULL)

query: {
filtered\_query: {
query: { match\_all\_query: {} },
filter: {
term\_filter: {
field: "description",
operator: "is\_null"
}
}
}
}

*   `field` (_string_, required) The filter field.
*   `operator` (_string_, required) The operator to compare the field's values with the given ones.  
    Allowed values: `is`, `one_of`, `is_null`, `is_not_null`, `less`, `greater`, `not_in`, `neq`.
*   `values` (_array of object_) The filter values.

### term\_query

A term query matches one (or more) value(s) against one (or more) document field(s). A document is considered a hit if one of the values matches (exactly) with at least one of the given fields. The operator "is" can only take one value, while "one\_of" can take multiple values. If multiple fields are specified, they are combined using the OR operator. The `less` and `greater` operators are not compatible with some search types. To query based on numeric bounds in those cases, you can use a range filter on a filtered query .

**Elastic only** : If used with multiple fields, the query is internally handled as a boolean OR of DisjointMaxQueries (with the dismax matching a value against all fields). The dismax makes sure that a document carrying a single term in multiple fields does not get higher scores than a document matching multiple terms in multiple fields.

**Example:** (id="my\_id")

query: {
term\_query: {
fields: \["id"\],
operator: "is",
values: \["my\_id"\]
}
}

**Example:** (id IN ("my\_id","other\_id"))

query: {
term\_query: {
fields: \["id"\],
operator: "one\_of",
values: \["my\_id","other\_id"\]
}
}

**Example:** (id=null)

query: {
term\_query: {
fields: \["description"\],
operator: "is\_null"
}
}

**Example:** ((id IN ('generic', 'keyword')) OR (description IN ('generic', 'keyword'))

query: {
term\_query: {
fields: \["id", "description"\],
operator: "one\_of",
values: \["generic","keyword"\]
}
}

*   `fields` (_array of string_, required) The document field(s) the value(s) are matched against, combined with the operator.  
    Minimum items: 1.
*   `operator` (_string_, required) Returns the operator to use for the term query.  
    Allowed values: `is`, `one_of`, `is_null`, `is_not_null`, `less`, `greater`, `not_in`, `neq`.
*   `values` (_array of object_) The values the field(s) are compared against, combined with the operator.

### text\_query

A text query is used to match some text (i.e. a search phrase possibly consisting of multiple terms) against one or multiple fields. In case multiple fields are provided, the phrase conceptually forms a logical OR over the fields. In this case, the terms of the phrase basically have to match the text that would result from concatenating all given fields.

**Example:** (coupon\_id contains "xmas" )

query: {
text\_query: {
fields: \["coupon\_id"\],
search\_phrase: "xmas"
}
}

**Example:** (coupon\_id contains "xmas" OR description contains "xmas")

query: {
text\_query: {
fields: \["description", "coupon\_id"\],
search\_phrase: "xmas"
}
}

**Example:** (description contains "holiday" AND description contains "bojo")

query: {
text\_query: {
fields: \["description"\],
search\_phrase: "holiday bogo"
}
}

*   `fields` (_array of string_, required) The document fields the search phrase has to match.  
    Minimum items: 1.
*   `search_phrase` (_string_, required) A search phrase which may consist of multiple terms.