# Types

### Adapter Object

| Property  | Type                                   | Required | Description                      |
| --------- | -------------------------------------- | -------- | -------------------------------- |
| config    | [`ConfigObject`](#config-object)       |          | Adapter configuration settings   |
| endpoints | [`EndpointsObject`](#endpoints-object) | yes      | Adapter endpoint implementations |

#### Config Object

The `config` object controls adapter behavior and widget-specific configurations.

| Property | Type                            | Required | Description                    |
| -------- | ------------------------------- | -------- | ------------------------------ |
| widget   | [`WidgetConfig`](#widgetconfig) |          | Widget-specific configurations |

#### WidgetConfig

| Property                        | Type                | Required | Description                                            |
| ------------------------------- | ------------------- | -------- | ------------------------------------------------------ |
| `'betRecommendation.eventList'` | `BrEventListConfig` |          | Configuration for bet recommendation event list widget |

#### Endpoints Object

The `endpoints` object contains all adapter endpoint implementations.

***The\*\*\*\* ****`market`**** ****and**** ****`eventMarkets`**** \*\*\*\*endpoints are mutually exclusive – you only need to implement ONE of these two. Choose based on your API capabilities:***

* Implement **`market`** if your API can fetch a specific market for an event efficiently
* Implement **`eventMarkets`** if your API can fetch all markets for an event in a single call
* If implementing `market`, you can optionally add `availableMarketsForEvent` to list available markets first

**Shared Endpoints Across Widgets:** All widgets use the same adapter endpoints. When a specific widget needs to limit returned data, the request `args` will include a `widget` property containing the widget name (the same value used in `SIR('addWidget', widgetName, ...)`). Use this to conditionally filter or modify your response per widget if needed.

| Property                 | Type                               | Required | Description                                                                                                                                                |
| ------------------------ | ---------------------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| availableMarketsForEvent | `AvailableMarketsForEventFunction` |          | Retrieves all available markets selections for a specific event. Use with `market` endpoint to discover available markets.                                 |
| market                   | `MarketFunction`                   |          | **Implement either this OR `eventMarkets`** – Retrieves a specific market data for a specific event.                                                       |
| eventMarkets             | `EventMarketsFunction`             |          | **Implement either this OR `market`** – Retrieves all markets data for a specific event in one call. Use if your API provides all markets on one endpoint. |
| event                    | `EventFunction`                    |          | Retrieves detailed event data including event start time, scores, team names, tournament name, and more.                                                   |
| filterMarkets            | `FilterMarketsFunction`            |          | Filters available markets based on widget requirements and provided selections, returning all or a subset.                                                 |
| betSlipSelection         | `BetSlipSelectionFunction`         |          | Subscribes to the current punter's bet slip selections (their betting cart)                                                                                |
| cashBackSelections       | `CashBackSelectionsFunction`       |          | Retrieves selections eligible for cash back promotions.                                                                                                    |
| tickets                  | `TicketsFunction`                  |          | Retrieves the punter's placed bets (tickets)                                                                                                               |

```javascript
// Example adapter implementation
const adapter = {
  config: {
    widget: {
      'betRecommendation.eventList': {
        layout: { /* EventListMarketsConfig */ },
        allowedMarkets: { /* SportMarketsMap */ }
      }
    }
  },
  endpoints: {
    event: (args, callback) => {
      // Fetch and return event data
      // Return optional unsubscribe function
    },
    eventMarkets: (args, callback) => {
      // Fetch and return markets for event
    },
    market: (args, callback) => {
      // Fetch and return specific market
    }
    // ... other endpoints
  }
};
```

### Adapter Endpoints

#### Market Function

Retrieves data for a specific market of a specific event.

***The\*\*\*\* ****`market`**** ****and**** ****`eventMarkets`**** \*\*\*\*endpoints are mutually exclusive – you only need to implement ONE. If your API does not support fetching individual markets, consider using the eventMarkets endpoint instead.***

***Names such as market names, outcome names, and other text content should be provided in the language specified by\*\*\*\* ****`args.language`**** \*\*\*\*to ensure proper localization for users.***

The `oddsType` parameter specifies the current format of odds set for the widget. If you provide odds in a different format, consider updating the odds type in the widget loader configuration. See the [Widget Loader documentation](https://docs.sportradar.com/engagement-tools/adapter/broken-reference) for details on configuring odds formats.

| Argument | Type                         | Required | Description                                                                    |
| -------- | ---------------------------- | -------- | ------------------------------------------------------------------------------ |
| args     | `MarketRequest`              | yes      | Request parameters including market/outcome selection, language, and odds type |
| callback | `Callback`<`MarketResponse`> | yes      | Function to receive market data or error                                       |

**Returns:** [`UnsubscribeFunction`](https://docs.sportradar.com/engagement-tools/adapter/broken-reference) - Optional cleanup function to stop receiving updates

```javascript
// Example implementation
adapter.endpoints.market = (args, callback) => {
  // args example:
  // {
  //   selection: { event: "sr:match:123", market: "18", specifiers: "total=2.5", type: 'uf' },
  //   language: "en",
  //   oddsType: "eu"
  // }
  
  // Your implementation here - fetch specific market data based on args
  // Then call callback with the result
  callback(undefined, {
    market: {
    id: "1",
    name: "Match Winner (1X2)",
    outcomes: [
      { id: "1", name: "Home", status: "active", odds: { type: "eu", value: "2.10" } },
      { id: "X", name: "Draw", status: "active", odds: { type: "eu", value: "3.40" } },
      { id: "2", name: "Away", status: "active", odds: { type: "eu", value: "3.50" } }
    ],
    status: "active"
  },
    event: { id: "sr:match:12345", type: "uf" }
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};
```

#### EventMarkets Function

Retrieves data for all markets of a specific event.

***The\*\*\*\* ****`eventMarkets`**** ****and**** ****`market`**** \*\*\*\*endpoints are mutually exclusive – you only need to implement ONE. If your API does not support fetching all markets for requested event, consider using the market endpoint instead.***

***Names such as market names, outcome names, and other text content should be provided in the language specified by\*\*\*\* ****`args.language`**** \*\*\*\*to ensure proper localization for users.***

The `oddsType` parameter specifies the current format of odds set for the widget. If you provide odds in a different format, consider updating the odds type in the widget loader configuration. See the [Widget Loader documentation](https://docs.sportradar.com/engagement-tools/adapter/broken-reference) for details on configuring odds formats.

| Argument | Type                               | Required | Description                                                           |
| -------- | ---------------------------------- | -------- | --------------------------------------------------------------------- |
| args     | `EventMarketsRequest`              | yes      | Request parameters including event selection, language, and odds type |
| callback | `Callback`<`EventMarketsResponse`> | yes      | Function to receive markets data or error                             |

**Returns:** [`UnsubscribeFunction`](https://docs.sportradar.com/engagement-tools/adapter/broken-reference) - Optional cleanup function to stop receiving updates

```javascript
// Example implementation
adapter.endpoints.eventMarkets = (args, callback) => {
  // args example:
  // {
  //   selection: { event: "sr:match:12345", type: "uf" },
  //   language: "en",
  //   oddsType: "eu"
  // }
  
  // Your implementation here - fetch markets data based on args
  // Then call callback with the result
  callback(undefined, {
    markets: [
       {
        id: "18",
        name: "Total Goals",
        specifiers: "total=2.5",
        outcomes: [
          { id: "12", name: "Over 2.5", status: "active", odds: { type: "eu", value: "1.85" } },
          { id: "13", name: "Under 2.5", status: "active", odds: { type: "eu", value: "2.05" } }
        ],
        status: "active"
      },
      // ... other of market objects ofr this event
    ],
    event: args.selection.id
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};
```

#### Event Function

Retrieves detailed event data including event start time, scores, team names, tournament name, and more.

***Names such as team names, tournament names, and other text content should be provided in the language specified by\*\*\*\* ****`args.language`****. Event times should be converted and displayed in the timezone specified by\*\*\*\* ****`args.displayedTimezone`**** \*\*\*\*to ensure proper localization for users.***

| Argument | Type                         | Required | Description                                                          |
| -------- | ---------------------------- | -------- | -------------------------------------------------------------------- |
| args     | `EventRequest`               | yes      | Request parameters including event selection and display preferences |
| callback | `Callback`<`EventResponse>`> | yes      | Function to receive event data or error                              |

**Returns:** `UnsubscribeFunction` - Optional cleanup function to stop receiving updates

```javascript
// Example implementation
adapter.endpoints.event = (args, callback) => {
  // args example:
  // {
  //   selection: { event: "sr:match:12345", type: "uf" },
  //   language: "en",
  //   displayedTimezone: "Europe:Berlin"
  // }
  
  // Your implementation here - fetch event data based on args
  // Then call callback with the result
  callback(undefined, {
    event: {
      id: args.selection.id,
      // ... other event properties
    }
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};
```

#### AvailableMarketsForEvent Function

Retrieves all available market offering in Selection format for a requested event.

| Argument | Type                                           | Required | Description                                    |
| -------- | ---------------------------------------------- | -------- | ---------------------------------------------- |
| args     | `AvailableMarketsForEventRequest`              | yes      | Request parameters including event selection   |
| callback | `Callback`<`AvailableMarketsForEventResponse`> | yes      | Function to receive available markets or error |

**Returns:** `UnsubscribeFunction` - Optional cleanup function to stop receiving updates

```javascript
// Example implementation
adapter.endpoints.availableMarketsForEvent = (args, callback) => {
  // args example:
  // {
  //   selection: { event: "sr:match:12345", type: "uf" }
  // }
  
  // Your implementation here - fetch available markets for the event
  // Then call callback with the result
  callback(undefined, {
    selection: [
      { event: "sr:match:12345", market: "1", type: "uf" },
      { event: "sr:match:12345", market: "18", specifiers: "total=1.5" type: "uf" },
      { event: "sr:match:12345", market: "18", specifiers: "total=2.5" type: "uf" },
      // ... other market offering selections
    ]
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};
```

#### FilterMarkets Function

This endpoint is called to perform additional filtering based on widget-specific requirements or other parameters. The `widget` property in the request arguments identifies which widget is requesting the filtering, allowing you to customize market filtering logic per widget. If no filtering is required, you can simply return the input selections unchanged. Example: For Swipe Bet you only want to use market 1x2 out of all available.

| Argument | Type                                | Required | Description                                                            |
| -------- | ----------------------------------- | -------- | ---------------------------------------------------------------------- |
| args     | `FilterMarketsRequest`              | yes      | Request parameters including widget name and optional event selections |
| callback | `Callback`<`FilterMarketsResponse`> | yes      | Function to receive filtered markets or error                          |

**Returns:** `UnsubscribeFunction` - Optional cleanup function to stop receiving updates

```javascript
// Example implementation
adapter.endpoints.filterMarkets = (args, callback) => {
  // args example:
  // {
  //   widget: "swipeBet",
  //   selection: [
  //     { event: "sr:match:12345", type: "uf", market: "1" },
  //     { event: "sr:match:12345", type: "uf", market: "18", specifiers: "total=2.5" }
  //   ]
  // }
  
  // Your implementation here - filter markets based on widget and selections
  // Then call callback with the result
  // callback(undefined, {
  //   selection: [
  //     { market: "sr:match:12345", type: "uf", market: "1" },
  //     // ... filtered selections
  //   ]
  // });

  // Or just return the selection if you don't wish to filter
  callback(undefined, {
    selection: args.selection
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};
```

#### BetSlipSelection Function

Subscribes to the current punter's bet slip selections (their betting cart). Widgets use this data to display selections as selected or, depending on the widget, may hide certain selections.

| Argument | Type                                   | Required | Description                                      |
| -------- | -------------------------------------- | -------- | ------------------------------------------------ |
| args     | `undefined`                            |          | No arguments                                     |
| callback | `Callback`<`BetSlipSelectionResponse`> | yes      | Function to receive bet slip selections or error |

**Returns:** `UnsubscribeFunction` - Optional cleanup function to stop receiving updates

```javascript
// Example implementation
adapter.endpoints.betSlipSelection = (args, callback) => {
  // args is undefined for this endpoint
  
  // Your implementation here - subscribe to bet slip changes
  // Call callback whenever bet slip changes
  callback(undefined, {
    selection: [
      { event: "sr:match:12345", market: "1", outcome: "2", odds: { type: "eu", value: "1.95" } },
      // ... current bet slip selections
    ]
  });
  
  // Return unsubscribe function to stop receiving updates
  return () => {
    // Cleanup bet slip subscription
  };
};
```

#### CashBackSelections Function

Retrieves selections eligible for cash back promotions.

| Argument | Type                                     | Required | Description                                                   |
| -------- | ---------------------------------------- | -------- | ------------------------------------------------------------- |
| args     | `CashBackSelectionsRequest`              | yes      | Request parameters including widget name and event selections |
| callback | `Callback`<`CashBackSelectionsResponse`> | yes      | Function to receive cash back selections or error             |

**Returns:** `UnsubscribeFunction` - Optional cleanup function to stop receiving updates

```javascript
// Example implementation
adapter.endpoints.cashBackSelections = (args, callback) => {
  // args example:
  // {
  //   widget: "cashBack",
  //   selection: [
  //     { event: "sr:match:12345", type: "uf" },
  //     { event: "sr:match:67890", type: "uf" }
  //   ]
  // }
  
  // Your implementation here - fetch cash back eligible events
  // Then call callback with the result
  callback(undefined, {
    events: [
      { event: "sr:match:12345", type: "uf" },
      // ... events eligible for cash back
    ]
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};
```

#### Tickets Function

Retrieves the punter's placed bets (tickets).

| Argument | Type                          | Required | Description                                                                 |
| -------- | ----------------------------- | -------- | --------------------------------------------------------------------------- |
| args     | `TicketsRequest`              | yes      | Request parameters including operator ID, customer ID, and optional filters |
| callback | `Callback`<`TicketsResponse`> | yes      | Function to receive tickets or error                                        |

**Returns:** `UnsubscribeFunction` - Optional cleanup function to stop receiving updates

```javascript
// Example implementation
adapter.endpoints.tickets = (args, callback) => {
  // args example:
  // {
  //   operatorId: "operator123",
  //   endCustomerId: "customer456",
  //   events: [
  //     { id: "sr:match:12345", type: "uf" }
  //   ],
  //   channelId: "web",
  //   page: 1
  // }
  
  // Your implementation here - fetch user tickets based on args
  // Then call callback with the result
  callback(undefined, {
    tickets: [
      // array of ticket objects
    ]
  });
  
  // Return optional unsubscribe function
  return () => {
    // Cleanup subscriptions if needed
  };
};
```

### Utility Types

#### Callback\<T>

Error-first callback function pattern used by all adapter endpoints.

| Property | Type                 | Required | Description                                                      |
| -------- | -------------------- | -------- | ---------------------------------------------------------------- |
| error    | `Error \| undefined` | yes      | Error object if the operation failed, or undefined if successful |
| data     | `T \| undefined`     |          | Response data if successful, or undefined if an error occurred   |

**Type Parameters:**

* `T` - The type of data returned on success

```javascript
// Type-specific example with BetSlipSelectionResponse
betSlipSelection(args, callback) {
  // other code
  
  if (error) {
    // something went wrong, return error
    callback(error)
    return;
  }
  // Operation successful, return BetSlipSelectionResponse
  callback(undefined, { selection: { event: "sr:match:12345", market: "18", outcome: "1", odds: { type: "uk", value: "3.2", numerator: "6", denominator: "4" }} })

  // rest of code
}

```

#### UnsubscribeFunction

Optional cleanup function returned by adapter endpoints to stop receiving updates.

**Type:** `(() => void) | undefined`

When an adapter endpoint returns an `UnsubscribeFunction`, you can call it to stop receiving further callback invocations. This is useful for:

* Cleaning up subscriptions when a component unmounts
* Stopping live data updates when they are no longer needed
* Managing memory and preventing memory leaks

```javascript
endpoint(args, callback) {
  // code
  return () => {
    // Implement unsubscribe logic, e.g., remove event listener, cancel subscription
    subscription.unsubscribe();
  }
}
```

**See Also:** `Callback<T>`

### Request Types

#### EventRequest

Request parameters for fetching event data.

| Property          | Type             | Required | Description                                                                  |
| ----------------- | ---------------- | -------- | ---------------------------------------------------------------------------- |
| selection         | `SelectionEvent` | yes      | Event identifier in UF or external format                                    |
| language          | `string`         |          | Language code for localized content (e.g., "en", "de")                       |
| displayedTimezone | `string`         |          | Timezone for displaying event times (e.g., "Europe:Berlin", "Europe/London") |

```javascript
// Example usage
const eventRequest = {
  selection: { event: "sr:match:12345", type: "uf" },
  language: "en",
  displayedTimezone: "Europe:Berlin"
};

// With minimal properties
const minimalRequest = {
  selection: { event: "sr:match:67890", type: "uf" }
};
```

#### EventMarketsRequest

Request parameters for fetching all markets data for a specific event.

| Property  | Type             | Required | Description                                                                                 |
| --------- | ---------------- | -------- | ------------------------------------------------------------------------------------------- |
| selection | `SelectionEvent` | yes      | Event identifier in UF or external format                                                   |
| language  | `string`         |          | Language code for localized content (e.g., "en", "de")                                      |
| oddsType  | `string`         |          | Type of odds to display. Valid values: 'eu', 'uk', 'us', 'hong-kong', 'indonesian', 'malay' |

```javascript
// Example usage
const eventMarketsRequest = {
  selection: { id: "sr:match:12345", type: "uf" },
  language: "en",
  oddsType: "eu"
};

// With minimal properties
const minimalRequest = {
  selection: { id: "sr:match:67890", type: "uf" }
};
```

#### MarketRequest

Request parameters for fetching a specific market data for an event.

| Property  | Type                                    | Required | Description                                                                                 |
| --------- | --------------------------------------- | -------- | ------------------------------------------------------------------------------------------- |
| selection | `SelectionMarket` \| `SelectionOutcome` | yes      | Market or outcome identifier to fetch                                                       |
| language  | `string`                                | yes      | Language code for localized content (e.g., "en", "de")                                      |
| oddsType  | `string`                                | yes      | Type of odds to display. Valid values: 'eu', 'uk', 'us', 'hong-kong', 'indonesian', 'malay' |

```javascript
// Example usage with market selection
const marketRequest = {
  selection: { id: "sr:market:123", marketId: 1 },
  language: "en",
  oddsType: "eu"
};

// Example with outcome selection
const outcomeRequest = {
  selection: { id: "sr:outcome:456", outcomeId: "1" },
  language: "en",
  oddsType: "us"
};
```

#### AvailableMarketsForEventRequest

Request parameters for fetching all available markets for a specific event.

| Property  | Type             | Required | Description                               |
| --------- | ---------------- | -------- | ----------------------------------------- |
| selection | `SelectionEvent` | yes      | Event identifier in UF or external format |

```javascript
// Example usage
const availableMarketsRequest = {
  selection: { event: "sr:match:12345", type: "uf" }
};
```

#### FilterMarketsRequest

Request parameters for filtering markets based on widget configuration.

| Property  | Type                | Required | Description                                                                                    |
| --------- | ------------------- | -------- | ---------------------------------------------------------------------------------------------- |
| widget    | `string`            | yes      | Widget identifier to determine which markets to filter (e.g., "swipeBet", "betRecommendation") |
| selection | `SelectionMarket[]` |          | Optional array of market identifiers to filter markets                                         |

```javascript
// Example usage with events
const filterMarketsRequest = {
  widget: "swipeBet",
  selection: [
    { id: "sr:match:12345", type: "uf", market: "1" },
    { id: "sr:match:67890", type: "uf", market: "18", specifiers: "total=2.5" }
  ]
};

// Example with widget only
const simpleRequest = {
  widget: "betRecommendation"
};
```

#### TicketsRequest

Request parameters for fetching tickets.

| Property      | Type               | Required | Description                                                                   |
| ------------- | ------------------ | -------- | ----------------------------------------------------------------------------- |
| operatorId    | `string`           | yes      | Client/operator identifier                                                    |
| endCustomerId | `string`           | yes      | End user/customer identifier                                                  |
| events        | `SelectionEvent[]` |          | Optional array of event identifiers to filter tickets by specific events      |
| channelId     | `string`           |          | Optional channel identifier to filter tickets by virtual stadium chat channel |
| page          | `number`           |          | Optional page number for pagination                                           |

```javascript
// Example usage with all properties
const ticketsRequest = {
  operatorId: "operator123",
  endCustomerId: "customer456",
  events: [
    { id: "sr:match:12345", type: "uf" }
  ],
  channelId: "euro-league",
  page: 1
};

// Example with minimal properties
const minimalRequest = {
  operatorId: "operator123",
  endCustomerId: "customer456"
};
```

### Response Types

#### EventResponse

Response data containing event information.

| Property | Type    | Required | Description                                                               |
| -------- | ------- | -------- | ------------------------------------------------------------------------- |
| event    | `Event` | yes      | Complete event data including details, status, participants, and metadata |

```javascript
// Example response structure
const eventResponse = {
  event: {
    id: "sr:match:12345",
    sport: { id: "1", name: "Soccer" },
    category: { id: "1", name: "England" },
    tournament: { id: "17", name: "Premier League" },
    teams: [
      { id: "sr:team:1", name: "Manchester United" },
      { id: "sr:team:2", name: "Liverpool" }
    ],
    isLive: false,
    // ... additional event properties
  }
};
```

#### EventMarketsResponse

Response data containing all markets for an event.

| Property | Type        | Required | Description                                      |
| -------- | ----------- | -------- | ------------------------------------------------ |
| markets  | `Market`\[] | yes      | Array of market data for the event               |
| event    | `string`    | yes      | Event identifier string (e.g., "sr:match:12345") |

```javascript
// Example response structure
const eventMarketsResponse = {
  markets: [
     {
      id: "18",
      name: "Total Goals",
      specifiers: "total=2.5",
      outcomes: [
        { id: "12", name: "Over 2.5", status: "active", odds: { type: "eu", value: "1.85" } },
        { id: "13", name: "Under 2.5", status: "active", odds: { type: "eu", value: "2.05" } }
      ],
      status: "active"
    },
    // ... additional markets
  ],
  event: { id: "sr:match:12345", type: "uf" }
};
```

#### MarketResponse

Response data containing a specific market and event information.

| Property | Type     | Required | Description                                      |
| -------- | -------- | -------- | ------------------------------------------------ |
| market   | `Market` | yes      | Market data including outcomes and odds          |
| event    | `string` | yes      | Event identifier string (e.g., "sr:match:12345") |

```javascript
// Example response structure
const marketResponse = {
  market: {
    id: "sr:market:1",
    name: "Match Winner",
    outcomes: [
      { id: "1", name: "Home", odds: 2.5 },
      { id: "X", name: "Draw", odds: 3.0 },
      { id: "2", name: "Away", odds: 3.2 }
    ]
  },
  event: { id: "sr:match:12345", type: "uf" }
};
```

#### AvailableMarketsForEventResponse

Response data containing all available market offering as selections for an event.

| Property  | Type                 | Required | Description                                                   |
| --------- | -------------------- | -------- | ------------------------------------------------------------- |
| selection | `SelectionMarket`\[] | yes      | Array of market selection identifiers available for the event |

```javascript
// Example response structure
const availableMarketsResponse = {
  selection: [
    { event: "sr:event:1", market: "1" },
    { event: "sr:event:2", market: "18", specifiers: "total=2.5" },
    { event: "sr:event:3", market: "10" }
  ]
};
```

#### FilterMarketsResponse

Response data containing filtered market selections based on the widget identifier and input selections.

| Property  | Type                 | Required | Description                                                        |
| --------- | -------------------- | -------- | ------------------------------------------------------------------ |
| selection | `SelectionMarket`\[] | yes      | Array of event or market selections that match the filter criteria |

```javascript
// Example response structure
const filterMarketsResponse = {
  selection: [
    { event: "sr:match:12345", type: "uf", market: "1" },
    { event: "sr:match:12345", type: "uf", market: "18", specifiers: "total=2.5" }
  ]
};
```

#### BetSlipSelectionResponse

Response data containing currently selected outcomes in the bet slip.

| Property  | Type                  | Required | Description                                           |
| --------- | --------------------- | -------- | ----------------------------------------------------- |
| selection | `SelectionOutcome`\[] | yes      | Array of outcome selections currently in the bet slip |

```javascript
// Example response structure
const betSlipSelectionResponse = {
  selection: [
    { event: "sr:match:12345", market: "1", outcome: "2", odds: { type: "eu", value: "1.95" } },
    { event: "sr:match:12345", market: "18", outcome: "1", odds: { type: "uk", value: "3.2", numerator: "6", denominator: "4" }}    
  ]
};
```

#### CashBackSelectionsRequest

Request parameters for fetching cash back selections.

| Property  | Type               | Required | Description                                                         |
| --------- | ------------------ | -------- | ------------------------------------------------------------------- |
| widget    | `string`           | yes      | Widget identifier to determine the context of the cash back request |
| selection | `SelectionEvent[]` | yes      | Array of event selections to check for cash back eligibility        |

```javascript
// Example usage
const cashBackSelectionsRequest = {
  widget: "cashBack",
  selection: [
    { event: "sr:match:12345", type: "uf" },
    { event: "sr:match:67890", type: "uf" }
  ]
};
```

#### CashBackSelectionsResponse

Response data containing events eligible for cash back.

| Property | Type                | Required | Description                                                          |
| -------- | ------------------- | -------- | -------------------------------------------------------------------- |
| events   | `SelectionEvent`\[] | yes      | Array of event selections that are eligible for cash back promotions |

```javascript
// Example response structure
const cashBackSelectionsResponse = {
  events: [
    { id: "sr:match:12345", type: "uf" },
    { id: "sr:match:67890", type: "uf" }
  ]
};
```

#### TicketsResponse

Response data containing user tickets.

| Property | Type        | Required | Description                                                              |
| -------- | ----------- | -------- | ------------------------------------------------------------------------ |
| tickets  | `Ticket`\[] | yes      | Array of ticket objects containing bet information, status, and outcomes |

```javascript
// Example response structure
const ticketsResponse = {
  tickets: [
    {
      ticketId: "ticket_123456",
      bets: [
        {
          betId: "bet_001",
          selections: [
            {
              type: "uf",
              event: "sr:match:12345",
              market: "1",
              outcome: "1",
              odds: { type: "eu", value: "2.10" }
            }
          ],
          stake: [{
            type: "cash",
            currency: "USD",
            amount: "10.00",
            mode: "total"
          }]
        }
      ],
      type: "ticket",
      version: "1.0"
    }
    // ... additional tickets
  ]
};
```

### Adapter Data Types

#### SelectionEvent

Discriminated union type for identifying betting events. The `type` field discriminates between UF (Unified Feed) and external formats.

**When `type: 'uf'`**

Use this format when referencing events from the Sportradar Unified Feed (UOF).

| Property | Type     | Required | Description                                                                              |
| -------- | -------- | -------- | ---------------------------------------------------------------------------------------- |
| type     | `'uf'`   | yes      | Indicates Unified Feed format                                                            |
| event    | `string` | yes      | SR entity identifier following UOF schema (e.g., `"sr:match:12345"`, `"sr:stage:67890"`) |

**When `type: 'external'`**

Use this format when referencing events using your own client-defined identifiers.

| Property | Type         | Required | Description                                                                                                     |
| -------- | ------------ | -------- | --------------------------------------------------------------------------------------------------------------- |
| type     | `'external'` | yes      | Indicates external client-defined format                                                                        |
| event    | `string`     | yes      | Client-defined unique event identifier. Format is determined by your system (e.g., `"736977"`, `"event_12345"`) |

```javascript
// UF format - referencing a Sportradar match
const ufSelection = {
  type: "uf",
  event: "sr:match:12345"
};

// External format - referencing a client-defined event
const externalSelection = {
  type: "external",
  event: "ext:match:736977"
};
```

**See Also:** `SelectionMarket`, `SelectionOutcome`

#### SelectionMarket

Discriminated union type for identifying betting markets within events. Extends `SelectionEvent` with market-specific properties. The `type` field discriminates between UF (Unified Feed) and external formats.

**When `type: 'uf'`**

Use this format when referencing markets from the Sportradar Unified Feed (UOF).

| Property   | Type     | Required | Description                                                                                                                                                                                               |
| ---------- | -------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| type       | `'uf'`   | yes      | Indicates Unified Feed format                                                                                                                                                                             |
| event      | `string` | yes      | SR entity identifier following UOF schema (e.g., `"sr:match:12345"`)                                                                                                                                      |
| market     | `string` | yes      | Betting market identifier as defined by UOF. Retrieved from the UOF feed (e.g., `"1"` for 1x2)                                                                                                            |
| specifiers | `string` |          | Additional market data as defined by UOF. Although optional in schema, must be provided when the UOF market requires specifiers (e.g., for "Total 1.5" vs "Total 2.5", specifiers would be `"total=1.5"`) |

**When `type: 'external'`**

Use this format when referencing markets using your own client-defined identifiers.

| Property | Type         | Required | Description                                                                                   |
| -------- | ------------ | -------- | --------------------------------------------------------------------------------------------- |
| type     | `'external'` | yes      | Indicates external client-defined format                                                      |
| event    | `string`     | yes      | Client-defined unique event identifier                                                        |
| market   | `string`     | yes      | Client-defined market identifier. If not available in your system, use the outcome identifier |

```javascript
// UF format - referencing a Sportradar market
const ufMarket = {
  type: "uf",
  event: "sr:match:12345",
  market: "1"
};

// UF format with specifiers - market with line (e.g., Total goals)
const ufMarketWithSpecifiers = {
  type: "uf",
  event: "sr:match:12345",
  market: "18",
  specifiers: "total=2.5"
};

// External format - client-defined market
const externalMarket = {
  type: "external",
  event: "event_12345",
  market: "match_winner"
};
```

**See Also:** `SelectionEvent`, `SelectionOutcome`

#### SelectionOutcome

Discriminated union type for identifying specific betting outcomes within markets. Extends `SelectionMarket` with outcome-specific properties. The `type` field discriminates between UF (Unified Feed) and external formats.

**When `type: 'uf'`**

Use this format when referencing outcomes from the Sportradar Unified Feed (UOF).

| Property   | Type     | Required | Description                                                                                                       |
| ---------- | -------- | -------- | ----------------------------------------------------------------------------------------------------------------- |
| type       | `'uf'`   | yes      | Indicates Unified Feed format                                                                                     |
| event      | `string` | yes      | SR entity identifier following UOF schema (e.g., `"sr:match:12345"`)                                              |
| market     | `string` | yes      | Betting market identifier as defined by UOF                                                                       |
| specifiers | `string` |          | Additional market data as defined by UOF. Required when market uses specifiers                                    |
| outcome    | `string` | yes      | Market outcome identifier as defined by UOF. Retrieved from the UOF feed (e.g., `"1"` for home win in 1x2 market) |
| odds       | `Odds`   |          | Odds information for this outcome                                                                                 |

**When `type: 'external'`**

Use this format when referencing outcomes using your own client-defined identifiers.

| Property | Type         | Required | Description                                                      |
| -------- | ------------ | -------- | ---------------------------------------------------------------- |
| type     | `'external'` | yes      | Indicates external client-defined format                         |
| event    | `string`     | yes      | Client-defined unique event identifier                           |
| market   | `string`     | yes      | Client-defined market identifier                                 |
| outcome  | `string`     | yes      | Client-defined unique market outcome identifier                  |
| odds     | `Odds`       | yes      | Odds information for this outcome (required for external format) |

```javascript
// UF format - referencing a Sportradar outcome
const ufOutcome = {
  type: "uf",
  event: "sr:match:12345",
  market: "1",
  outcome: "1",
  odds: {
    type: "eu",
    value: "2.50"
  }
};

// UF format with specifiers
const ufOutcomeWithSpecifiers = {
  type: "uf",
  event: "sr:match:12345",
  market: "18",
  specifiers: "total=2.5",
  outcome: "12",
  odds: {
    type: "eu",
    value: "1.85"
  }
};

// External format - client-defined outcome
const externalOutcome = {
  type: "external",
  event: "event_12345",
  market: "match_winner",
  outcome: "home",
  odds: {
    type: "eu",
    value: "2.10"
  }
};
```

**See Also:** `SelectionEvent`, `SelectionMarket`, `Odds`

#### Odds

Represents betting odds in various formats with optional custom display values.

| Property           | Type     | Required | Description                                                                                                                                                           |
| ------------------ | -------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| type               | `string` | yes      | Odds format. Valid values: `'eu'` (European/Decimal), `'uk'` (UK/Fractional), `'us'` (American)                                                                       |
| value              | `string` | yes      | Odds value submitted by the client. Pattern: 1-8 digits (first cannot be 0), optionally followed by decimal point and 1-8 digits. Regex: `^[1-9]\d{0,7}(\.\d{1,8})?$` |
| numerator          | `string` |          | Numerator of fractional odds. Only present when `type` is `'uk'` (fractional). Regex: `^[1-9]\d{0,7}$`                                                                |
| denominator        | `string` |          | Denominator of fractional odds. Only present when `type` is `'uk'` (fractional). Regex: `^[1-9]\d{0,7}$`                                                              |
| customDisplayValue | `string` |          | Custom display value for odds, used as-is for display purposes. Only provide if you want to handle custom formatting                                                  |

```javascript
// European (decimal) odds
const decimalOdds = {
  type: "eu",
  value: "2.50"
};

// UK (fractional) odds
const fractionalOdds = {
  type: "uk",
  value: "3.2",
  numerator: "6",
  denominator: "4"
};

// American odds
const americanOdds = {
  type: "us",
  value: "150"
};

// With custom display value
const customOdds = {
  type: "eu",
  value: "2.50",
  customDisplayValue: "5/2"
};
```

#### Outcome

Represents a single betting outcome within a market.

| Property   | Type     | Required | Description                                                                                                                                                                                              |
| ---------- | -------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| id         | `string` | yes      | Unique identifier for the outcome, used to reference it in bets                                                                                                                                          |
| name       | `string` | yes      | Translated name of the outcome, used for display purposes                                                                                                                                                |
| competitor | `string` |          | Name or identifier of the team or player associated with this outcome. Useful for markets where each outcome is tied to a specific competitor (e.g., for 1x2 market, outcome: 1, competitor: "FC Barca") |
| odds       | `Odds`   |          | Odds information for this outcome                                                                                                                                                                        |
| status     | `string` | yes      | Outcome status. Valid values: 'active', 'inactive'                                                                                                                                                       |

```javascript
// Active outcome with odds
const outcome = {
  id: "1",
  name: "Home Win",
  competitor: "FC Barcelona",
  odds: {
    type: "eu",
    value: "2.50"
  },
  status: "active"
};

// Inactive outcome
const inactiveOutcome = {
  id: "X",
  name: "Draw",
  status: "inactive"
};
```

**See Also:** `Market`, `Odds`

#### Market

Represents a betting market with multiple outcomes.

| Property   | Type        | Required | Description                                                                                                                                                                                |
| ---------- | ----------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| id         | `string`    | yes      | Unique identifier for the market, used to reference it in bets                                                                                                                             |
| name       | `string`    | yes      | Translated name of the market, used for display purposes                                                                                                                                   |
| outcomes   | `Outcome[]` | yes      | All outcomes associated with this market                                                                                                                                                   |
| status     | `string`    | yes      | Market status. Valid values: 'active', 'deactivated', 'suspended', 'settled', 'cancelled'                                                                                                  |
| specifiers | `string`    |          | Additional market data as defined by UOF (e.g., for markets with lines like Total 1.5 vs Total 2.5). Although optional in schema, must be provided when the UOF market requires specifiers |

**Market Status Values:**

* **active**: Odds are provided and you can accept bets on the market
* **deactivated**: Odds are no longer provided for this market. Can go back to active (e.g., when a different total line becomes most balanced)
* **suspended**: Odds continue to be provided but you should not accept bets temporarily (e.g., "bet stop" before/during goal confirmation)
* **settled**: Bet settlement messages have been sent for this market, no further odds will be provided. In rare cases, settled markets may be moved to cancelled
* **cancelled**: This market has been cancelled. No further odds will be provided

```javascript
// Active market with outcomes
const market = {
  id: "1",
  name: "Match Winner (1X2)",
  outcomes: [
    { id: "1", name: "Home", status: "active", odds: { type: "eu", value: "2.10" } },
    { id: "X", name: "Draw", status: "active", odds: { type: "eu", value: "3.40" } },
    { id: "2", name: "Away", status: "active", odds: { type: "eu", value: "3.50" } }
  ],
  status: "active"
};

// Market with specifiers (Total goals)
const totalMarket = {
  id: "18",
  name: "Total Goals",
  specifiers: "total=2.5",
  outcomes: [
    { id: "12", name: "Over 2.5", status: "active", odds: { type: "eu", value: "1.85" } },
    { id: "13", name: "Under 2.5", status: "active", odds: { type: "eu", value: "2.05" } }
  ],
  status: "active"
};
```

**See Also:** `Outcome`, `Event`

#### Event

Represents a sporting event with teams, tournament information, and match details.

| Property          | Type              | Required | Description                                                      |
| ----------------- | ----------------- | -------- | ---------------------------------------------------------------- |
| id                | `string`          | yes      | Event identifier as defined by UOF. Retrieved from the MAPI feed |
| sport             | `Sport`           | yes      | Sport information (imported from adapter types)                  |
| category          | `Category`        | yes      | Category information (e.g., country, region)                     |
| tournament        | `Tournament`      | yes      | Tournament information                                           |
| teams             | \[`Team`, `Team`] | yes      | Array of exactly two teams (home and away)                       |
| isLive            | `boolean`         | yes      | Indicates whether the event is currently live                    |
| date              | `EventDate`       |          | Date information for the event                                   |
| date.displayValue | `string`          |          | Formatted date string for display                                |
| date.startTime    | `string`          |          | Event start time (ISO format)                                    |
| liveCurrentTime   | `string`          |          | Current match time for live events (e.g., "45:00", "HT")         |
| result1           | `Result`          |          | Primary result/score information                                 |
| result2           | `Result`          |          | Secondary result information (e.g., half-time score)             |
| result3           | `Result`          |          | Tertiary result information (e.g., period scores)                |

```javascript
// Pre-match event
const prematchEvent = {
  id: "sr:match:12345",
  sport: { id: "1", name: "Soccer" },
  category: { id: "1", name: "England" },
  tournament: { id: "17", name: "Premier League" },
  teams: [
    { id: "sr:team:1", name: "Manchester United" },
    { id: "sr:team:2", name: "Liverpool" }
  ],
  isLive: false,
  date: {
    displayValue: "Jan 7, 2026",
    startTime: "2026-01-07T20:00:00Z"
  }
};

// Live event with score
const liveEvent = {
  id: "sr:match:67890",
  sport: { id: "1", name: "Soccer" },
  category: { id: "1", name: "England" },
  tournament: { id: "17", name: "Premier League" },
  teams: [
    { id: "sr:team:3", name: "Chelsea" },
    { id: "sr:team:4", name: "Arsenal" }
  ],
  isLive: true,
  liveCurrentTime: "72:15",
  result1: { home: 2, away: 1 }
};
```

**See Also:** `Market`, `SelectionEvent`

#### EventDate

Represents date and time information for an event.

| Property     | Type     | Required | Description                                                   |
| ------------ | -------- | -------- | ------------------------------------------------------------- |
| displayValue | `string` |          | Formatted date string for display purposes                    |
| startTime    | `string` |          | Event start time in ISO format (e.g., "2026-01-07T20:00:00Z") |

```javascript
// Example date object
const eventDate = {
  displayValue: "Jan 7, 2026",
  startTime: "2026-01-07T20:00:00Z"
};
```

**See Also:** [`Event`](#event)

#### Ticket

Represents a betting ticket containing one or more bets.

| Property                    | Type       | Required | Description                                                                   |
| --------------------------- | ---------- | -------- | ----------------------------------------------------------------------------- |
| ticketId                    | `string`   | yes      | Client defined string to identify the ticket (unique in the client's system), |
| minimal string length = 1,  |            |          |                                                                               |
| maximum string length = 128 |            |          |                                                                               |
| bets                        | `Bet[]`    | yes      | Array of bets included in this ticket                                         |
| type                        | `'ticket'` | yes      | Declaration of content type, should be "ticket"                               |
| version                     | `1.0`      | yes      | Ticket format version                                                         |

```javascript
const ticket = {
  ticketId: "ticket_123456",
  bets: [
    {
      betId: "bet_001",
      selections: [
        {
          type: "uf",
          event: "sr:match:12345",
          market: "1",
          outcome: "1",
          odds: { type: "eu", value: "2.10" }
        }
      ],
      stake: [{
        type: "cash",
        currency: "USD",
        amount: "10.00",
        mode: "total"
      }]
    }
  ],
  type: "ticket",
  version: "1.0"
};
```

**See Also:** `Bet`, `TicketsResponse`

#### Bet

Represents a single bet within a ticket, containing selections and stake information.

| Property                                  | Type                                           | Required | Description                                                                                                                          |
| ----------------------------------------- | ---------------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| betId                                     | `string`                                       | yes      | Unique bet id (in the client's system),                                                                                              |
| minimal string length = 1,                |                                                |          |                                                                                                                                      |
| maximum length = 128                      |                                                |          |                                                                                                                                      |
| selections                                | Array<`TicketSelection` \| `SelectionOutcome`> | yes      | Array of bet selections, included in this bet. Can include custom bets (`TicketSelection`) or standard outcomes (`SelectionOutcome`) |
| minimal number of selections per bet = 1, |                                                |          |                                                                                                                                      |
| maximum number = 100                      |                                                |          |                                                                                                                                      |
| stake                                     | Array<`Stake`>                                 | yes      | Array of bet stakes,                                                                                                                 |
| minimal number of stake per bet = 1,      |                                                |          |                                                                                                                                      |
| maximum number = 5                        |                                                |          |                                                                                                                                      |
| odds                                      | `Odds`                                         |          | The odds for this bet                                                                                                                |

```javascript
// Single bet
const singleBet = {
  betId: "bet_001",
  selections: [
    {
      type: "uf",
      event: "sr:match:12345",
      market: "1",
      outcome: "1",
      odds: { type: "eu", value: "2.10" }
    }
  ],
  stake: [{
    type: "cash",
    currency: "USD",
    amount: "10.00"
  }]
};

// Accumulator bet
const accumulatorBet = {
  betId: "bet_002",
  selections: [
    {
      type: "uf",
      event: "sr:match:12345",
      market: "1",
      outcome: "1",
      odds: { type: "eu", value: "2.10" }
    },
    {
      type: "uf",
      event: "sr:match:67890",
      market: "1",
      outcome: "1",
      odds: { type: "eu", value: "1.85" }
    }
  ],
  stake: [{
    type: "cash",
    currency: "USD",
    amount: "5.00"
  }],
  odds: { type: "eu", value: "3.89" }
};

// Custom bet using TicketSelection
const customBet = {
  betId: "bet_003",
  selections: [
    {
      type: "custom-bet",
      betId: "custom_001",
      selections: [
        {
          type: "uf",
          event: "sr:match:12345",
          market: "1",
          outcome: "1",
          odds: { type: "eu", value: "2.10" }
        },
        {
          type: "uf",
          event: "sr:match:12345",
          market: "18",
          specifiers: "total=2.5",
          outcome: "12",
          odds: { type: "eu", value: "1.85" }
        }
      ],
      odds: { type: "eu", value: "3.89" }
    }
  ],
  stake: [{
    type: "cash",
    currency: "EUR",
    amount: "10.00"
  }]
};

```

**See Also:** `Ticket`, `SelectionOutcome`, `TicketSelection`, `Stake`

#### Stake

Represents stake information for a bet.

| Property | Type     | Required | Description                                                                                                                                                          |
| -------- | -------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| type     | `string` | yes      | Stake type. Valid values: 'cash' (used for stake and payout), 'bonus' (amount added on top of winnings if bet is won)                                                |
| currency | `string` | yes      | Currency code (e.g., "USD", "EUR", "GBP")                                                                                                                            |
| amount   | `string` | yes      | Stake amount as a string to allow for decimal values                                                                                                                 |
| mode     | `string` |          | Stake mode (default: 'total'). Valid values: 'unit' (stake relates to each sub-bet in system bets), 'total' (stake relates to all sub-bets, each receives a portion) |

```javascript
// Cash stake with total mode
const cashStake = {
  type: "cash",
  currency: "USD",
  amount: "10.00",
  mode: "total"
};

// Bonus stake
const bonusStake = {
  type: "bonus",
  currency: "EUR",
  amount: "5.00"
};

// Unit stake for system bet
const unitStake = {
  type: "cash",
  currency: "GBP",
  amount: "2.00",
  mode: "unit"
};
```

**See Also:** `Bet`

#### TicketSelection

Represents a custom bet selection within a ticket.

| Property   | Type                 | Required | Description                                             |
| ---------- | -------------------- | -------- | ------------------------------------------------------- |
| type       | `'custom-bet'`       | yes      | Type identifier, always 'custom-bet'                    |
| betId      | `string`             |          | Optional unique identifier for this custom bet          |
| selections | `SelectionOutcome[]` | yes      | Array of outcome selections included in this custom bet |
| odds       | `Odds`               | yes      | Odds information for this custom bet                    |

```javascript
const customBetSelection = {
  type: "custom-bet",
  betId: "custom_001",
  selections: [
    {
      type: "uf",
      event: "sr:match:12345",
      market: "1",
      outcome: "1",
      odds: { type: "eu", value: "2.10" }
    },
    {
      type: "uf",
      event: "sr:match:67890",
      market: "1",
      outcome: "2",
      odds: { type: "eu", value: "1.85" }
    }
  ],
  odds: { type: "eu", value: "3.89" }
};
```

**See Also:** `Bet`, `SelectionOutcome`

#### Sport

Represents information about a sport.

| Property | Type     | Required | Description                            |
| -------- | -------- | -------- | -------------------------------------- |
| id       | `string` |          | The unique SR identifier for the sport |
| name     | `string` |          | The name of the sport                  |
| icon     | `string` |          | URL where the sport icon is located    |

```javascript
const soccer = {
  id: "1",
  name: "Soccer",
  icon: "https://example.com/icons/soccer.png"
};

const basketball = {
  id: "2",
  name: "Basketball"
};
```

**See Also:** `Event`, `Category`

#### Category

Represents information about a category (e.g., country, region).

| Property | Type     | Required | Description                                         |
| -------- | -------- | -------- | --------------------------------------------------- |
| id       | `string` |          | The unique identifier assigned to the category      |
| name     | `string` |          | The name of the category                            |
| cc       | `object` |          | Country code information                            |
| cc.a2    | `string` | yes      | Country code in A2 format (if cc object is present) |

```javascript
const england = {
  id: "1",
  name: "England",
  cc: {
    a2: "GB"
  }
};

const spain = {
  id: "32",
  name: "Spain"
};
```

**See Also:** `Event`, `Sport`

#### Tournament

Represents information about a tournament.

| Property   | Type               | Required | Description                                      |
| ---------- | ------------------ | -------- | ------------------------------------------------ |
| id         | `string`           |          | The unique identifier assigned to the tournament |
| externalId | `string \| number` |          | Your unique identifier for the tournament        |
| name       | `string`           |          | The name of the tournament                       |

```javascript
const premierLeague = {
  id: "17",
  externalId: "PL2025",
  name: "Premier League"
};

const championsLeague = {
  id: "7",
  name: "UEFA Champions League"
};
```

**See Also:** `Event`, `Category`

#### Team

Represents information about a team participating in an event.

| Property | Type     | Required | Description                                   |
| -------- | -------- | -------- | --------------------------------------------- |
| id       | `string` |          | The unique SR identifier assigned to the team |
| name     | `string` | yes      | The name of the team                          |

```javascript
const manchesterUnited = {
  id: "sr:team:1",
  name: "Manchester United"
};

const liverpool = {
  name: "Liverpool FC"
};
```

**See Also:** `Event`

#### Result

Represents result/score information for an event.

| Property | Type                      | Required | Description                                           |
| -------- | ------------------------- | -------- | ----------------------------------------------------- |
| result   | `Array<number \| string>` | yes      | The result of the event (e.g., scores, statistics)    |
| label    | `string`                  |          | Optional label describing what this result represents |

```javascript
// Match score
const finalScore = {
  result: [2, 1],
  label: "Final Score"
};

// Half-time score
const halftimeScore = {
  result: [1, 0],
  label: "Half-time"
};

// Period scores
const periodScores = {
  result: [25, 20, 30, 18],
  label: "Quarter Scores"
};
```

**See Also:** `Event`

### Adapter Config

#### BrEventListConfig

Configuration for the bet recommendation event list widget. Note: The `allowedMarkets` and `blockedMarkets` properties are only applicable when using hosted Sportradar type with UOF (Unified Odds Feed) IDs.

| Property       | Type                     | Required | Description                                        |
| -------------- | ------------------------ | -------- | -------------------------------------------------- |
| layout         | `EventListMarketsConfig` | yes      | Market layout configuration per sport              |
| allowedMarkets | `SportMarketsMap`        |          | Markets allowed for this widget, keyed by sport ID |
| blockedMarkets | `SportMarketsMap`        |          | Markets blocked for this widget, keyed by sport ID |

```javascript
const brEventListConfig = {
  layout: {
    "1": {  // Soccer
      sportId: 1,
      markets: [
        {
          title: "1X2",
          preMatchMarketId: 1,
          liveMarketId: 1,
          columns: ["1", "X", "2"]
        },
        {
          title: "Total",
          preMatchMarketId: 18,
          liveMarketId: 18,
          showSpecifier: true,
          columns: ["Over", "Under"]
        }
      ]
    }
  },
  allowedMarkets: {
    "1": {
      "1": true,     // Allow 1X2 market with all specifiers
      "18": ["2.5"]  // Allow Total market only with 2.5 specifier
    }
  }
};
```

**See Also:** `EventListMarketsConfig`, `SportMarketsMap`

#### SportMarketsMap

A map of sport IDs to their market configurations with specifier filtering. Only applicable when using hosted Sportradar type with UOF (Unified Odds Feed) IDs.

| Property   | Type                         | Required | Description                                                                                   |
| ---------- | ---------------------------- | -------- | --------------------------------------------------------------------------------------------- |
| \[sportId] | `Record<string, Specifiers>` | yes      | Market configurations for a sport, where keys are market IDs and values are specifier filters |

**Specifiers Type:**

* `true` - Allow/block market with all specifiers
* `string[]` - Allow/block market only with specific specifiers (e.g., `["2.5", "3.5"]` for Total markets)

```javascript
const sportMarketsMap = {
  "1": {                    // Soccer (sport ID 1)
    "1": true,              // 1X2 market - all specifiers
    "18": ["2.5", "3.5"],   // Total market - only 2.5 and 3.5 lines
    "16": ["0:1", "1:0"]    // Handicap - only specific lines
  },
  "2": {                    // Basketball (sport ID 2)
    "219": true,            // Money Line
    "225": ["180.5", "200.5"]  // Total Points - specific lines
  }
};
```

#### EventListMarketsConfig

Configuration for market layout display in event lists. This is a `Record<string, SportLayoutConfig>` where keys are sport IDs and values are layout configurations.

**Type:** `Record<string, SportLayoutConfig>`

**SportLayoutConfig**

| Property | Type                    | Required | Description                           |
| -------- | ----------------------- | -------- | ------------------------------------- |
| sportId  | `string \| number`      | yes      | Sport identifier                      |
| markets  | `MarketLayoutConfig`\[] | yes      | Array of market layout configurations |

**MarketLayoutConfig**

| Property         | Type                            | Required | Description                                                     |
| ---------------- | ------------------------------- | -------- | --------------------------------------------------------------- |
| title            | `string`                        |          | Display title for the market column                             |
| preMatchMarketId | `string \| number`              |          | Market ID to use for pre-match events                           |
| liveMarketId     | `string \| number`              |          | Market ID to use for live events                                |
| showSpecifier    | `boolean`                       |          | Whether to display the market specifier (e.g., "2.5" for Total) |
| columns          | `Array<string \| ColumnConfig>` |          | Column definitions for outcome display                          |

**ColumnConfig**

| Property | Type     | Required | Description                          |
| -------- | -------- | -------- | ------------------------------------ |
| id       | `string` | yes      | Outcome ID to display in this column |
| title    | `string` |          | Custom column title                  |
| tKey     | `string` |          | Translation key for the column title |

```javascript
const eventListMarketsConfig = {
  "1": {  // Soccer
    sportId: 1,
    markets: [
      {
        title: "1X2",
        preMatchMarketId: 1,
        liveMarketId: 1,
        columns: ["1", "X", "2"]
      },
      {
        title: "Total",
        preMatchMarketId: 18,
        liveMarketId: 18,
        showSpecifier: true,
        columns: [
          { id: "12", title: "Over" },
          { id: "13", title: "Under" }
        ]
      }
    ]
  },
  "2": {  // Basketball
    sportId: 2,
    markets: [
      {
        title: "Money Line",
        preMatchMarketId: 219,
        liveMarketId: 219,
        columns: ["1", "2"]
      }
    ]
  }
};
```

**See Also:** [`BrEventListConfig`](#breventlistconfig)