# Introduction

The Time Slots API allows you to retrieve availability information for time slots at a reservation location on and around a given date and for a given party size.

A time slot represents a period of time in a restaurant’s calendar. Time slots can have any duration, and restaurants generally set their durations based on party size.

The following factors influence whether a time slot at a reservation location is available:
* The size of the party that must be seated.
* The reservation location’s table and seat pacing rules.
* The reservation location’s business schedule (operating hours).
* Existing reservations at the reservation location.

With the Time Slots API, you can:

* Check the reservation location availability in a specific time slot.
* Get time slots for a reservation location.
* Get scheduled time slots for a reservation location. Scheduled time slots are time slots within a restaurant's opening hours as defined in the reservation location's `businessSchedule`. For more information, see [`getScheduledTimeSlots()`](portalId::b85dea5b-341b-493b-b99e-4d4ca12baaa2resourceId::cf739cec-afb3-401e-bd91-50de2656f1bdslug::get-scheduled-time-slots*fallback::https://dev.wix.com/docs/sdk/backend-modules/table-reservations/time-slots/get-scheduled-time-slots).

A time slot can have the following statuses:
* `AVAILABLE` - The restaurant is open and available to seat a party of the given size at the given date and time.
* `UNAVAILABLE` - The restaurant is open but unable to seat a party of the given size at the given date and time.
* `NON_WORKING_HOURS` - The restaurant is not open at this time.

`timeSlot` objects also indicate whether manual approval is required to make a reservation at the given reservation location.

## Before you begin
It’s important to note the following points before starting to code:
* The Wix user must install the Wix Table Reservations app.
* The Wix user must have at least 1 location configured in the Dashboard under [Business Info](fallback::https://www.wix.com/my-account/site-selector/?buttonText=Select%20Site&title=Select%20a%20Site&autoSelectOnSingleSite=true&actionUrl=https:%2F%2Fwww.wix.com%2Fdashboard%2F%7B%7BmetaSiteId%7D%7D%2Fbusiness-info).

## Terminology
For a comprehensive glossary of Table Reservations terms, see [Terminology](portalId::b85dea5b-341b-493b-b99e-4d4ca12baaa2resourceId::2c786af1-3030-4b0d-8ef0-3c6165ef4d21*fallback::https://dev.wix.com/docs/sdk/api-reference/table-reservations/terminology).

@package_metadata:@wix/table-reservations

To use the TimeSlots API, install the `@wix/table-reservations` package.

#### Install the package

Follow the installation instructions for your development environment.

| Development environment | Installation method |
|--|--|
| Wix sites (editor or IDE) | Use the [package manager](fallback::https://dev.wix.com/docs/develop-websites/articles/coding-with-velo/packages/work-with-npm-packages-in-the-editor). |
| Wix sites (local IDE) | Run `wix install @wix/table-reservations` using the [Wix CLI](fallback::https://dev.wix.com/docs/develop-websites/articles/coding-with-velo/packages/work-with-npm-packages-with-the-wix-cli).|
| Blocks apps | Use the same installation method as Wix sites. |
| CLI and self-hosted apps | Run `npm install @wix/table-reservations` or `yarn add @wix/table-reservations`. |
| Headless sites and apps | Run `npm install @wix/table-reservations` or `yarn add @wix/table-reservations`. |

#### Import the package

To import the package in your code:

```js
import { timeSlots } from '@wix/table-reservations'
```

Coding Examples

Sled Tests

Go Headless

Build Apps

Client

API Preview

Ricos

Develop Websites

API Reference

Velo

Picasso

GraphQL (Alpha)

TimeSlots

Time Slots 1 0 0

ID of the reservation location for which to check the time slot.

reservationLocationId

string

options

CheckTimeSlotOptions

Checks a restaurant's availability to accommodate a reservation for a given party size in a given time slot.

 `checkTimeSlot()` returns availability information for the restaurant's table combinations, and flags any party pacing or seat pacing conflicts that the proposed reservation would cause.

import { timeSlots } from '@wix/table-reservations';

async function checkTimeSlot(reservationLocationId, options) {
  const response = await timeSlots.checkTimeSlot(reservationLocationId, options);
};

checkTimeSlot

import { timeSlots } from '@wix/table-reservations';
import { auth } from '@wix/essentials';

async function myCheckTimeSlotMethod(reservationLocationId, options) {
  const elevatedCheckTimeSlot = auth.elevate(timeSlots.checkTimeSlot);
  const response = await elevatedCheckTimeSlot(reservationLocationId, options);
}

checkTimeSlot (with elevated permissions)

import { createClient } from '@wix/sdk';
import { timeSlots } from '@wix/table-reservations';
// Import the auth strategy for the relevant access type
// Import the relevant host module if needed

const myWixClient = createClient ({
  modules: { timeSlots },
  // Include the auth strategy and host as relevant
});


async function checkTimeSlot(reservationLocationId, options) {
  const response = await myWixClient.timeSlots.checkTimeSlot(reservationLocationId, options);
};

Self-hosted SDK calls require you to [create a client](https://dev.wix.com/docs/sdk/articles/work-with-the-sdk/about-the-wix-client).

checkTimeSlot (self-hosted)

Manage Reservations (Medium)

CheckTimeSlotResponse

ID of the reservation location for which to retrieve time slots.

Size of the party that needs to be seated during this time slot.

Min: `1`

partySize

number

GetScheduledTimeSlotsOptions

Returns a list of scheduled time slots at a specified reservation location for a specified time range, and their availability for a specified `partySize`.

Scheduled time slots are sequential time periods whose start times fall within a restaurant's opening hours. Opening hours are defined in the reservation location's `businessSchedule`.

[Experiences](https://dev.wix.com/docs/api-reference/business-solutions/restaurants/wix-restaurants-new/reservations/experiences/introduction) have their own business schedules that override that of the reservation location. To get scheduled time slots for an experience, pass the ID of that experience to this method.

If a restaurant is open during distinct time periods throughout the week, the `startDate` of the first scheduled time slot returned for each period is the same as starting time of that time period.
If a restaurant is always open, the `startDate` of the first returned scheduled time slot for each week is Sunday at `00:00`.

The duration of scheduled time slots and the interval between their `startDate`s is determined by the reservation location's `timeSlotInterval`.

For example:

A restaurant is open every night from `22:30` to `03:55` with a `timeSlotInterval` of 1 hour.
If you called this method with the time range `23:00` to `02:50`, it would return time slots starting at `23:30`, `00:30`, `01:30`, and `02:30`.

import { timeSlots } from '@wix/table-reservations';

async function getScheduledTimeSlots(reservationLocationId, partySize, options) {
  const response = await timeSlots.getScheduledTimeSlots(reservationLocationId, partySize, options);
};

getScheduledTimeSlots

import { timeSlots } from '@wix/table-reservations';
import { auth } from '@wix/essentials';

async function myGetScheduledTimeSlotsMethod(reservationLocationId, partySize, options) {
  const elevatedGetScheduledTimeSlots = auth.elevate(timeSlots.getScheduledTimeSlots);
  const response = await elevatedGetScheduledTimeSlots(reservationLocationId, partySize, options);
}

getScheduledTimeSlots (with elevated permissions)

import { createClient } from '@wix/sdk';
import { timeSlots } from '@wix/table-reservations';
// Import the auth strategy for the relevant access type
// Import the relevant host module if needed

const myWixClient = createClient ({
  modules: { timeSlots },
  // Include the auth strategy and host as relevant
});


async function getScheduledTimeSlots(reservationLocationId, partySize, options) {
  const response = await myWixClient.timeSlots.getScheduledTimeSlots(reservationLocationId, partySize, options);
};

getScheduledTimeSlots (self-hosted)

Manage Reservations (Basic)

GetScheduledTimeSlotsResponse

Date and time for which to retrieve a time slot in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#coordinated_Universal_Time_(UTC)) format.

date

GetTimeSlotsOptions

Returns a list of time slots at a specified reservation location on a specified `date`, and their availability for a specified `partySize`.

Without passing optional parameters, the list will contain a single time slot at the specified `date`.
Use `slotsBefore` and `slotsAfter` to get additional time slots before and after the specified `date`.

If you do not provide a `duration`, the duration will be calculated automatically based on the reservation location's configuration.
The reservation location's settings used to determine the duration are its `defaultTurnoverTime` and `turnoverTimeRules`. These specify how much time should be allotted for a reservation of a party of a specified size.

The interval between `startDate`s of time slots in the response is determined by the reservation location's `timeSlotInterval`. This interval is not affected by the `duration` provided.

import { timeSlots } from '@wix/table-reservations';

/* Sample reservationLocationId value: 'fab8cc1f-31cf-462f-b5bb-392594624bf2'
 * Sample date value: new Date("2023-12-29T12:30:00Z")
 * Sample partySize value: 2
 */

timeSlots.getTimeSlots(reservationLocationId, new Date("2023-12-29T12:30:00Z"), partySize)
  .then((retrievedSlots) => {
    const firstStartDate = retrievedSlots.timeSlots[0].startDate;
    const firstStatus = retrievedSlots.timeSlots[0].status;

    console.log('Success! Retrieved the following time slots:', retrievedSlots);
    return retrievedSlots;
  })
  .catch((error) => {
    console.error(error);
    // Handle the error
  });

/* Promise resolves to:
 * {
 *   "timeSlots": [
 *     {
 *       "startDate": "2023-12-29T10:00:00.000Z",
 *       "duration": 90,
 *       "status": "AVAILABLE",
 *       "tableCombinations": [
 *         {
 *           "tableIds": [
 *             "1ed802ae-708f-4da6-9177-54c3df5d3dd5"
 *           ]
 *         }
 *       ],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T10:15:00.000Z",
 *       "duration": 90,
 *       "status": "AVAILABLE",
 *       "tableCombinations": [
 *         {
 *           "tableIds": [
 *             "1ed802ae-708f-4da6-9177-54c3df5d3dd5"
 *           ]
 *         }
 *       ],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T10:30:00.000Z",
 *       "duration": 90,
 *       "status": "AVAILABLE",
 *       "tableCombinations": [
 *         {
 *           "tableIds": [
 *             "1ed802ae-708f-4da6-9177-54c3df5d3dd5"
 *           ]
 *         }
 *       ],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T10:45:00.000Z",
 *       "duration": 90,
 *       "status": "AVAILABLE",
 *       "tableCombinations": [
 *         {
 *           "tableIds": [
 *             "1ed802ae-708f-4da6-9177-54c3df5d3dd5"
 *           ]
 *         }
 *       ],
 *       "manualApproval": false
 *   },
 *     {
 *       "startDate": "2023-12-29T11:00:00.000Z",
 *       "duration": 90,
 *       "status": "AVAILABLE",
 *       "tableCombinations": [
 *         {
 *           "tableIds": [
 *             "1ed802ae-708f-4da6-9177-54c3df5d3dd5"
 *           ]
 *         }
 *       ],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T11:15:00.000Z",
 *       "duration": 90,
 *       "status": "UNAVAILABLE",
 *       "tableCombinations": [],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T11:30:00.000Z",
 *       "duration": 90,
 *       "status": "UNAVAILABLE",
 *       "tableCombinations": [],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T11:45:00.000Z",
 *       "duration": 90,
 *       "status": "UNAVAILABLE",
 *       "tableCombinations": [],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T12:00:00.000Z",
 *       "duration": 90,
 *       "status": "UNAVAILABLE",
 *       "tableCombinations": [],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T12:15:00.000Z",
 *       "duration": 90,
 *       "status": "UNAVAILABLE",
 *       "tableCombinations": [],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T12:30:00.000Z",
 *       "duration": 90,
 *       "status": "UNAVAILABLE",
 *       "tableCombinations": [],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T12:45:00.000Z",
 *       "duration": 90,
 *       "status": "UNAVAILABLE",
 *       "tableCombinations": [],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T13:00:00.000Z",
 *       "duration": 90,
 *       "status": "UNAVAILABLE",
 *       "tableCombinations": [],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T13:15:00.000Z",
 *       "duration": 90,
 *       "status": "UNAVAILABLE",
 *       "tableCombinations": [],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T13:30:00.000Z",
 *       "duration": 90,
 *       "status": "UNAVAILABLE",
 *       "tableCombinations": [],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T13:45:00.000Z",
 *       "duration": 90,
 *       "status": "UNAVAILABLE",
 *       "tableCombinations": [],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T14:00:00.000Z",
 *       "duration": 90,
 *       "status": "AVAILABLE",
 *       "tableCombinations": [
 *         {
 *           "tableIds": [
 *             "1ed802ae-708f-4da6-9177-54c3df5d3dd5"
 *           ]
 *         }
 *       ],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T14:15:00.000Z",
 *       "duration": 90,
 *       "status": "AVAILABLE",
 *       "tableCombinations": [
 *         {
 *           "tableIds": [
 *             "1ed802ae-708f-4da6-9177-54c3df5d3dd5"
 *           ]
 *         }
 *       ],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T14:30:00.000Z",
 *       "duration": 90,
 *       "status": "AVAILABLE",
 *       "tableCombinations": [
 *         {
 *           "tableIds": [
 *             "1ed802ae-708f-4da6-9177-54c3df5d3dd5"
 *           ]
 *         }
 *       ],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T14:45:00.000Z",
 *       "duration": 90,
 *       "status": "AVAILABLE",
 *       "tableCombinations": [
 *         {
 *           "tableIds": [
 *             "1ed802ae-708f-4da6-9177-54c3df5d3dd5"
 *           ]
 *         }
 *       ],
 *       "manualApproval": false
 *     },
 *     {
 *       "startDate": "2023-12-29T15:00:00.000Z",
 *       "duration": 90,
 *       "status": "AVAILABLE",
 *       "tableCombinations": [
 *         {
 *           "tableIds": [
 *             "1ed802ae-708f-4da6-9177-54c3df5d3dd5"
 *           ]
 *         }
 *       ],
 *       "manualApproval": false
 *     }
 *   ]
 * }
 */

Get time slots for a given date,location, and party size 

import { timeSlots } from '@wix/table-reservations';

/* Sample reservationLocationId value: 'fab8cc1f-31cf-462f-b5bb-392594624bf2'
 * Sample date value: new Date("2023-12-29T12:30:00Z")
 * Sample partySize value: 2
 * 
 * Sample options value: 
 * {
 *   "duration": 5,
 *   "slotsAfter": 1,
 *   "slotsBefore": 0
 * }
 */

timeSlots.getTimeSlots(reservationLocationId, new Date("2023-12-29T12:30:00Z"), partySize)
  .then((retrievedSlots) => {
    const firstStartDate = retrievedSlots.timeSlots[0].startDate;
    const firstStatus = retrievedSlots.timeSlots[0].status;

    console.log('Success! Retrieved the following time slots:', retrievedSlots);
    return retrievedSlots;
  })
  .catch((error) => {
    console.error(error);
    // Handle the error
  });

/* Promise resolves to:
* {
*   "timeSlots": [
*     {
*       "startDate": "2023-12-29T12:30:00.000Z",
*       "duration": 5,
*       "status": "UNAVAILABLE",
*       "tableCombinations": [],
*       "manualApproval": false
*     },
*     {
*       "startDate": "2023-12-29T12:45:00.000Z",
*       "duration": 5,
*       "status": "UNAVAILABLE",
*       "tableCombinations": [],
*       "manualApproval": false
*     }
*   ]
* }
*/

This example gets a 5-minute time slot at the selected date, and the next 5-minute time slot after it.

Get time slots with options 

/* This example requires the following elements:
 * A dropdown element named `locationDropdown`.
 * A dropdown element named `partySizeDropdown`.
 * A dropdown element named `timeSlotDropdown`.
 * A button named `confirmButton`.
 * A text element named `heldReservationNotification`.
 */

/*************************************************
 * Backend code - reservationLocations.web.js/ts *
 ************************************************/

import { Permissions, webMethod } from '@wix/web-methods';
import { locations } from '@wix/business-tools';
import { auth } from '@wix/essentials';

export const getRestaurantLocation = webMethod(Permissions.Anyone, async (location_id) => {
  const elevatedGetLocation = auth.elevate(locations.getLocation);

  try {
     const result = await elevatedGetLocation(location_id);
     return result;
   } catch (error) {
     console.error(error);
     // Handle the error
   }
});

/*************
 * Page code *
 *************/

import { reservationLocations } from '@wix/table-reservations';
import { reservations } from '@wix/table-reservations';
import { timeSlots } from '@wix/table-reservations';

import { getRestaurantLocation } from 'backend/reservationLocations.web';

$w.onReady(async function () {
  $w('#timeSlotDropdown').hide();
  $w('#partySizeDropdown').hide();
  $w('#confirmButton').hide();
  $w('#heldReservationNotification').hide();

  //Get the list of reservation locations
  const myReservationLocationList = await (async () => {
    try {
      let fullListObject = await reservationLocations.listReservationLocations();
      return fullListObject.reservationLocations;
    } catch (error) {
     console.error(error);
     // Handle the error
   }
  })();

  //Create an array to hold names and values for our locations dropdown list
  let locationDropdownOptions = [];
  for (const object in myReservationLocationList){
    //Use the _id stored in the reservation location's location object to get the location's name from the `locations` service
    const locationObject = await getRestaurantLocation(myReservationLocationList[object].location._id);
    locationDropdownOptions.push({
      "label": locationObject.name, 
      "value": myReservationLocationList[object]._id
    })	
  }
  //Populate our dropdown list with the array
  $w("#locationDropdown").options = locationDropdownOptions;

  //Create an array to hold numbers and values for our party size dropdown list
  let partySizeDropdownOptions = [];
  for (let i = 1; i<10; i++){
    partySizeDropdownOptions.push({
      "label": String(i), 
      "value": String(i)
    })	
  }
  //Populate our dropdown list with the array
  $w("#partySizeDropdown").options = partySizeDropdownOptions;

  $w('#locationDropdown').onChange( (event) => {
    if ($w('#locationDropdown').value) {
      $w('#partySizeDropdown').show();
      $w('#timeSlotDropdown').hide()
      $w('#confirmButton').hide();
    }
  });

  $w('#partySizeDropdown').onChange( async (event) => {
    if ($w('#locationDropdown').value) {
      $w('#timeSlotDropdown').show()
      $w('#confirmButton').hide();

      const timeSlotDetails = {
        "reservationLocationId": $w('#locationDropdown').value, 
        "date": new Date(),
        "partySize": parseInt($w('#partySizeDropdown').value)
      };

      const timeSlotOptions = {
        "duration": 30,
	"slotsAfter": 8,
	"slotsBefore": 0
      };

      //Get the list of time slots according to the details and options above
      const availableTimeSlots = await (async () => {
        try {
          let fullListObject = await timeSlots.getTimeSlots(timeSlotDetails.reservationLocationId, timeSlotDetails.date, timeSlotDetails.partySize, timeSlotOptions);
          return fullListObject.timeSlots;
        } catch (error) {
          console.error(error);
          // Handle the error
        }
      })();

      //Create an array to hold numbers and values for our time slot dropdown list
      let timeSlotDropdownOptions = [];
      for (const timeSlot in availableTimeSlots){
        if(availableTimeSlots[timeSlot].status == "AVAILABLE"){
          timeSlotDropdownOptions.push({
            "label": String(availableTimeSlots[timeSlot].startDate), 
            "value": String(availableTimeSlots[timeSlot].startDate)
          })
        }	
      }
      //Populate our dropdown list with the array
      $w("#timeSlotDropdown").options = timeSlotDropdownOptions;
    }
  });

  $w('#timeSlotDropdown').onChange( async (event) => {
    if ($w('#timeSlotDropdown').value) {
      $w('#confirmButton').show();
    }
  });

  $w('#confirmButton').onClick( async (event) => {
    //Get the list of time slots according to the details and options above
    
    const createdHeldReservation = await (async () => {
      try {
        const reservationDetails = {
          "reservationLocationId": $w('#locationDropdown').value, 
          "startDate": new Date($w("#timeSlotDropdown").value),
          "partySize": parseInt($w('#partySizeDropdown').value)
        };

        return await reservations.createHeldReservation(reservationDetails);
      } catch (error) {
        console.error(error);
        // Handle the error
      }
    })();

    if(createdHeldReservation){
      $w('#heldReservationNotification').text = "Held reservation created successfully."
      $w('#heldReservationNotification').show();
    }
  });
});


This scenario sets up an interface that allows a site owner to select a reservation location and a party size, then select a time slot to reserve. Once a time slot is selected, the site owner can click a confirm button to create a held reservation at that time.

Create a held reservation with a given time, location, and party size (with $w) 

import { createClient } from '@wix/sdk';
import { timeSlots } from '@wix/table-reservations';
// Import the auth strategy for the relevant access type
// Import the relevant host module if needed

const myWixClient = createClient ({
  modules: { timeSlots },
  // Include the auth strategy and host as relevant
});


async function getTimeSlots() {
  const response = await myWixClient.timeSlots.getTimeSlots();
};

getTimeSlots (self-hosted)

getTimeSlots

GetTimeSlotsResponse

---
title: Introduction
---

# Introduction

The Time Slots API allows you to retrieve availability information for time slots at a reservation location on and around a given date and for a given party size.

A time slot represents a period of time in a restaurant’s calendar. Time slots can have any duration, and restaurants generally set their durations based on party size.

The following factors influence whether a time slot at a reservation location is available:
* The size of the party that must be seated.
* The reservation location’s table and seat pacing rules.
* The reservation location’s business schedule (operating hours).
* Existing reservations at the reservation location.

With the Time Slots API, you can:

* Check the reservation location availability in a specific time slot.
* Get time slots for a reservation location.
* Get scheduled time slots for a reservation location. Scheduled time slots are time slots within a restaurant's opening hours as defined in the reservation location's `businessSchedule`. For more information, see [`getScheduledTimeSlots()`](https://dev.wix.com/docs/sdk/backend-modules/table-reservations/time-slots/get-scheduled-time-slots).

A time slot can have the following statuses:
* `AVAILABLE` - The restaurant is open and available to seat a party of the given size at the given date and time.
* `UNAVAILABLE` - The restaurant is open but unable to seat a party of the given size at the given date and time.
* `NON_WORKING_HOURS` - The restaurant is not open at this time.

`timeSlot` objects also indicate whether manual approval is required to make a reservation at the given reservation location.

## Before you begin
It’s important to note the following points before starting to code:
* The Wix user must install the Wix Table Reservations app.
* The Wix user must have at least 1 location configured in the Dashboard under [Business Info](https://www.wix.com/my-account/site-selector/?buttonText=Select%20Site&title=Select%20a%20Site&autoSelectOnSingleSite=true&actionUrl=https:%2F%2Fwww.wix.com%2Fdashboard%2F%7B%7BmetaSiteId%7D%7D%2Fbusiness-info).

## Terminology
For a comprehensive glossary of Table Reservations terms, see [Terminology](https://dev.wix.com/docs/sdk/api-reference/table-reservations/terminology).


@package_metadata:@wix/table-reservations

To use the TimeSlots API, install the `@wix/table-reservations` package.

#### Install the package

Follow the installation instructions for your development environment.

| Development environment | Installation method |
|--|--|
| Wix sites (editor or IDE) | Use the [package manager](https://dev.wix.com/docs/develop-websites/articles/coding-with-velo/packages/work-with-npm-packages-in-the-editor). |
| Wix sites (local IDE) | Run `wix install @wix/table-reservations` using the [Wix CLI](https://dev.wix.com/docs/develop-websites/articles/coding-with-velo/packages/work-with-npm-packages-with-the-wix-cli).|
| Blocks apps | Use the same installation method as Wix sites. |
| CLI and self-hosted apps | Run `npm install @wix/table-reservations` or `yarn add @wix/table-reservations`. |
| Headless sites and apps | Run `npm install @wix/table-reservations` or `yarn add @wix/table-reservations`. |

#### Import the package

To import the package in your code:

```js
import { timeSlots } from '@wix/table-reservations'
```
  

table-reservations_time-slots

Duration of the time slot in minutes .

Min: `5`

duration

ID of a reservation to ignore during the check.

Use this when rescheduling a reservation to exclude it in its current state from the availability calculations.

excludeReservationId

Party size to check the restaurant's availability for.

Reservation location conflicts that would occur by making a reservation for the specified party size in the specified time slot.

reservationLocationConflicts

Table combinations and their availability information.

tableCombinationAvailabilities

Time range from which to retrieve time slots.

timeRange

TimeRange

A list of time slots and their availability according to the specified party size.

timeSlots

Duration in minutes of the time slot.

Min: `5`

The number of time slots to retrieve after the specified `date`.

slotsAfter

The number of time slots to retrieve before the specified `date`.

slotsBefore

The restaurant cannot accommodate a party of the given size according to party pacing settings.

The required number of seats are unavailable according to seat pacing settings.

Undefined reservation location conflict type.

ReservationLocationConflictType

The restaurant can accommodate a party of the given size in this time slot.

The restaurant is not open during this time slot. Time slots retrieved by Get Scheduled Time Slots never have this status.

The restaurant can't accommodate a party of the given size in this time slot.

Status

TableCombinationAvailability

Conflicts that would be generated by attempting to accommodate the proposed reservation using the table combination.

tableCombinationConflicts

IDs of the tables in the table combination.

tableIds

The restaurant does not allow online reservations.

One or more of the chosen tables are already reserved.

The party is too big for the selected table.

The party is too small for the selected table.

TableCombinationConflictType

Date and time to which to retrieve time slots in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#coordinated_Universal_Time_(UTC)) format.

endDate

Date and time from which to retrieve time slots in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#coordinated_Universal_Time_(UTC)) format.

checkTimeSlot( )