Package com.duffel.sdk.api

Class BookingApi

java.lang.Object
com.duffel.sdk.api.BookingApi
@Generated(value="org.openapitools.codegen.languages.JavaClientCodegen", date="2024-01-16T15:26:22.356688490+07:00[Asia/Bangkok]") public class BookingApi extends Object

  • Constructor Details

    • BookingApi

      public BookingApi()

    • BookingApi

      @Autowired public BookingApi(ApiClient apiClient)

  • Method Details

    • getApiClient

      public ApiClient getApiClient()

    • setApiClient

      public void setApiClient(ApiClient apiClient)

    • acceptAirlineInitiatedChanges

      public reactor.core.publisher.Mono<UpdateAirlineInitiatedChanges200Response> acceptAirlineInitiatedChanges(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Accept the airline-initiated change Once there is an airline-initiated change you can choose to accept it.

      200 - Airline-initiated Change has been accepted with airline

      202 - Airline-initiated Change acceptance is in progress

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the airline-initiated change
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      UpdateAirlineInitiatedChanges200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • acceptAirlineInitiatedChangesWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<UpdateAirlineInitiatedChanges200Response>> acceptAirlineInitiatedChangesWithHttpInfo(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Accept the airline-initiated change Once there is an airline-initiated change you can choose to accept it.

      200 - Airline-initiated Change has been accepted with airline

      202 - Airline-initiated Change acceptance is in progress

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the airline-initiated change
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseEntity<UpdateAirlineInitiatedChanges200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • acceptAirlineInitiatedChangesWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec acceptAirlineInitiatedChangesWithResponseSpec(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Accept the airline-initiated change Once there is an airline-initiated change you can choose to accept it.

      200 - Airline-initiated Change has been accepted with airline

      202 - Airline-initiated Change acceptance is in progress

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the airline-initiated change
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • confirmOrderCancellation

      public reactor.core.publisher.Mono<CreateOrderCancellation201Response> confirmOrderCancellation(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Confirm an order cancellation Once you've created a pending order cancellation, you'll know the `refund_amount` you're due to get back. To actually cancel the order, you'll need to confirm the cancellation. The booking with the airline will be cancelled, and the `refund_amount` will be returned to the original payment method (i.e. your Duffel balance). You'll then need to refund your customer (e.g. back to their credit/debit card).

      200 - An order cancellation object

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order cancellation
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      CreateOrderCancellation201Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • confirmOrderCancellationWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<CreateOrderCancellation201Response>> confirmOrderCancellationWithHttpInfo(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Confirm an order cancellation Once you've created a pending order cancellation, you'll know the `refund_amount` you're due to get back. To actually cancel the order, you'll need to confirm the cancellation. The booking with the airline will be cancelled, and the `refund_amount` will be returned to the original payment method (i.e. your Duffel balance). You'll then need to refund your customer (e.g. back to their credit/debit card).

      200 - An order cancellation object

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order cancellation
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseEntity<CreateOrderCancellation201Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • confirmOrderCancellationWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec confirmOrderCancellationWithResponseSpec(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Confirm an order cancellation Once you've created a pending order cancellation, you'll know the `refund_amount` you're due to get back. To actually cancel the order, you'll need to confirm the cancellation. The booking with the airline will be cancelled, and the `refund_amount` will be returned to the original payment method (i.e. your Duffel balance). You'll then need to refund your customer (e.g. back to their credit/debit card).

      200 - An order cancellation object

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order cancellation
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • confirmOrderChange

      public reactor.core.publisher.Mono<ConfirmOrderChange200Response> confirmOrderChange(String accept, String duffelVersion, String id, ConfirmOrderChangeRequest confirmOrderChangeRequest, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Confirm an order change Once you've created a pending order change, you'll know the `change_total_amount` due for the change. To actually change the order, you'll need to confirm the change. The booking with the airline will be updated with the new slice you previously chose, and the `change_total_amount` will be charged to your specific payment type. If the amount of `change_total_amount` is negative, then this will be returned to the `refund_to` method (e.g. your Duffel balance). You'll then need to refund your customer (e.g. back to their credit/debit card).

      200 - An order change object

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order change
      confirmOrderChangeRequest - The confirmOrderChangeRequest parameter
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ConfirmOrderChange200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • confirmOrderChangeWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<ConfirmOrderChange200Response>> confirmOrderChangeWithHttpInfo(String accept, String duffelVersion, String id, ConfirmOrderChangeRequest confirmOrderChangeRequest, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Confirm an order change Once you've created a pending order change, you'll know the `change_total_amount` due for the change. To actually change the order, you'll need to confirm the change. The booking with the airline will be updated with the new slice you previously chose, and the `change_total_amount` will be charged to your specific payment type. If the amount of `change_total_amount` is negative, then this will be returned to the `refund_to` method (e.g. your Duffel balance). You'll then need to refund your customer (e.g. back to their credit/debit card).

      200 - An order change object

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order change
      confirmOrderChangeRequest - The confirmOrderChangeRequest parameter
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseEntity<ConfirmOrderChange200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • confirmOrderChangeWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec confirmOrderChangeWithResponseSpec(String accept, String duffelVersion, String id, ConfirmOrderChangeRequest confirmOrderChangeRequest, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Confirm an order change Once you've created a pending order change, you'll know the `change_total_amount` due for the change. To actually change the order, you'll need to confirm the change. The booking with the airline will be updated with the new slice you previously chose, and the `change_total_amount` will be charged to your specific payment type. If the amount of `change_total_amount` is negative, then this will be returned to the `refund_to` method (e.g. your Duffel balance). You'll then need to refund your customer (e.g. back to their credit/debit card).

      200 - An order change object

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order change
      confirmOrderChangeRequest - The confirmOrderChangeRequest parameter
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOfferRequest

      public reactor.core.publisher.Mono<GetOfferRequestById200Response> createOfferRequest(String accept, String duffelVersion, String acceptEncoding, String contentType, Boolean returnOffers, Integer supplierTimeout, CreateOfferRequestRequest createOfferRequestRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create an offer request To search for flights, you'll need to create an __offer request__. An offer request describes the passengers and where and when they want to travel (in the form of a list of __slices__). It may also include additional filters (e.g. a particular cabin to travel in). We'll send your search to a range of airlines, and return your offer request back to you with a series of __offers__. Each offer represents a set of flights you can buy from an airline at a particular price that meet your search criteria. Inside the offers, you'll see your slices, but now each slice will also include a list of one or more specific flights (called __segments__) that the airline is *offering* to get the passengers where they want to go. When presenting offers to your customers, you should always show the full name of the operating carrier of each segment (`slices[].segments[].operating_carrier.name`). This must be displayed prominently on the first screen where the offer is presented in order to comply with [US regulations](https://www.ecfr.gov/cgi-bin/text-idx?SID=8e736a5c813a737a5c2f6700a4c9006d&mc=true&node=pt14.4.257&rgn=div5).

      200 - An offer request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      returnOffers - When set to `true`, the offer request resource returned will include _all_ the `offer`s returned by the airlines. If set to `false`, the offer request resource won't include any `offer`s. To retrieve the associated offers later, use the [List Offers](/docs/api/offers/get-offers) endpoint, specifying the `offer_request_id`. You should use this option if you want to take advantage of the pagination, sorting and filtering that the [List Offers](/docs/api/offers/get-offers) endpoint provides.
      supplierTimeout - The maximum amount of time in milliseconds to wait for each airline to respond. This timeout only applies to the [response time](/docs/api/overview/response-times) of the call to the airline and doesn't include additional overhead added by Duffel. Value should be between 2 seconds and 60 seconds. Any values outside the range will be ignored and the default `supplier_timeout` will be used. If a value is set, the response will only include offers from airlines that returned within the given time. If a value is not set, the response will only include offers from airlines that returned within the default `supplier_timeout` value of 20 seconds. We recommend setting `supplier_timeout` lower than the timeout on the request sent to Duffel API as that will allow us to respond with the offers we received before your request times out with an empty response.
      createOfferRequestRequest - The createOfferRequestRequest parameter
      Returns:
      GetOfferRequestById200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOfferRequestWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOfferRequestById200Response>> createOfferRequestWithHttpInfo(String accept, String duffelVersion, String acceptEncoding, String contentType, Boolean returnOffers, Integer supplierTimeout, CreateOfferRequestRequest createOfferRequestRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create an offer request To search for flights, you'll need to create an __offer request__. An offer request describes the passengers and where and when they want to travel (in the form of a list of __slices__). It may also include additional filters (e.g. a particular cabin to travel in). We'll send your search to a range of airlines, and return your offer request back to you with a series of __offers__. Each offer represents a set of flights you can buy from an airline at a particular price that meet your search criteria. Inside the offers, you'll see your slices, but now each slice will also include a list of one or more specific flights (called __segments__) that the airline is *offering* to get the passengers where they want to go. When presenting offers to your customers, you should always show the full name of the operating carrier of each segment (`slices[].segments[].operating_carrier.name`). This must be displayed prominently on the first screen where the offer is presented in order to comply with [US regulations](https://www.ecfr.gov/cgi-bin/text-idx?SID=8e736a5c813a737a5c2f6700a4c9006d&mc=true&node=pt14.4.257&rgn=div5).

      200 - An offer request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      returnOffers - When set to `true`, the offer request resource returned will include _all_ the `offer`s returned by the airlines. If set to `false`, the offer request resource won't include any `offer`s. To retrieve the associated offers later, use the [List Offers](/docs/api/offers/get-offers) endpoint, specifying the `offer_request_id`. You should use this option if you want to take advantage of the pagination, sorting and filtering that the [List Offers](/docs/api/offers/get-offers) endpoint provides.
      supplierTimeout - The maximum amount of time in milliseconds to wait for each airline to respond. This timeout only applies to the [response time](/docs/api/overview/response-times) of the call to the airline and doesn't include additional overhead added by Duffel. Value should be between 2 seconds and 60 seconds. Any values outside the range will be ignored and the default `supplier_timeout` will be used. If a value is set, the response will only include offers from airlines that returned within the given time. If a value is not set, the response will only include offers from airlines that returned within the default `supplier_timeout` value of 20 seconds. We recommend setting `supplier_timeout` lower than the timeout on the request sent to Duffel API as that will allow us to respond with the offers we received before your request times out with an empty response.
      createOfferRequestRequest - The createOfferRequestRequest parameter
      Returns:
      ResponseEntity<GetOfferRequestById200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOfferRequestWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec createOfferRequestWithResponseSpec(String accept, String duffelVersion, String acceptEncoding, String contentType, Boolean returnOffers, Integer supplierTimeout, CreateOfferRequestRequest createOfferRequestRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create an offer request To search for flights, you'll need to create an __offer request__. An offer request describes the passengers and where and when they want to travel (in the form of a list of __slices__). It may also include additional filters (e.g. a particular cabin to travel in). We'll send your search to a range of airlines, and return your offer request back to you with a series of __offers__. Each offer represents a set of flights you can buy from an airline at a particular price that meet your search criteria. Inside the offers, you'll see your slices, but now each slice will also include a list of one or more specific flights (called __segments__) that the airline is *offering* to get the passengers where they want to go. When presenting offers to your customers, you should always show the full name of the operating carrier of each segment (`slices[].segments[].operating_carrier.name`). This must be displayed prominently on the first screen where the offer is presented in order to comply with [US regulations](https://www.ecfr.gov/cgi-bin/text-idx?SID=8e736a5c813a737a5c2f6700a4c9006d&mc=true&node=pt14.4.257&rgn=div5).

      200 - An offer request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      returnOffers - When set to `true`, the offer request resource returned will include _all_ the `offer`s returned by the airlines. If set to `false`, the offer request resource won't include any `offer`s. To retrieve the associated offers later, use the [List Offers](/docs/api/offers/get-offers) endpoint, specifying the `offer_request_id`. You should use this option if you want to take advantage of the pagination, sorting and filtering that the [List Offers](/docs/api/offers/get-offers) endpoint provides.
      supplierTimeout - The maximum amount of time in milliseconds to wait for each airline to respond. This timeout only applies to the [response time](/docs/api/overview/response-times) of the call to the airline and doesn't include additional overhead added by Duffel. Value should be between 2 seconds and 60 seconds. Any values outside the range will be ignored and the default `supplier_timeout` will be used. If a value is set, the response will only include offers from airlines that returned within the given time. If a value is not set, the response will only include offers from airlines that returned within the default `supplier_timeout` value of 20 seconds. We recommend setting `supplier_timeout` lower than the timeout on the request sent to Duffel API as that will allow us to respond with the offers we received before your request times out with an empty response.
      createOfferRequestRequest - The createOfferRequestRequest parameter
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOrder

      public reactor.core.publisher.Mono<GetOrderById200Response> createOrder(String accept, String duffelVersion, CreateOrderRequest createOrderRequest, String acceptEncoding, String contentType) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create an order Creates a booking with an airline based on an offer. Orders are usually paid at the time of creation, but can be held and paid for at a later date if the offer supports it (see `offer.payment_requirements.requires_instant_payment`). To create an order and pay for it at the same time, specify a `payments` key. To hold the order and pay for it later, specify the type as `hold`, omit the `payments` and `services` keys, and complete payment after creating the order through the [Create a payment endpoint](/docs/api/payments/create-payment). When presenting an order confirmation to your customers (e.g. on screen or in an email), you should include the `booking_reference` and details of the full itinerary and show the full name of the operating carrier of each segment (`slices[].segments[].operating_carrier.name`) in order to comply with [US regulations](https://www.ecfr.gov/cgi-bin/text-idx?SID=8e736a5c813a737a5c2f6700a4c9006d&mc=true&node=pt14.4.257&rgn=div5). ### Validation errors | Field | Code | Description | | ---------- | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ | | `payments` | `payments_not_allowed_for_order_type` | You’ve included a `payments` key for a `hold` order, but the key should be omitted. | | `services` | `services_not_allowed_for_order_type` | You’ve included `services` for a `hold` order, but they’re not currently supported. | | `type` | `not_valid_with_selected_offer` | The type is not valid with selected offer because either `requires_instant_payment` is `true` or the `payment_required_by` is in the past. |

      201 - An order

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      createOrderRequest - The createOrderRequest parameter
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      Returns:
      GetOrderById200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOrderWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOrderById200Response>> createOrderWithHttpInfo(String accept, String duffelVersion, CreateOrderRequest createOrderRequest, String acceptEncoding, String contentType) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create an order Creates a booking with an airline based on an offer. Orders are usually paid at the time of creation, but can be held and paid for at a later date if the offer supports it (see `offer.payment_requirements.requires_instant_payment`). To create an order and pay for it at the same time, specify a `payments` key. To hold the order and pay for it later, specify the type as `hold`, omit the `payments` and `services` keys, and complete payment after creating the order through the [Create a payment endpoint](/docs/api/payments/create-payment). When presenting an order confirmation to your customers (e.g. on screen or in an email), you should include the `booking_reference` and details of the full itinerary and show the full name of the operating carrier of each segment (`slices[].segments[].operating_carrier.name`) in order to comply with [US regulations](https://www.ecfr.gov/cgi-bin/text-idx?SID=8e736a5c813a737a5c2f6700a4c9006d&mc=true&node=pt14.4.257&rgn=div5). ### Validation errors | Field | Code | Description | | ---------- | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ | | `payments` | `payments_not_allowed_for_order_type` | You’ve included a `payments` key for a `hold` order, but the key should be omitted. | | `services` | `services_not_allowed_for_order_type` | You’ve included `services` for a `hold` order, but they’re not currently supported. | | `type` | `not_valid_with_selected_offer` | The type is not valid with selected offer because either `requires_instant_payment` is `true` or the `payment_required_by` is in the past. |

      201 - An order

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      createOrderRequest - The createOrderRequest parameter
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      Returns:
      ResponseEntity<GetOrderById200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOrderWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec createOrderWithResponseSpec(String accept, String duffelVersion, CreateOrderRequest createOrderRequest, String acceptEncoding, String contentType) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create an order Creates a booking with an airline based on an offer. Orders are usually paid at the time of creation, but can be held and paid for at a later date if the offer supports it (see `offer.payment_requirements.requires_instant_payment`). To create an order and pay for it at the same time, specify a `payments` key. To hold the order and pay for it later, specify the type as `hold`, omit the `payments` and `services` keys, and complete payment after creating the order through the [Create a payment endpoint](/docs/api/payments/create-payment). When presenting an order confirmation to your customers (e.g. on screen or in an email), you should include the `booking_reference` and details of the full itinerary and show the full name of the operating carrier of each segment (`slices[].segments[].operating_carrier.name`) in order to comply with [US regulations](https://www.ecfr.gov/cgi-bin/text-idx?SID=8e736a5c813a737a5c2f6700a4c9006d&mc=true&node=pt14.4.257&rgn=div5). ### Validation errors | Field | Code | Description | | ---------- | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ | | `payments` | `payments_not_allowed_for_order_type` | You’ve included a `payments` key for a `hold` order, but the key should be omitted. | | `services` | `services_not_allowed_for_order_type` | You’ve included `services` for a `hold` order, but they’re not currently supported. | | `type` | `not_valid_with_selected_offer` | The type is not valid with selected offer because either `requires_instant_payment` is `true` or the `payment_required_by` is in the past. |

      201 - An order

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      createOrderRequest - The createOrderRequest parameter
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOrderCancellation

      public reactor.core.publisher.Mono<CreateOrderCancellation201Response> createOrderCancellation(String accept, String duffelVersion, CreateOrderCancellationRequest createOrderCancellationRequest, String acceptEncoding, String contentType) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create a pending order cancellation To begin the process of cancelling an order you need to create an order cancellation. The OrderCancellation will contain the `refund_amount` due from the Airline. To proceed, you must confirm the cancellation using the [Confirm an order cancellation](/docs/api/order-cancellations/confirm-order-cancellation) endpoint.

      201 - A pending order cancellation to be confirmed

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      createOrderCancellationRequest - The createOrderCancellationRequest parameter
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      Returns:
      CreateOrderCancellation201Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOrderCancellationWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<CreateOrderCancellation201Response>> createOrderCancellationWithHttpInfo(String accept, String duffelVersion, CreateOrderCancellationRequest createOrderCancellationRequest, String acceptEncoding, String contentType) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create a pending order cancellation To begin the process of cancelling an order you need to create an order cancellation. The OrderCancellation will contain the `refund_amount` due from the Airline. To proceed, you must confirm the cancellation using the [Confirm an order cancellation](/docs/api/order-cancellations/confirm-order-cancellation) endpoint.

      201 - A pending order cancellation to be confirmed

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      createOrderCancellationRequest - The createOrderCancellationRequest parameter
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      Returns:
      ResponseEntity<CreateOrderCancellation201Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOrderCancellationWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec createOrderCancellationWithResponseSpec(String accept, String duffelVersion, CreateOrderCancellationRequest createOrderCancellationRequest, String acceptEncoding, String contentType) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create a pending order cancellation To begin the process of cancelling an order you need to create an order cancellation. The OrderCancellation will contain the `refund_amount` due from the Airline. To proceed, you must confirm the cancellation using the [Confirm an order cancellation](/docs/api/order-cancellations/confirm-order-cancellation) endpoint.

      201 - A pending order cancellation to be confirmed

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      createOrderCancellationRequest - The createOrderCancellationRequest parameter
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOrderChange

      public reactor.core.publisher.Mono<ConfirmOrderChange200Response> createOrderChange(String accept, String duffelVersion, String acceptEncoding, String contentType, CreateOrderChangeRequest createOrderChangeRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create a pending order change To begin the process of changing an order you need to create an order change. The OrderChange will contain the `selected_order_change_offer` reference of the change you wish to make to your order. To proceed, you must confirm the change using the [Confirm an order change](/docs/api/order-changes/confirm-order-change) endpoint.

      201 - An order change

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      createOrderChangeRequest - The createOrderChangeRequest parameter
      Returns:
      ConfirmOrderChange200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOrderChangeWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<ConfirmOrderChange200Response>> createOrderChangeWithHttpInfo(String accept, String duffelVersion, String acceptEncoding, String contentType, CreateOrderChangeRequest createOrderChangeRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create a pending order change To begin the process of changing an order you need to create an order change. The OrderChange will contain the `selected_order_change_offer` reference of the change you wish to make to your order. To proceed, you must confirm the change using the [Confirm an order change](/docs/api/order-changes/confirm-order-change) endpoint.

      201 - An order change

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      createOrderChangeRequest - The createOrderChangeRequest parameter
      Returns:
      ResponseEntity<ConfirmOrderChange200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOrderChangeWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec createOrderChangeWithResponseSpec(String accept, String duffelVersion, String acceptEncoding, String contentType, CreateOrderChangeRequest createOrderChangeRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create a pending order change To begin the process of changing an order you need to create an order change. The OrderChange will contain the `selected_order_change_offer` reference of the change you wish to make to your order. To proceed, you must confirm the change using the [Confirm an order change](/docs/api/order-changes/confirm-order-change) endpoint.

      201 - An order change

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      createOrderChangeRequest - The createOrderChangeRequest parameter
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOrderChangeRequest

      public reactor.core.publisher.Mono<GetOrderChangeRequestById200Response> createOrderChangeRequest(String accept, String duffelVersion, String acceptEncoding, String contentType, CreateOrderChangeRequestRequest createOrderChangeRequestRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create an order change request To change flights on an existing paid order, you'll need to create an __order change request__. An order change request describes the slices you want to change and the details of where and when they want to travel (in the form of a list of __slices__). Any new slices will all need to use the same cabin class. We'll send your search to the airline you originally booked with to search for __order_change_offers__. This list will be empty if no offers are available. These can be viewed through the [Get a single order change offer](docs/api/order-change-offers/get-order-change-offer-by-id) endpoint. Each offer represents a set of flights you can buy from the airline to add to your order at a particular price that meet your search criteria. Inside the offers, you'll see your slices, but now each slice will also include a list of one or more specific flights (called __segments__) that the airline is *offering* to get the passengers where they want to go. When presenting offers to your customers, you should always show the full name of the operating carrier of each segment (`slices[].segments[].operating_carrier.name`). This must be displayed prominently on the first screen where the offer is presented in order to comply with [US regulations](https://www.ecfr.gov/cgi-bin/text-idx?SID=8e736a5c813a737a5c2f6700a4c9006d&mc=true&node=pt14.4.257&rgn=div5).

      201 - An order change request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      createOrderChangeRequestRequest - The createOrderChangeRequestRequest parameter
      Returns:
      GetOrderChangeRequestById200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOrderChangeRequestWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOrderChangeRequestById200Response>> createOrderChangeRequestWithHttpInfo(String accept, String duffelVersion, String acceptEncoding, String contentType, CreateOrderChangeRequestRequest createOrderChangeRequestRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create an order change request To change flights on an existing paid order, you'll need to create an __order change request__. An order change request describes the slices you want to change and the details of where and when they want to travel (in the form of a list of __slices__). Any new slices will all need to use the same cabin class. We'll send your search to the airline you originally booked with to search for __order_change_offers__. This list will be empty if no offers are available. These can be viewed through the [Get a single order change offer](docs/api/order-change-offers/get-order-change-offer-by-id) endpoint. Each offer represents a set of flights you can buy from the airline to add to your order at a particular price that meet your search criteria. Inside the offers, you'll see your slices, but now each slice will also include a list of one or more specific flights (called __segments__) that the airline is *offering* to get the passengers where they want to go. When presenting offers to your customers, you should always show the full name of the operating carrier of each segment (`slices[].segments[].operating_carrier.name`). This must be displayed prominently on the first screen where the offer is presented in order to comply with [US regulations](https://www.ecfr.gov/cgi-bin/text-idx?SID=8e736a5c813a737a5c2f6700a4c9006d&mc=true&node=pt14.4.257&rgn=div5).

      201 - An order change request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      createOrderChangeRequestRequest - The createOrderChangeRequestRequest parameter
      Returns:
      ResponseEntity<GetOrderChangeRequestById200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createOrderChangeRequestWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec createOrderChangeRequestWithResponseSpec(String accept, String duffelVersion, String acceptEncoding, String contentType, CreateOrderChangeRequestRequest createOrderChangeRequestRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create an order change request To change flights on an existing paid order, you'll need to create an __order change request__. An order change request describes the slices you want to change and the details of where and when they want to travel (in the form of a list of __slices__). Any new slices will all need to use the same cabin class. We'll send your search to the airline you originally booked with to search for __order_change_offers__. This list will be empty if no offers are available. These can be viewed through the [Get a single order change offer](docs/api/order-change-offers/get-order-change-offer-by-id) endpoint. Each offer represents a set of flights you can buy from the airline to add to your order at a particular price that meet your search criteria. Inside the offers, you'll see your slices, but now each slice will also include a list of one or more specific flights (called __segments__) that the airline is *offering* to get the passengers where they want to go. When presenting offers to your customers, you should always show the full name of the operating carrier of each segment (`slices[].segments[].operating_carrier.name`). This must be displayed prominently on the first screen where the offer is presented in order to comply with [US regulations](https://www.ecfr.gov/cgi-bin/text-idx?SID=8e736a5c813a737a5c2f6700a4c9006d&mc=true&node=pt14.4.257&rgn=div5).

      201 - An order change request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      createOrderChangeRequestRequest - The createOrderChangeRequestRequest parameter
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createPartialOfferRequest

      public reactor.core.publisher.Mono<GetOfferRequestById200Response> createPartialOfferRequest(String accept, String duffelVersion, String acceptEncoding, String contentType, Integer supplierTimeout, CreateOfferRequestRequest createOfferRequestRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create a partial offer request To search for and select flights separately for each slice of the journey, you'll need to create a __partial offer request__. A partial offer request describes the passengers and where and when they want to travel (in the form of a list of __slices__). It may also include additional filters (e.g. a particular cabin to travel in). We'll send your search to a range of airlines, and return your offer request back to you with a series of __offers__ for the first slice in your journey. Offers returned from a partial offer request will have the __partial__ flag set to `true`. Each partial offer represents a set of flights you can buy from an airline at a particular price that meet the criteria of a slice in your search. Inside the partial offer you'll see the slice it pertains to, and each slice will also include a list of one or more specific flights (called __segments__) that the airline is *offering* to get the passengers where they want to go. When presenting partial offers to your customers, you should always show the full name of the operating carrier of each segment (`slices[].segments[].operating_carrier.name`). This must be displayed prominently on the first screen where the offer is presented in order to comply with [US regulations](https://www.ecfr.gov/cgi-bin/text-idx?SID=8e736a5c813a737a5c2f6700a4c9006d&mc=true&node=pt14.4.257&rgn=div5).

      200 - An offer request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      supplierTimeout - The maximum amount of time in milliseconds to wait for each airline to respond. This timeout only applies to the [response time](/docs/api/overview/response-times) of the call to the airline and doesn't include additional overhead added by Duffel. Value should be between 2 seconds and 60 seconds. Any values outside the range will be ignored and the default `supplier_timeout` will be used. If a value is set, the response will only include offers from airlines that returned within the given time. If a value is not set, the response will only include offers from airlines that returned within the default `supplier_timeout` value of 20 seconds. We recommend setting `supplier_timeout` lower than the timeout on the request sent to Duffel API as that will allow us to respond with the offers we received before your request times out with an empty response.
      createOfferRequestRequest - The createOfferRequestRequest parameter
      Returns:
      GetOfferRequestById200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createPartialOfferRequestWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOfferRequestById200Response>> createPartialOfferRequestWithHttpInfo(String accept, String duffelVersion, String acceptEncoding, String contentType, Integer supplierTimeout, CreateOfferRequestRequest createOfferRequestRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create a partial offer request To search for and select flights separately for each slice of the journey, you'll need to create a __partial offer request__. A partial offer request describes the passengers and where and when they want to travel (in the form of a list of __slices__). It may also include additional filters (e.g. a particular cabin to travel in). We'll send your search to a range of airlines, and return your offer request back to you with a series of __offers__ for the first slice in your journey. Offers returned from a partial offer request will have the __partial__ flag set to `true`. Each partial offer represents a set of flights you can buy from an airline at a particular price that meet the criteria of a slice in your search. Inside the partial offer you'll see the slice it pertains to, and each slice will also include a list of one or more specific flights (called __segments__) that the airline is *offering* to get the passengers where they want to go. When presenting partial offers to your customers, you should always show the full name of the operating carrier of each segment (`slices[].segments[].operating_carrier.name`). This must be displayed prominently on the first screen where the offer is presented in order to comply with [US regulations](https://www.ecfr.gov/cgi-bin/text-idx?SID=8e736a5c813a737a5c2f6700a4c9006d&mc=true&node=pt14.4.257&rgn=div5).

      200 - An offer request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      supplierTimeout - The maximum amount of time in milliseconds to wait for each airline to respond. This timeout only applies to the [response time](/docs/api/overview/response-times) of the call to the airline and doesn't include additional overhead added by Duffel. Value should be between 2 seconds and 60 seconds. Any values outside the range will be ignored and the default `supplier_timeout` will be used. If a value is set, the response will only include offers from airlines that returned within the given time. If a value is not set, the response will only include offers from airlines that returned within the default `supplier_timeout` value of 20 seconds. We recommend setting `supplier_timeout` lower than the timeout on the request sent to Duffel API as that will allow us to respond with the offers we received before your request times out with an empty response.
      createOfferRequestRequest - The createOfferRequestRequest parameter
      Returns:
      ResponseEntity<GetOfferRequestById200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createPartialOfferRequestWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec createPartialOfferRequestWithResponseSpec(String accept, String duffelVersion, String acceptEncoding, String contentType, Integer supplierTimeout, CreateOfferRequestRequest createOfferRequestRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create a partial offer request To search for and select flights separately for each slice of the journey, you'll need to create a __partial offer request__. A partial offer request describes the passengers and where and when they want to travel (in the form of a list of __slices__). It may also include additional filters (e.g. a particular cabin to travel in). We'll send your search to a range of airlines, and return your offer request back to you with a series of __offers__ for the first slice in your journey. Offers returned from a partial offer request will have the __partial__ flag set to `true`. Each partial offer represents a set of flights you can buy from an airline at a particular price that meet the criteria of a slice in your search. Inside the partial offer you'll see the slice it pertains to, and each slice will also include a list of one or more specific flights (called __segments__) that the airline is *offering* to get the passengers where they want to go. When presenting partial offers to your customers, you should always show the full name of the operating carrier of each segment (`slices[].segments[].operating_carrier.name`). This must be displayed prominently on the first screen where the offer is presented in order to comply with [US regulations](https://www.ecfr.gov/cgi-bin/text-idx?SID=8e736a5c813a737a5c2f6700a4c9006d&mc=true&node=pt14.4.257&rgn=div5).

      200 - An offer request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      supplierTimeout - The maximum amount of time in milliseconds to wait for each airline to respond. This timeout only applies to the [response time](/docs/api/overview/response-times) of the call to the airline and doesn't include additional overhead added by Duffel. Value should be between 2 seconds and 60 seconds. Any values outside the range will be ignored and the default `supplier_timeout` will be used. If a value is set, the response will only include offers from airlines that returned within the given time. If a value is not set, the response will only include offers from airlines that returned within the default `supplier_timeout` value of 20 seconds. We recommend setting `supplier_timeout` lower than the timeout on the request sent to Duffel API as that will allow us to respond with the offers we received before your request times out with an empty response.
      createOfferRequestRequest - The createOfferRequestRequest parameter
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createPayment

      public reactor.core.publisher.Mono<CreatePayment201Response> createPayment(String accept, String duffelVersion, CreatePaymentRequest createPaymentRequest, String acceptEncoding, String contentType) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create a payment Creates a payment for a `hold` order. A `hold` order can be paid for up to the time limit indicated in `payment_required_by`, after which the space held for the order will be released and you will have to create a new order. Before paying, you should always get the latest price by [retrieving the order](/docs/api/orders/get-order-by-id) to minimise the risk that the price you have is different from the latest price. If the price for an order has changed from the time of booking and you pass in the old price, then you will get a validation error on the `amount` field with a `price_changed` code. The price of an order should only change if the order has no price guarantee or the price guarantee has expired (ie. `price_guaranteed_expires_at` is `null` or in the past). If you receive a `500 Internal Server Error` when trying to create a payment for a `hold` order, it may have still been created on the airline’s side. Please contact Duffel support before trying the request again. ### Validation errors | Field | Code | Description | | ---------- | ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `order_id` | `order_type_not_eligible_for_payment` | This order can't be paid for because it isn't a `hold` order. | `amount` | `payment_amount_does_not_match_order_amount` | The `amount` provided in the payment doesn't match the `total_amount` of the order. | | `currency` | `payment_currency_does_not_match_order_currency` | The `currency` provided in the payment doesn't match the `total_currency` of the order. | ### Invalid states This endpoint can return the following errors with a `type` of `invalid_state`, to indicate a reason that the order can't be paid for: * `already_paid`: The order you’re paying for has already been paid for. * `already_cancelled`: The order you’re attempting to pay for has been cancelled. * `past_payment_required_by_date`: The order’s `payment_required_by` date has elapsed. * `schedule_changed`: You can't pay for this order because it has been changed in some way on the airline's side. You should start again, creating a new order.

      201 - A payment

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      createPaymentRequest - The createPaymentRequest parameter
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      Returns:
      CreatePayment201Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createPaymentWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<CreatePayment201Response>> createPaymentWithHttpInfo(String accept, String duffelVersion, CreatePaymentRequest createPaymentRequest, String acceptEncoding, String contentType) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create a payment Creates a payment for a `hold` order. A `hold` order can be paid for up to the time limit indicated in `payment_required_by`, after which the space held for the order will be released and you will have to create a new order. Before paying, you should always get the latest price by [retrieving the order](/docs/api/orders/get-order-by-id) to minimise the risk that the price you have is different from the latest price. If the price for an order has changed from the time of booking and you pass in the old price, then you will get a validation error on the `amount` field with a `price_changed` code. The price of an order should only change if the order has no price guarantee or the price guarantee has expired (ie. `price_guaranteed_expires_at` is `null` or in the past). If you receive a `500 Internal Server Error` when trying to create a payment for a `hold` order, it may have still been created on the airline’s side. Please contact Duffel support before trying the request again. ### Validation errors | Field | Code | Description | | ---------- | ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `order_id` | `order_type_not_eligible_for_payment` | This order can't be paid for because it isn't a `hold` order. | `amount` | `payment_amount_does_not_match_order_amount` | The `amount` provided in the payment doesn't match the `total_amount` of the order. | | `currency` | `payment_currency_does_not_match_order_currency` | The `currency` provided in the payment doesn't match the `total_currency` of the order. | ### Invalid states This endpoint can return the following errors with a `type` of `invalid_state`, to indicate a reason that the order can't be paid for: * `already_paid`: The order you’re paying for has already been paid for. * `already_cancelled`: The order you’re attempting to pay for has been cancelled. * `past_payment_required_by_date`: The order’s `payment_required_by` date has elapsed. * `schedule_changed`: You can't pay for this order because it has been changed in some way on the airline's side. You should start again, creating a new order.

      201 - A payment

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      createPaymentRequest - The createPaymentRequest parameter
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      Returns:
      ResponseEntity<CreatePayment201Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • createPaymentWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec createPaymentWithResponseSpec(String accept, String duffelVersion, CreatePaymentRequest createPaymentRequest, String acceptEncoding, String contentType) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Create a payment Creates a payment for a `hold` order. A `hold` order can be paid for up to the time limit indicated in `payment_required_by`, after which the space held for the order will be released and you will have to create a new order. Before paying, you should always get the latest price by [retrieving the order](/docs/api/orders/get-order-by-id) to minimise the risk that the price you have is different from the latest price. If the price for an order has changed from the time of booking and you pass in the old price, then you will get a validation error on the `amount` field with a `price_changed` code. The price of an order should only change if the order has no price guarantee or the price guarantee has expired (ie. `price_guaranteed_expires_at` is `null` or in the past). If you receive a `500 Internal Server Error` when trying to create a payment for a `hold` order, it may have still been created on the airline’s side. Please contact Duffel support before trying the request again. ### Validation errors | Field | Code | Description | | ---------- | ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `order_id` | `order_type_not_eligible_for_payment` | This order can't be paid for because it isn't a `hold` order. | `amount` | `payment_amount_does_not_match_order_amount` | The `amount` provided in the payment doesn't match the `total_amount` of the order. | | `currency` | `payment_currency_does_not_match_order_currency` | The `currency` provided in the payment doesn't match the `total_currency` of the order. | ### Invalid states This endpoint can return the following errors with a `type` of `invalid_state`, to indicate a reason that the order can't be paid for: * `already_paid`: The order you’re paying for has already been paid for. * `already_cancelled`: The order you’re attempting to pay for has been cancelled. * `past_payment_required_by_date`: The order’s `payment_required_by` date has elapsed. * `schedule_changed`: You can't pay for this order because it has been changed in some way on the airline's side. You should start again, creating a new order.

      201 - A payment

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      createPaymentRequest - The createPaymentRequest parameter
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      contentType - All request bodies sent to the API should be in JSON format. A `Content-Type` header is required whenever you're sending a request body (i.e. for POST and PUT requests).
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getAirlineInitiatedChanges

      public reactor.core.publisher.Mono<GetAirlineInitiatedChanges200Response> getAirlineInitiatedChanges(String accept, String duffelVersion, String acceptEncoding, String orderId) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List airline-initiated changes Retrieves a list of all airline-initiated changes.

      200 - A list of airline-initiated changes

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      orderId - Filters airline-initiated changes by their order ID. Value must be a valid order ID. Check the [Order schema](/docs/api/orders/schema#orders-schema-id) for details.
      Returns:
      GetAirlineInitiatedChanges200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getAirlineInitiatedChangesWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetAirlineInitiatedChanges200Response>> getAirlineInitiatedChangesWithHttpInfo(String accept, String duffelVersion, String acceptEncoding, String orderId) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List airline-initiated changes Retrieves a list of all airline-initiated changes.

      200 - A list of airline-initiated changes

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      orderId - Filters airline-initiated changes by their order ID. Value must be a valid order ID. Check the [Order schema](/docs/api/orders/schema#orders-schema-id) for details.
      Returns:
      ResponseEntity<GetAirlineInitiatedChanges200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getAirlineInitiatedChangesWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getAirlineInitiatedChangesWithResponseSpec(String accept, String duffelVersion, String acceptEncoding, String orderId) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List airline-initiated changes Retrieves a list of all airline-initiated changes.

      200 - A list of airline-initiated changes

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      orderId - Filters airline-initiated changes by their order ID. Value must be a valid order ID. Check the [Order schema](/docs/api/orders/schema#orders-schema-id) for details.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOfferById

      public reactor.core.publisher.Mono<GetOfferById200Response> getOfferById(String accept, String duffelVersion, String id, String acceptEncoding, Boolean returnAvailableServices) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single offer You should use this API to get the complete, up-to-date information about an offer. This endpoint **does not** guarantee that the offer will be available at the time of booking. Due to limitations in airlines' systems, you may see changes to the offer (e.g a changed `total_amount`). Additionally, you may receive information that may have not been included in the original offer such as baggage allowances. Optionally, you can request information about additional `available_services` that you can book with this offer by specifying the `return_available_services` query parameter.

      200 - A single offer

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the offer
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      returnAvailableServices - When set to `true`, the offer resource returned will include all the `available_services` returned by the airline. If set to false, the offer resource won't include any `available_services`.
      Returns:
      GetOfferById200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOfferByIdWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOfferById200Response>> getOfferByIdWithHttpInfo(String accept, String duffelVersion, String id, String acceptEncoding, Boolean returnAvailableServices) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single offer You should use this API to get the complete, up-to-date information about an offer. This endpoint **does not** guarantee that the offer will be available at the time of booking. Due to limitations in airlines' systems, you may see changes to the offer (e.g a changed `total_amount`). Additionally, you may receive information that may have not been included in the original offer such as baggage allowances. Optionally, you can request information about additional `available_services` that you can book with this offer by specifying the `return_available_services` query parameter.

      200 - A single offer

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the offer
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      returnAvailableServices - When set to `true`, the offer resource returned will include all the `available_services` returned by the airline. If set to false, the offer resource won't include any `available_services`.
      Returns:
      ResponseEntity<GetOfferById200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOfferByIdWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getOfferByIdWithResponseSpec(String accept, String duffelVersion, String id, String acceptEncoding, Boolean returnAvailableServices) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single offer You should use this API to get the complete, up-to-date information about an offer. This endpoint **does not** guarantee that the offer will be available at the time of booking. Due to limitations in airlines' systems, you may see changes to the offer (e.g a changed `total_amount`). Additionally, you may receive information that may have not been included in the original offer such as baggage allowances. Optionally, you can request information about additional `available_services` that you can book with this offer by specifying the `return_available_services` query parameter.

      200 - A single offer

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the offer
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      returnAvailableServices - When set to `true`, the offer resource returned will include all the `available_services` returned by the airline. If set to false, the offer resource won't include any `available_services`.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOfferRequestById

      public reactor.core.publisher.Mono<GetOfferRequestById200Response> getOfferRequestById(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single offer request Retrieves an offer request by its ID

      200 - A single offer request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the offer request
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      GetOfferRequestById200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOfferRequestByIdWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOfferRequestById200Response>> getOfferRequestByIdWithHttpInfo(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single offer request Retrieves an offer request by its ID

      200 - A single offer request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the offer request
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseEntity<GetOfferRequestById200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOfferRequestByIdWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getOfferRequestByIdWithResponseSpec(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single offer request Retrieves an offer request by its ID

      200 - A single offer request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the offer request
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOfferRequests

      public reactor.core.publisher.Mono<GetOfferRequests200Response> getOfferRequests(String accept, String duffelVersion, String acceptEncoding, String after, String before, Integer limit) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List offer requests Retrieves a paginated list of your offer requests. The results may be returned in any order.

      200 - A paginated list of offer requests

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      Returns:
      GetOfferRequests200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOfferRequestsWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOfferRequests200Response>> getOfferRequestsWithHttpInfo(String accept, String duffelVersion, String acceptEncoding, String after, String before, Integer limit) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List offer requests Retrieves a paginated list of your offer requests. The results may be returned in any order.

      200 - A paginated list of offer requests

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      Returns:
      ResponseEntity<GetOfferRequests200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOfferRequestsWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getOfferRequestsWithResponseSpec(String accept, String duffelVersion, String acceptEncoding, String after, String before, Integer limit) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List offer requests Retrieves a paginated list of your offer requests. The results may be returned in any order.

      200 - A paginated list of offer requests

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOffers

      public reactor.core.publisher.Mono<GetOffers200Response> getOffers(String accept, String duffelVersion, String offerRequestId, String acceptEncoding, String after, String before, Integer limit, String sort, Integer maxConnections) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List offers Retrieves a list of offers for a given offer request specified by its ID. Unless you specify a `sort` parameter, the results may be returned in any order. This endpoint does not return the complete, up-to-date information on each offer. The [Get a single offer](/docs/api/offers/get-offer-by-id) endpoint should be called for a given offer in order to get complete and up-to-date information.

      200 - A paginated list of offers

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      offerRequestId - Duffel's unique identifier for the offer request, returned when it was created
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      sort - By default, the offers will be returned sorted by ID in ascending order. This parameter allows you to sort the list of offers by `total_amount` or `total_duration`. By default the sorting order will be ascending, if you wish to sort in descending order a `-` will need to be prepended to the sorting attribute (i.e: `-total_amount`).
      maxConnections - Allows to filter the offers list by the maximum number of connections in a given offer. e.g. a return flight with three flights outbound and a direct inbound flight would be filtered out if `max_connections=1` was passed.
      Returns:
      GetOffers200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOffersWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOffers200Response>> getOffersWithHttpInfo(String accept, String duffelVersion, String offerRequestId, String acceptEncoding, String after, String before, Integer limit, String sort, Integer maxConnections) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List offers Retrieves a list of offers for a given offer request specified by its ID. Unless you specify a `sort` parameter, the results may be returned in any order. This endpoint does not return the complete, up-to-date information on each offer. The [Get a single offer](/docs/api/offers/get-offer-by-id) endpoint should be called for a given offer in order to get complete and up-to-date information.

      200 - A paginated list of offers

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      offerRequestId - Duffel's unique identifier for the offer request, returned when it was created
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      sort - By default, the offers will be returned sorted by ID in ascending order. This parameter allows you to sort the list of offers by `total_amount` or `total_duration`. By default the sorting order will be ascending, if you wish to sort in descending order a `-` will need to be prepended to the sorting attribute (i.e: `-total_amount`).
      maxConnections - Allows to filter the offers list by the maximum number of connections in a given offer. e.g. a return flight with three flights outbound and a direct inbound flight would be filtered out if `max_connections=1` was passed.
      Returns:
      ResponseEntity<GetOffers200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOffersWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getOffersWithResponseSpec(String accept, String duffelVersion, String offerRequestId, String acceptEncoding, String after, String before, Integer limit, String sort, Integer maxConnections) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List offers Retrieves a list of offers for a given offer request specified by its ID. Unless you specify a `sort` parameter, the results may be returned in any order. This endpoint does not return the complete, up-to-date information on each offer. The [Get a single offer](/docs/api/offers/get-offer-by-id) endpoint should be called for a given offer in order to get complete and up-to-date information.

      200 - A paginated list of offers

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      offerRequestId - Duffel's unique identifier for the offer request, returned when it was created
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      sort - By default, the offers will be returned sorted by ID in ascending order. This parameter allows you to sort the list of offers by `total_amount` or `total_duration`. By default the sorting order will be ascending, if you wish to sort in descending order a `-` will need to be prepended to the sorting attribute (i.e: `-total_amount`).
      maxConnections - Allows to filter the offers list by the maximum number of connections in a given offer. e.g. a return flight with three flights outbound and a direct inbound flight would be filtered out if `max_connections=1` was passed.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderById

      public reactor.core.publisher.Mono<GetOrderById200Response> getOrderById(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order Retrieves an order by its ID

      200 - A single order

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      GetOrderById200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderByIdWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOrderById200Response>> getOrderByIdWithHttpInfo(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order Retrieves an order by its ID

      200 - A single order

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseEntity<GetOrderById200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderByIdWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getOrderByIdWithResponseSpec(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order Retrieves an order by its ID

      200 - A single order

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderCancellationById

      public reactor.core.publisher.Mono<CreateOrderCancellation201Response> getOrderCancellationById(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order cancellation Retrieves an order cancellation by its ID.

      200 - An order cancellation object

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order cancellation
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      CreateOrderCancellation201Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderCancellationByIdWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<CreateOrderCancellation201Response>> getOrderCancellationByIdWithHttpInfo(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order cancellation Retrieves an order cancellation by its ID.

      200 - An order cancellation object

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order cancellation
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseEntity<CreateOrderCancellation201Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderCancellationByIdWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getOrderCancellationByIdWithResponseSpec(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order cancellation Retrieves an order cancellation by its ID.

      200 - An order cancellation object

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order cancellation
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderCancellations

      public reactor.core.publisher.Mono<GetOrderCancellations200Response> getOrderCancellations(String accept, String duffelVersion, String acceptEncoding, String after, String before, Integer limit, String orderId) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List order cancellations Retrieves a paginated list of order cancellations

      200 - A paginated list of order cancellations

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      orderId - Filters the returned order cancellations by a specific order's unique identifier.
      Returns:
      GetOrderCancellations200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderCancellationsWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOrderCancellations200Response>> getOrderCancellationsWithHttpInfo(String accept, String duffelVersion, String acceptEncoding, String after, String before, Integer limit, String orderId) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List order cancellations Retrieves a paginated list of order cancellations

      200 - A paginated list of order cancellations

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      orderId - Filters the returned order cancellations by a specific order's unique identifier.
      Returns:
      ResponseEntity<GetOrderCancellations200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderCancellationsWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getOrderCancellationsWithResponseSpec(String accept, String duffelVersion, String acceptEncoding, String after, String before, Integer limit, String orderId) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List order cancellations Retrieves a paginated list of order cancellations

      200 - A paginated list of order cancellations

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      orderId - Filters the returned order cancellations by a specific order's unique identifier.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderChangeById

      public reactor.core.publisher.Mono<ConfirmOrderChange200Response> getOrderChangeById(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order change Retrieves an order change by its ID

      200 - A single order change

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order change
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ConfirmOrderChange200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderChangeByIdWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<ConfirmOrderChange200Response>> getOrderChangeByIdWithHttpInfo(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order change Retrieves an order change by its ID

      200 - A single order change

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order change
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseEntity<ConfirmOrderChange200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderChangeByIdWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getOrderChangeByIdWithResponseSpec(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order change Retrieves an order change by its ID

      200 - A single order change

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order change
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderChangeOfferById

      public reactor.core.publisher.Mono<GetOrderChangeOfferById200Response> getOrderChangeOfferById(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order change offer Retrieves an order change offer by its ID

      200 - A single order change offer

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order change offer
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      GetOrderChangeOfferById200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderChangeOfferByIdWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOrderChangeOfferById200Response>> getOrderChangeOfferByIdWithHttpInfo(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order change offer Retrieves an order change offer by its ID

      200 - A single order change offer

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order change offer
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseEntity<GetOrderChangeOfferById200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderChangeOfferByIdWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getOrderChangeOfferByIdWithResponseSpec(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order change offer Retrieves an order change offer by its ID

      200 - A single order change offer

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order change offer
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderChangeOffersByOrderChangeRequestId

      public reactor.core.publisher.Mono<GetOrderChangeOffersByOrderChangeRequestId200Response> getOrderChangeOffersByOrderChangeRequestId(String accept, String duffelVersion, String orderChangeRequestId, String acceptEncoding, String after, String before, Integer limit, String sort, Integer maxConnections) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List order change offers Returns a list of order change offers for a given order change requestID

      200 - A paginated list of order change offers

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      orderChangeRequestId - Duffel's unique identifier for the order change request
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      sort - By default, the offers will be returned sorted by ID in ascending order. This parameter allows you to sort the list of offers by `change_total_amount` or `total_duration`. By default the sorting order will be ascending, if you wish to sort in descending order a `-` will need to be prepended to the sorting attribute (i.e: `-change_total_amount`).
      maxConnections - Allows to filter the offers list by the maximum number of connections in a given offer. e.g. a return flight with three flights outbound and a direct inbound flight would be filtered out if `max_connections=1` was passed.
      Returns:
      GetOrderChangeOffersByOrderChangeRequestId200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderChangeOffersByOrderChangeRequestIdWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOrderChangeOffersByOrderChangeRequestId200Response>> getOrderChangeOffersByOrderChangeRequestIdWithHttpInfo(String accept, String duffelVersion, String orderChangeRequestId, String acceptEncoding, String after, String before, Integer limit, String sort, Integer maxConnections) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List order change offers Returns a list of order change offers for a given order change requestID

      200 - A paginated list of order change offers

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      orderChangeRequestId - Duffel's unique identifier for the order change request
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      sort - By default, the offers will be returned sorted by ID in ascending order. This parameter allows you to sort the list of offers by `change_total_amount` or `total_duration`. By default the sorting order will be ascending, if you wish to sort in descending order a `-` will need to be prepended to the sorting attribute (i.e: `-change_total_amount`).
      maxConnections - Allows to filter the offers list by the maximum number of connections in a given offer. e.g. a return flight with three flights outbound and a direct inbound flight would be filtered out if `max_connections=1` was passed.
      Returns:
      ResponseEntity<GetOrderChangeOffersByOrderChangeRequestId200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderChangeOffersByOrderChangeRequestIdWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getOrderChangeOffersByOrderChangeRequestIdWithResponseSpec(String accept, String duffelVersion, String orderChangeRequestId, String acceptEncoding, String after, String before, Integer limit, String sort, Integer maxConnections) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List order change offers Returns a list of order change offers for a given order change requestID

      200 - A paginated list of order change offers

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      orderChangeRequestId - Duffel's unique identifier for the order change request
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      sort - By default, the offers will be returned sorted by ID in ascending order. This parameter allows you to sort the list of offers by `change_total_amount` or `total_duration`. By default the sorting order will be ascending, if you wish to sort in descending order a `-` will need to be prepended to the sorting attribute (i.e: `-change_total_amount`).
      maxConnections - Allows to filter the offers list by the maximum number of connections in a given offer. e.g. a return flight with three flights outbound and a direct inbound flight would be filtered out if `max_connections=1` was passed.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderChangeRequestById

      public reactor.core.publisher.Mono<GetOrderChangeRequestById200Response> getOrderChangeRequestById(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order change request Retrieves an order change request by its ID

      200 - A single order change request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order change request
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      GetOrderChangeRequestById200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderChangeRequestByIdWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOrderChangeRequestById200Response>> getOrderChangeRequestByIdWithHttpInfo(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order change request Retrieves an order change request by its ID

      200 - A single order change request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order change request
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseEntity<GetOrderChangeRequestById200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrderChangeRequestByIdWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getOrderChangeRequestByIdWithResponseSpec(String accept, String duffelVersion, String id, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single order change request Retrieves an order change request by its ID

      200 - A single order change request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order change request
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrders

      public reactor.core.publisher.Mono<GetOrders200Response> getOrders(String accept, String duffelVersion, String acceptEncoding, String after, String before, Integer limit, String bookingReference, Boolean awaitingPayment, String sort, List<String> ownerId, List<String> originId, List<String> destinationId, GetOrdersDepartingAtParameter departingAt, GetOrdersArrivingAtParameter arrivingAt, GetOrdersCreatedAtParameter createdAt, List<String> passengerName, Boolean requiresAction) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List orders Retrieves a paginated list of all orders. The results may be returned in any order, unless a sorting parameter is provided.

      200 - A paginated list of orders

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      bookingReference - Filters orders by their `booking reference`. The filter requires an exact match but is case insensitive.
      awaitingPayment - Whether to filter orders that are awaiting payment or not. If not specified, all orders regardless of their payment state will be returned.
      sort - By default, orders aren't returned in any specific order. This parameter allows you to sort the list of orders by the `payment_required_by`, `total_amount`, `created_at`, or `next_departure`. If you wish to sort in descending order, a `-` prefix will be needed (e.g. `-payment_required_by`). When sorting by next departure (`next_departure`), flown orders will be last.
      ownerId - Filters the returned orders by `owner.id`. Values must be valid `airline.id`s. Check the [Airline schema](/docs/api/airlines/schema#id) for details.
      originId - Filters the returned orders by `origin`. Values must be valid origin identifiers. Check the [Order schema](/docs/api/orders#slices-origin-id) for details. Orders will be included if **any** of their slices matches the given criteria.
      destinationId - Filters the returned orders by `destination`. Values must be valid destination identifiers. Check the [Order schema](/docs/api/orders#slices-destination-id) for details. Orders will be included if **any** of their slices matches the given criteria.
      departingAt - Filters the returned orders by [departure datetime](/docs/api/orders/schema#slices-segments-departing_at). Orders will be included if **any** of their segments matches the given criteria.
      arrivingAt - Filters the returned orders by [arrival datetime](/docs/api/orders/schema#slices-segments-arriving_at). Orders will be included if **any** of their segments matches the given criteria.
      createdAt - Filters the returned orders by [creation datetime](docs/api/orders#created_at).
      passengerName - Filters the returned orders by passengers' `family_name` and `given_name`. Orders will be included if **any** of their passengers matches **any** of the given names. Matches are case insensitive, and include partial matches. For example, `?passenger_name[]=roger` will return orders for both `Anna Rogers` and `Roger Smith`.
      requiresAction - Orders will be included if they have any Airline-Inititated Changes that are unactioned.
      Returns:
      GetOrders200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrdersWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOrders200Response>> getOrdersWithHttpInfo(String accept, String duffelVersion, String acceptEncoding, String after, String before, Integer limit, String bookingReference, Boolean awaitingPayment, String sort, List<String> ownerId, List<String> originId, List<String> destinationId, GetOrdersDepartingAtParameter departingAt, GetOrdersArrivingAtParameter arrivingAt, GetOrdersCreatedAtParameter createdAt, List<String> passengerName, Boolean requiresAction) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List orders Retrieves a paginated list of all orders. The results may be returned in any order, unless a sorting parameter is provided.

      200 - A paginated list of orders

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      bookingReference - Filters orders by their `booking reference`. The filter requires an exact match but is case insensitive.
      awaitingPayment - Whether to filter orders that are awaiting payment or not. If not specified, all orders regardless of their payment state will be returned.
      sort - By default, orders aren't returned in any specific order. This parameter allows you to sort the list of orders by the `payment_required_by`, `total_amount`, `created_at`, or `next_departure`. If you wish to sort in descending order, a `-` prefix will be needed (e.g. `-payment_required_by`). When sorting by next departure (`next_departure`), flown orders will be last.
      ownerId - Filters the returned orders by `owner.id`. Values must be valid `airline.id`s. Check the [Airline schema](/docs/api/airlines/schema#id) for details.
      originId - Filters the returned orders by `origin`. Values must be valid origin identifiers. Check the [Order schema](/docs/api/orders#slices-origin-id) for details. Orders will be included if **any** of their slices matches the given criteria.
      destinationId - Filters the returned orders by `destination`. Values must be valid destination identifiers. Check the [Order schema](/docs/api/orders#slices-destination-id) for details. Orders will be included if **any** of their slices matches the given criteria.
      departingAt - Filters the returned orders by [departure datetime](/docs/api/orders/schema#slices-segments-departing_at). Orders will be included if **any** of their segments matches the given criteria.
      arrivingAt - Filters the returned orders by [arrival datetime](/docs/api/orders/schema#slices-segments-arriving_at). Orders will be included if **any** of their segments matches the given criteria.
      createdAt - Filters the returned orders by [creation datetime](docs/api/orders#created_at).
      passengerName - Filters the returned orders by passengers' `family_name` and `given_name`. Orders will be included if **any** of their passengers matches **any** of the given names. Matches are case insensitive, and include partial matches. For example, `?passenger_name[]=roger` will return orders for both `Anna Rogers` and `Roger Smith`.
      requiresAction - Orders will be included if they have any Airline-Inititated Changes that are unactioned.
      Returns:
      ResponseEntity<GetOrders200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getOrdersWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getOrdersWithResponseSpec(String accept, String duffelVersion, String acceptEncoding, String after, String before, Integer limit, String bookingReference, Boolean awaitingPayment, String sort, List<String> ownerId, List<String> originId, List<String> destinationId, GetOrdersDepartingAtParameter departingAt, GetOrdersArrivingAtParameter arrivingAt, GetOrdersCreatedAtParameter createdAt, List<String> passengerName, Boolean requiresAction) throws org.springframework.web.reactive.function.client.WebClientResponseException
      List orders Retrieves a paginated list of all orders. The results may be returned in any order, unless a sorting parameter is provided.

      200 - A paginated list of orders

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      after - A cursor pointing to the previous page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      before - A cursor pointing to the next page of records. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      limit - The maximum number of records to return per page. Defaults to `50`. May be set to any integer between `1` and `200`. For more information on how to paginate through records, see the [Pagination](/docs/api/overview/pagination) section.
      bookingReference - Filters orders by their `booking reference`. The filter requires an exact match but is case insensitive.
      awaitingPayment - Whether to filter orders that are awaiting payment or not. If not specified, all orders regardless of their payment state will be returned.
      sort - By default, orders aren't returned in any specific order. This parameter allows you to sort the list of orders by the `payment_required_by`, `total_amount`, `created_at`, or `next_departure`. If you wish to sort in descending order, a `-` prefix will be needed (e.g. `-payment_required_by`). When sorting by next departure (`next_departure`), flown orders will be last.
      ownerId - Filters the returned orders by `owner.id`. Values must be valid `airline.id`s. Check the [Airline schema](/docs/api/airlines/schema#id) for details.
      originId - Filters the returned orders by `origin`. Values must be valid origin identifiers. Check the [Order schema](/docs/api/orders#slices-origin-id) for details. Orders will be included if **any** of their slices matches the given criteria.
      destinationId - Filters the returned orders by `destination`. Values must be valid destination identifiers. Check the [Order schema](/docs/api/orders#slices-destination-id) for details. Orders will be included if **any** of their slices matches the given criteria.
      departingAt - Filters the returned orders by [departure datetime](/docs/api/orders/schema#slices-segments-departing_at). Orders will be included if **any** of their segments matches the given criteria.
      arrivingAt - Filters the returned orders by [arrival datetime](/docs/api/orders/schema#slices-segments-arriving_at). Orders will be included if **any** of their segments matches the given criteria.
      createdAt - Filters the returned orders by [creation datetime](docs/api/orders#created_at).
      passengerName - Filters the returned orders by passengers' `family_name` and `given_name`. Orders will be included if **any** of their passengers matches **any** of the given names. Matches are case insensitive, and include partial matches. For example, `?passenger_name[]=roger` will return orders for both `Anna Rogers` and `Roger Smith`.
      requiresAction - Orders will be included if they have any Airline-Inititated Changes that are unactioned.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getPartialOfferRequestById

      public reactor.core.publisher.Mono<GetOfferRequestById200Response> getPartialOfferRequestById(String accept, String duffelVersion, String id, String acceptEncoding, String selectedPartialOffer) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single partial offer request Retrieves a partial offers request by its ID, only including partial offers for the current slice of multi-step search flow.

      200 - A single partial offer request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the partial offer request
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      selectedPartialOffer - Duffel's unqiue identifier for the partial offer selected for previous slices. This parameter should be repeated for each selected partial offer.
      Returns:
      GetOfferRequestById200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getPartialOfferRequestByIdWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOfferRequestById200Response>> getPartialOfferRequestByIdWithHttpInfo(String accept, String duffelVersion, String id, String acceptEncoding, String selectedPartialOffer) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single partial offer request Retrieves a partial offers request by its ID, only including partial offers for the current slice of multi-step search flow.

      200 - A single partial offer request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the partial offer request
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      selectedPartialOffer - Duffel's unqiue identifier for the partial offer selected for previous slices. This parameter should be repeated for each selected partial offer.
      Returns:
      ResponseEntity<GetOfferRequestById200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getPartialOfferRequestByIdWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getPartialOfferRequestByIdWithResponseSpec(String accept, String duffelVersion, String id, String acceptEncoding, String selectedPartialOffer) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get a single partial offer request Retrieves a partial offers request by its ID, only including partial offers for the current slice of multi-step search flow.

      200 - A single partial offer request

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the partial offer request
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      selectedPartialOffer - Duffel's unqiue identifier for the partial offer selected for previous slices. This parameter should be repeated for each selected partial offer.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getPartialOfferRequestFaresById

      public reactor.core.publisher.Mono<GetOfferRequestById200Response> getPartialOfferRequestFaresById(String accept, String duffelVersion, String id, String selectedPartialOffer, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get full offer fares for selected partial offers Retrieves an offer request with offers for fares matching selected partial offers.

      200 - A single offer request with full offers for different fares matching selected itinerary in multi-step search flow.

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the partial offer request
      selectedPartialOffer - Duffel's unqiue identifier for the partial offer selected. This parameter should be repeated for each slice in the journey.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      GetOfferRequestById200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getPartialOfferRequestFaresByIdWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOfferRequestById200Response>> getPartialOfferRequestFaresByIdWithHttpInfo(String accept, String duffelVersion, String id, String selectedPartialOffer, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get full offer fares for selected partial offers Retrieves an offer request with offers for fares matching selected partial offers.

      200 - A single offer request with full offers for different fares matching selected itinerary in multi-step search flow.

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the partial offer request
      selectedPartialOffer - Duffel's unqiue identifier for the partial offer selected. This parameter should be repeated for each slice in the journey.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseEntity<GetOfferRequestById200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getPartialOfferRequestFaresByIdWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getPartialOfferRequestFaresByIdWithResponseSpec(String accept, String duffelVersion, String id, String selectedPartialOffer, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get full offer fares for selected partial offers Retrieves an offer request with offers for fares matching selected partial offers.

      200 - A single offer request with full offers for different fares matching selected itinerary in multi-step search flow.

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the partial offer request
      selectedPartialOffer - Duffel's unqiue identifier for the partial offer selected. This parameter should be repeated for each slice in the journey.
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getSeatMaps

      public reactor.core.publisher.Mono<GetSeatMaps200Response> getSeatMaps(String accept, String duffelVersion, String offerId, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get seat maps Gets seat maps by specific parameters. At the moment we only support querying by an offer ID. A list of seat maps, one per segment, will be returned, which you can use to build a seat selection UI for your customers. This is not available for all airlines or flights, so seat maps will not always be returned. If there are one or more passengers, you do not have to select a seat for each one. Each passenger can only select one seat per segment. Two passengers cannot select the same seat. As with other services when creating an order, the total amount charged will be the cost of the offer and any selected services.

      200 - A list of seat maps.

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      offerId - The offer ID which you want to get seat maps for
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      GetSeatMaps200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getSeatMapsWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetSeatMaps200Response>> getSeatMapsWithHttpInfo(String accept, String duffelVersion, String offerId, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get seat maps Gets seat maps by specific parameters. At the moment we only support querying by an offer ID. A list of seat maps, one per segment, will be returned, which you can use to build a seat selection UI for your customers. This is not available for all airlines or flights, so seat maps will not always be returned. If there are one or more passengers, you do not have to select a seat for each one. Each passenger can only select one seat per segment. Two passengers cannot select the same seat. As with other services when creating an order, the total amount charged will be the cost of the offer and any selected services.

      200 - A list of seat maps.

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      offerId - The offer ID which you want to get seat maps for
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseEntity<GetSeatMaps200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • getSeatMapsWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec getSeatMapsWithResponseSpec(String accept, String duffelVersion, String offerId, String acceptEncoding) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Get seat maps Gets seat maps by specific parameters. At the moment we only support querying by an offer ID. A list of seat maps, one per segment, will be returned, which you can use to build a seat selection UI for your customers. This is not available for all airlines or flights, so seat maps will not always be returned. If there are one or more passengers, you do not have to select a seat for each one. Each passenger can only select one seat per segment. Two passengers cannot select the same seat. As with other services when creating an order, the total amount charged will be the cost of the offer and any selected services.

      200 - A list of seat maps.

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      offerId - The offer ID which you want to get seat maps for
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • updateAirlineInitiatedChanges

      public reactor.core.publisher.Mono<UpdateAirlineInitiatedChanges200Response> updateAirlineInitiatedChanges(String accept, String duffelVersion, String id, String acceptEncoding, UpdateAirlineInitiatedChangesRequest updateAirlineInitiatedChangesRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Update an airline-initiated change This endpoint is only available to those airline-initiated changes that Duffel cannot accept on behalf of the customer. Duffel is unable to accept an airline-initiated change when these two conditions aretrue: the order was booked with the merchant's IATA number and Duffel is unable to accept the airline-initiated change programatically. In this case you, the customer, are responsible to resolve airline-initiated changes concerning this order (e.g. by contacting the airline directly). Once these have been resolved, you need to inform us of the action taken so we can mark it accordingly in our system.

      200 - A single airline-initiated change

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the airline-initiated change
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      updateAirlineInitiatedChangesRequest - The updateAirlineInitiatedChangesRequest parameter
      Returns:
      UpdateAirlineInitiatedChanges200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • updateAirlineInitiatedChangesWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<UpdateAirlineInitiatedChanges200Response>> updateAirlineInitiatedChangesWithHttpInfo(String accept, String duffelVersion, String id, String acceptEncoding, UpdateAirlineInitiatedChangesRequest updateAirlineInitiatedChangesRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Update an airline-initiated change This endpoint is only available to those airline-initiated changes that Duffel cannot accept on behalf of the customer. Duffel is unable to accept an airline-initiated change when these two conditions aretrue: the order was booked with the merchant's IATA number and Duffel is unable to accept the airline-initiated change programatically. In this case you, the customer, are responsible to resolve airline-initiated changes concerning this order (e.g. by contacting the airline directly). Once these have been resolved, you need to inform us of the action taken so we can mark it accordingly in our system.

      200 - A single airline-initiated change

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the airline-initiated change
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      updateAirlineInitiatedChangesRequest - The updateAirlineInitiatedChangesRequest parameter
      Returns:
      ResponseEntity<UpdateAirlineInitiatedChanges200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • updateAirlineInitiatedChangesWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec updateAirlineInitiatedChangesWithResponseSpec(String accept, String duffelVersion, String id, String acceptEncoding, UpdateAirlineInitiatedChangesRequest updateAirlineInitiatedChangesRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Update an airline-initiated change This endpoint is only available to those airline-initiated changes that Duffel cannot accept on behalf of the customer. Duffel is unable to accept an airline-initiated change when these two conditions aretrue: the order was booked with the merchant's IATA number and Duffel is unable to accept the airline-initiated change programatically. In this case you, the customer, are responsible to resolve airline-initiated changes concerning this order (e.g. by contacting the airline directly). Once these have been resolved, you need to inform us of the action taken so we can mark it accordingly in our system.

      200 - A single airline-initiated change

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the airline-initiated change
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      updateAirlineInitiatedChangesRequest - The updateAirlineInitiatedChangesRequest parameter
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • updateOfferPassengerById

      public reactor.core.publisher.Mono<UpdateOfferPassengerById200Response> updateOfferPassengerById(String accept, String duffelVersion, String offerId, String offerPassengerId, String acceptEncoding, UpdateOfferPassengerByIdRequest updateOfferPassengerByIdRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Update a single offer passenger Some offer passenger fields are updateable. Each field that can be updated is detailed in the request object.

      200 - A single offer passenger

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      offerId - Duffel's unique identifier for the __Offer__
      offerPassengerId - Duffel's unique identifier for the __Offer Passenger__
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      updateOfferPassengerByIdRequest - The updateOfferPassengerByIdRequest parameter
      Returns:
      UpdateOfferPassengerById200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • updateOfferPassengerByIdWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<UpdateOfferPassengerById200Response>> updateOfferPassengerByIdWithHttpInfo(String accept, String duffelVersion, String offerId, String offerPassengerId, String acceptEncoding, UpdateOfferPassengerByIdRequest updateOfferPassengerByIdRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Update a single offer passenger Some offer passenger fields are updateable. Each field that can be updated is detailed in the request object.

      200 - A single offer passenger

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      offerId - Duffel's unique identifier for the __Offer__
      offerPassengerId - Duffel's unique identifier for the __Offer Passenger__
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      updateOfferPassengerByIdRequest - The updateOfferPassengerByIdRequest parameter
      Returns:
      ResponseEntity<UpdateOfferPassengerById200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • updateOfferPassengerByIdWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec updateOfferPassengerByIdWithResponseSpec(String accept, String duffelVersion, String offerId, String offerPassengerId, String acceptEncoding, UpdateOfferPassengerByIdRequest updateOfferPassengerByIdRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Update a single offer passenger Some offer passenger fields are updateable. Each field that can be updated is detailed in the request object.

      200 - A single offer passenger

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      offerId - Duffel's unique identifier for the __Offer__
      offerPassengerId - Duffel's unique identifier for the __Offer Passenger__
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      updateOfferPassengerByIdRequest - The updateOfferPassengerByIdRequest parameter
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • updateOrderById

      public reactor.core.publisher.Mono<GetOrderById200Response> updateOrderById(String accept, String duffelVersion, String id, String acceptEncoding, UpdateOrderByIdRequest updateOrderByIdRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Update a single order Some order fields are updateable. Each field that can be updated is detailed in the request object.

      200 - A single order

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      updateOrderByIdRequest - The updateOrderByIdRequest parameter
      Returns:
      GetOrderById200Response
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • updateOrderByIdWithHttpInfo

      public reactor.core.publisher.Mono<org.springframework.http.ResponseEntity<GetOrderById200Response>> updateOrderByIdWithHttpInfo(String accept, String duffelVersion, String id, String acceptEncoding, UpdateOrderByIdRequest updateOrderByIdRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Update a single order Some order fields are updateable. Each field that can be updated is detailed in the request object.

      200 - A single order

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      updateOrderByIdRequest - The updateOrderByIdRequest parameter
      Returns:
      ResponseEntity<GetOrderById200Response>
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API

    • updateOrderByIdWithResponseSpec

      public org.springframework.web.reactive.function.client.WebClient.ResponseSpec updateOrderByIdWithResponseSpec(String accept, String duffelVersion, String id, String acceptEncoding, UpdateOrderByIdRequest updateOrderByIdRequest) throws org.springframework.web.reactive.function.client.WebClientResponseException
      Update a single order Some order fields are updateable. Each field that can be updated is detailed in the request object.

      200 - A single order

      Parameters:
      accept - All responses from the API are in JSON format with UTF-8 encoding. An `Accept` header is required with every request.
      duffelVersion - You'll need to send a `Duffel-Version` header with each request so we know which version of the API you want to use. Currently, the only available API version is `beta`.
      id - Duffel's unique identifier for the order
      acceptEncoding - We recommend enabling compression for responses returned by the API, since they can be very large. To enable compression, send an `Accept-Encoding` header. You'll need to configure your HTTP client to decompress responses. Most clients will have this functionality built-in.
      updateOrderByIdRequest - The updateOrderByIdRequest parameter
      Returns:
      ResponseSpec
      Throws:
      org.springframework.web.reactive.function.client.WebClientResponseException - if an error occurs while attempting to invoke the API