@duffel/api 1.29.0 → 2.0.0

package/dist/typings.d.ts

@@ -0,0 +1,3673 @@
+// Generated by dts-bundle v0.7.3
+// Dependencies for this module:
+//   ../Client
+//   ../types
+//   ../node-fetch
+
+declare module '@duffel/api' {
+    import { PaymentIntents } from '@duffel/api/DuffelPayments';
+    import { OfferRequests, Offers, OrderCancellations, Orders, OrderChangeRequests, OrderChangeOffers, OrderChanges, Payments, PartialOfferRequests, SeatMaps, AirlineInitiatedChanges } from '@duffel/api/booking';
+    import { Config, DuffelError as _DuffelError } from '@duffel/api/Client';
+    import { Aircraft, Airlines, Airports } from '@duffel/api/supportingResources';
+    import { Suggestions } from '@duffel/api/Places/Suggestions';
+    import { Refunds } from '@duffel/api/DuffelPayments/Refunds';
+    import { Sessions } from '@duffel/api/Links';
+    import { Webhooks } from '@duffel/api/notifications';
+    export interface DuffelAPIClient {
+        aircraft: Aircraft;
+        airlines: Airlines;
+        airports: Airports;
+        offers: Offers;
+        offerRequests: OfferRequests;
+        orders: Orders;
+        orderChangeRequests: OrderChangeRequests;
+        orderChangeOffers: OrderChangeOffers;
+        orderChanges: OrderChanges;
+        orderCancellations: OrderCancellations;
+        payments: Payments;
+        seatMaps: SeatMaps;
+    }
+    export class Duffel {
+        aircraft: Aircraft;
+        airlineInitiatedChanges: AirlineInitiatedChanges;
+        airlines: Airlines;
+        airports: Airports;
+        links: Sessions;
+        offerRequests: OfferRequests;
+        offers: Offers;
+        orders: Orders;
+        orderChangeRequests: OrderChangeRequests;
+        orderChangeOffers: OrderChangeOffers;
+        orderChanges: OrderChanges;
+        orderCancellations: OrderCancellations;
+        payments: Payments;
+        seatMaps: SeatMaps;
+        paymentIntents: PaymentIntents;
+        partialOfferRequests: PartialOfferRequests;
+        suggestions: Suggestions;
+        refunds: Refunds;
+        webhooks: Webhooks;
+        constructor(config: Config);
+    }
+    export const DuffelError: typeof _DuffelError;
+}
+
+declare module '@duffel/api/DuffelPayments' {
+    export * from '@duffel/api/DuffelPayments/PaymentIntents';
+}
+
+declare module '@duffel/api/booking' {
+    export * from '@duffel/api/booking/AirlineInitiatedChanges';
+    export * from '@duffel/api/booking/OfferRequests';
+    export * from '@duffel/api/booking/Offers';
+    export * from '@duffel/api/booking/OrderCancellations';
+    export * from '@duffel/api/booking/Orders';
+    export * from '@duffel/api/booking/OrderChangeRequests';
+    export * from '@duffel/api/booking/OrderChangeOffers';
+    export * from '@duffel/api/booking/OrderChanges';
+    export * from '@duffel/api/booking/Payments';
+    export * from '@duffel/api/booking/PartialOfferRequests';
+    export * from '@duffel/api/booking/SeatMaps';
+}
+
+declare module '@duffel/api/Client' {
+    import { DuffelResponse, SDKOptions, ApiResponseMeta, ApiResponseError } from '@duffel/api/types';
+    export interface Config {
+        token: string;
+        basePath?: string;
+        apiVersion?: string;
+        debug?: SDKOptions;
+        source?: string;
+    }
+    export class DuffelError extends Error {
+        meta: ApiResponseMeta;
+        errors: ApiResponseError[];
+        headers: Record<string, string>;
+        constructor({ meta, errors, headers, }: {
+            meta: ApiResponseMeta;
+            errors: ApiResponseError[];
+            headers: Record<string, string>;
+        });
+    }
+    export class Client {
+        constructor({ token, basePath, apiVersion, debug, source }: Config);
+        request: <T_Data = any>({ method, path, data, params, compress, }: {
+            method: string;
+            path: string;
+            data?: Record<string, any> | undefined;
+            params?: Record<string, any> | undefined;
+            compress?: boolean | undefined;
+        }) => Promise<DuffelResponse<T_Data>>;
+        paginatedRequest<T_Data = any>({ path, params, }: {
+            path: string;
+            params?: Record<string, any>;
+        }): AsyncGenerator<DuffelResponse<T_Data>, void, unknown>;
+    }
+}
+
+declare module '@duffel/api/supportingResources' {
+    export * from '@duffel/api/supportingResources/Aircraft';
+    export * from '@duffel/api/supportingResources/Airlines';
+    export * from '@duffel/api/supportingResources/Airports';
+}
+
+declare module '@duffel/api/Places/Suggestions' {
+    export * from '@duffel/api/Places/Suggestions/Suggestions';
+}
+
+declare module '@duffel/api/DuffelPayments/Refunds' {
+    export * from '@duffel/api/DuffelPayments/Refunds/Refunds';
+}
+
+declare module '@duffel/api/Links' {
+    export * from '@duffel/api/Links/Sessions';
+}
+
+declare module '@duffel/api/notifications' {
+    export * from '@duffel/api/notifications/Webhooks';
+}
+
+declare module '@duffel/api/DuffelPayments/PaymentIntents' {
+    export * from '@duffel/api/DuffelPayments/PaymentIntents/PaymentIntents';
+}
+
+declare module '@duffel/api/booking/AirlineInitiatedChanges' {
+    export * from '@duffel/api/booking/AirlineInitiatedChanges/AirlineInitiatedChanges';
+}
+
+declare module '@duffel/api/booking/OfferRequests' {
+    export * from '@duffel/api/booking/OfferRequests/OfferRequests';
+}
+
+declare module '@duffel/api/booking/Offers' {
+    export * from '@duffel/api/booking/Offers/Offers';
+}
+
+declare module '@duffel/api/booking/OrderCancellations' {
+    export * from '@duffel/api/booking/OrderCancellations/OrderCancellations';
+}
+
+declare module '@duffel/api/booking/Orders' {
+    export * from '@duffel/api/booking/Orders/Orders';
+}
+
+declare module '@duffel/api/booking/OrderChangeRequests' {
+    export * from '@duffel/api/booking/OrderChangeRequests/OrderChangeRequests';
+}
+
+declare module '@duffel/api/booking/OrderChangeOffers' {
+    export * from '@duffel/api/booking/OrderChangeOffers/OrderChangeOffers';
+}
+
+declare module '@duffel/api/booking/OrderChanges' {
+    export * from '@duffel/api/booking/OrderChanges/OrderChanges';
+}
+
+declare module '@duffel/api/booking/Payments' {
+    export * from '@duffel/api/booking/Payments/Payments';
+}
+
+declare module '@duffel/api/booking/PartialOfferRequests' {
+    export * from '@duffel/api/booking/PartialOfferRequests/PartialOfferRequests';
+}
+
+declare module '@duffel/api/booking/SeatMaps' {
+    export * from '@duffel/api/booking/SeatMaps/SeatMaps';
+}
+
+declare module '@duffel/api/types' {
+    export * from '@duffel/api/booking/AirlineInitiatedChanges/AirlineInitiatedChangesTypes';
+    export * from '@duffel/api/booking/OfferRequests/OfferRequestsTypes';
+    export * from '@duffel/api/booking/Offers/OfferTypes';
+    export * from '@duffel/api/booking/OrderCancellations/OrderCancellationsTypes';
+    export * from '@duffel/api/booking/OrderChangeOffers/OrderChangeOfferTypes';
+    export * from '@duffel/api/booking/OrderChangeRequests/OrderChangeRequestsTypes';
+    export * from '@duffel/api/booking/OrderChanges/OrderChangesTypes';
+    export * from '@duffel/api/booking/Orders/OrdersTypes';
+    export * from '@duffel/api/booking/Payments/PaymentsTypes';
+    export * from '@duffel/api/booking/SeatMaps/SeatMapTypes';
+    export * from '@duffel/api/supportingResources/Aircraft/AircraftTypes';
+    export * from '@duffel/api/supportingResources/Airlines/AirlinesTypes';
+    export * from '@duffel/api/supportingResources/Airports/AirportsTypes';
+    export * from '@duffel/api/DuffelPayments/PaymentIntents/PaymentIntentsType';
+    export * from '@duffel/api/Places/Suggestions/SuggestionsType';
+    export * from '@duffel/api/types/shared';
+    export * from '@duffel/api/types/ClientType';
+    export * from '@duffel/api/notifications/Webhooks/WebhooksType';
+}
+
+declare module '@duffel/api/supportingResources/Aircraft' {
+    export * from '@duffel/api/supportingResources/Aircraft/Aircraft';
+}
+
+declare module '@duffel/api/supportingResources/Airlines' {
+    export * from '@duffel/api/supportingResources/Airlines/Airlines';
+    export * as AirlineType from '@duffel/api/supportingResources/Airlines/AirlinesTypes';
+}
+
+declare module '@duffel/api/supportingResources/Airports' {
+    export * from '@duffel/api/supportingResources/Airports/Airports';
+    export * as AirportType from '@duffel/api/supportingResources/Airports/AirportsTypes';
+}
+
+declare module '@duffel/api/Places/Suggestions/Suggestions' {
+    import { Client } from 'Client';
+    import { Resource } from '@duffel/api/Resource';
+    import { DuffelResponse, Places } from '@duffel/api/types';
+    interface PlacesSuggestionsParameters {
+            /**
+                * A search string for finding matching Places.
+                */
+            query: string;
+    }
+    /**
+        * A Place is a city or airport that can serve as an origin or destination.
+        * * @link https://duffel.com/docs/api/places
+        */
+    export class Suggestions extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(client: Client);
+            /**
+                * Retrieves a list of Places matching the provided query
+                */
+            list: (params: PlacesSuggestionsParameters) => Promise<DuffelResponse<Places[]>>;
+    }
+    export {};
+}
+
+declare module '@duffel/api/DuffelPayments/Refunds/Refunds' {
+    import { Resource } from '@duffel/api/Resource';
+    import { DuffelResponse } from '@duffel/api/types';
+    import { CreateRefund, Refund } from '@duffel/api/DuffelPayments/Refunds/RefundsType';
+    export class Refunds extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(args: any);
+            /**
+                * You should use this API to get the complete, up-to-date information about a Refund.
+                * @param {string} id - Duffel's unique identifier for the Refund
+                * @link https://duffel.com/docs/api/refunds/get-refund-by-id
+                */
+            get: (id: string) => Promise<DuffelResponse<Refund>>;
+            /**
+                * Create a Refund to refund some money to a customer that they paid using a Payment Intent. You must specify the amount and currency. The currency is currently limited to the currency in which the Payment Intent was made.
+                * @param {Object.<CreateFund>} params - Endpoint params (amount, currency and payment_intent_id)
+                */
+            create: (params: CreateRefund) => Promise<DuffelResponse<Refund>>;
+    }
+}
+
+declare module '@duffel/api/Links/Sessions' {
+    export * from '@duffel/api/Links/Sessions/Sessions';
+}
+
+declare module '@duffel/api/notifications/Webhooks' {
+    export * from '@duffel/api/notifications/Webhooks/Webhooks';
+}
+
+declare module '@duffel/api/DuffelPayments/PaymentIntents/PaymentIntents' {
+    import { DuffelResponse } from '@duffel/api/types';
+    import { Resource } from '@duffel/api/Resource';
+    import { CreatePaymentIntent, PaymentIntent } from '@duffel/api/DuffelPayments/PaymentIntents/PaymentIntentsType';
+    export class PaymentIntents extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(args: any);
+            /**
+                * You should use this API to get the complete, up-to-date information about a Payment Intent.
+                * @param {string} id - Duffel's unique identifier for the Payment Intent
+                * @link https://duffel.com/docs/api/payment-intents/get-payment-intent-by-id
+                */
+            get: (id: string) => Promise<DuffelResponse<PaymentIntent>>;
+            /**
+                * Once you've successfully collected the customer's card details, using the `client_token` from when you first created the Payment Intent, you then need to confirm it using this endpoint.
+                * Once confirmed, the amount charged to your customer's card will be added to your `Balance` (minus any Duffel Payment fees).
+                */
+            confirm: (id: string) => Promise<DuffelResponse<PaymentIntent>>;
+            /**
+                * To begin the process of collecting a card payment from your customer, you need to create a Payment Intent.
+                * The Payment Intent will contain a `client_token` that you use to collect the card payment in your application.
+                * If the Payment Intent is created in test mode you should use a [test card](https://duffel.com/docs/api/overview/test-mode/test-card-numbers).
+                * @param {Object.<CreatePaymentIntent>} params - Endpoint params (amount and string)
+                */
+            create: (params: CreatePaymentIntent) => Promise<DuffelResponse<PaymentIntent>>;
+    }
+}
+
+declare module '@duffel/api/booking/AirlineInitiatedChanges/AirlineInitiatedChanges' {
+    import { Client } from '@duffel/api/Client';
+    import { Resource } from '@duffel/api/Resource';
+    import { DuffelResponse, Order } from '@duffel/api/types';
+    import { AirlineInitiatedChange, AirlineInitiatedChangeActionTaken } from '@duffel/api/booking/AirlineInitiatedChanges/AirlineInitiatedChangesTypes';
+    /**
+        * Sometimes there can be changes to your order initiated by the airline, for
+        * example a flight being delayed. We record every one of these changes so that
+        * you can view them all or for an order. You can filter changes for a specific
+        * order using the `order_id` parameter.
+        *
+        * Each airline-initiated change contains an `added` and `removed` field. `added`
+        * contains the updated slices following the change. These slices and their
+        * segments may have a new ID based on the change. `removed` contains a list of
+        * slices and their segments as they were before the change.
+        */
+    export class AirlineInitiatedChanges extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(client: Client);
+            /**
+                * 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 are true: 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.
+                *
+                * @param {AirlineInitiatedChange['id']} id - Duffel's unique identifier for
+                * the airline-initiated change
+                *
+                * @param action_taken - The action taken in response to this
+                * airline-initiated change. Accepted, cancelled and changed reflect your
+                * action in accepting the change, cancelling the order or changing the order
+                * respectively.
+                *
+                * @link https://duffel.com/docs/api/v1/airline-initiated-changes/update-airline-initiated-changes
+                */
+            update: (id: AirlineInitiatedChange['id'], action_taken: AirlineInitiatedChangeActionTaken) => Promise<DuffelResponse<AirlineInitiatedChange>>;
+            /**
+                * Once there is an airline-initiated change you can choose to accept it.
+                *
+                * @param {AirlineInitiatedChange['id']} id - Duffel's unique identifier for
+                * the airline-initiated change
+                *
+                * @link https://duffel.com/docs/api/v1/airline-initiated-changes/accept-airline-initiated-changes
+                */
+            accept: (id: AirlineInitiatedChange['id']) => Promise<DuffelResponse<AirlineInitiatedChange>>;
+            /**
+                * Retrieves a list of all airline-initiated changes.
+                *
+                * @param order_id - Filters airline-initiated changes by their order ID.
+                * Value must be a valid order ID. Check the [Order schema](https://duffel.com/docs/api/orders/schema#orders-schema-id)
+                * for details.
+                *
+                * @link https://duffel.com/docs/api/v1/airline-initiated-changes/get-airline-initiated-changes
+                */
+            list: (order_id: Order['id']) => Promise<DuffelResponse<Order['airline_initiated_changes']>>;
+    }
+}
+
+declare module '@duffel/api/booking/OfferRequests/OfferRequests' {
+    import { Client } from 'Client';
+    import { Resource } from '@duffel/api/Resource';
+    import { CreateOfferRequest, CreateOfferRequestQueryParameters, DuffelResponse, OfferRequest, PaginationMeta } from '@duffel/api/types';
+    /**
+        * 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).
+        * @class
+        * @link https://duffel.com/docs/api/offer-requests
+        */
+    export class OfferRequests extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(client: Client);
+            /**
+                * Retrieves an offer request by its ID
+                * @param {string} id - Duffel's unique identifier for the offer request
+                * @link https:/duffel.com/docs/api/offer-requests/get-offer-request-by-id
+                */
+            get: (id: string) => Promise<DuffelResponse<OfferRequest>>;
+            /**
+                * Retrieves a page of offer requests. The results may be returned in any order.
+                * @param {Object} [options] - Pagination options (optional: limit, after, before)
+                * @link https://duffel.com/docs/api/offer-requests/get-offer-requests
+                */
+            list: (options?: PaginationMeta) => Promise<DuffelResponse<OfferRequest[]>>;
+            /**
+                * Retrieves a generator of all offer requests. The results may be returned in any order.
+                * @link https://duffel.com/docs/api/offer-requests/get-offer-requests
+                */
+            listWithGenerator: () => AsyncGenerator<DuffelResponse<OfferRequest>, void, unknown>;
+            /**
+                * 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).
+                * @param {Object} [options] - the parameters for making an offer requests (required: slices, passengers; optional: cabin_class, return_offers)
+                * When `return_offers` is set to `true`, the offer request resource returned will include all the `offers` returned by the airlines.
+                * If set to false, the offer request resource won't include any `offers`. To retrieve the associated offers later, use the List Offers endpoint, specifying the `offer_request_id`.
+                * @link https://duffel.com/docs/api/offer-requests/create-offer-request
+                */
+            create: <QueryParams extends CreateOfferRequestQueryParameters>(options: CreateOfferRequest & QueryParams) => Promise<DuffelResponse<QueryParams extends {
+                    return_offers: false;
+            } ? Omit<OfferRequest, "offers"> : OfferRequest>>;
+    }
+}
+
+declare module '@duffel/api/booking/Offers/Offers' {
+    import { Client } from 'Client';
+    import { Resource } from '@duffel/api/Resource';
+    import { DuffelResponse, ListOffersParams, Offer, LoyaltyProgrammeAccounts, UpdateOffer } from '@duffel/api/types';
+    interface UpdateOfferBodyParameters {
+            loyalty_programme_accounts: LoyaltyProgrammeAccounts[];
+            given_name: string;
+            family_name: string;
+    }
+    /**
+        * Each offer represents flights you can buy from an airline at a particular price that meet your search criteria.
+        * @class
+        * @link https://duffel.com/docs/api/offers
+        */
+    export class Offers extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(client: Client);
+            /**
+                * Retrieves an offer by its ID
+                * @param {string} id - Duffel's unique identifier for the offer
+                * @param {string} return_available_services - 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.
+                * @link https:/duffel.com/docs/api/offers/get-offer-by-id
+                */
+            get: (id: string, params?: {
+                    return_available_services: boolean;
+            }) => Promise<DuffelResponse<Offer>>;
+            /**
+                * Retrieves a page of offers. The results may be returned in any order.
+                * @param {Object.<ListOffersParams>} params - Endpoint options (optional: limit, after, before, max_connections, sort)
+                * @param {string} params.offer_request_id - Duffel's unique identifier for the offer request, returned when it was created
+                * @link https://duffel.com/docs/api/offers/get-offers
+                */
+            list: ({ offer_request_id, ...params }: ListOffersParams) => Promise<DuffelResponse<Offer[]>>;
+            /**
+                * Retrieves a generator of all offers. The results may be returned in any order.
+                * @param {Object.<ListOffersParams>} params - Endpoint options (optional: limit, after, before, max_connections, sort)
+                * @param {string} params.offer_request_id - Duffel's unique identifier for the offer request, returned when it was created
+                * @link https://duffel.com/docs/api/offers/get-offers
+                */
+            listWithGenerator: ({ offer_request_id, ...params }: ListOffersParams) => AsyncGenerator<DuffelResponse<Offer>, void, unknown>;
+            /**
+                * Some offer passenger fields are updateable. Each field that can be updated is detailed in the request object.
+                * @param {string} offerId - Duffel's unique identifier for the offer
+                * @param {string} passengerId - The identifier for the passenger. This ID will be generated by Duffel
+                * @param {string} params.family_name - The passenger's family name. Only space, -, ', and letters from the ASCII, Latin-1 Supplement and Latin Extended-A (with the exceptions of Æ, æ, IJ, ij, Œ, œ, Þ, and ð) Unicode charts are accepted. All other characters will result in a validation error. The minimum length is 1 character, and the maximum is 20 characters.
+                * @param {string} params.given_name - The passenger's given name. Only space, -, ', and letters from the ASCII, Latin-1 Supplement and Latin Extended-A (with the exceptions of Æ, æ, IJ, ij, Œ, œ, Þ, and ð) Unicode charts are accepted. All other characters will result in a validation error. The minimum length is 1 character, and the maximum is 20 characters.
+                * @param {Object.<LoyaltyProgrammeAccounts>} params.loyalty_programme_accounts - The Loyalty Programme Accounts for this passenger
+                */
+            update: (offerId: string, passengerId: string, params: UpdateOfferBodyParameters) => Promise<DuffelResponse<UpdateOffer>>;
+    }
+    export {};
+}
+
+declare module '@duffel/api/booking/OrderCancellations/OrderCancellations' {
+    import { Resource } from '@duffel/api/Resource';
+    import { CreateOrderCancellation, DuffelResponse, OrderCancellation, ListOrderCancellationsParams } from '@duffel/api/types';
+    export class OrderCancellations extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(args: any);
+            /**
+                * Retrieves an order cancellation by its ID
+                * @param {string} id - Duffel's unique identifier for the order cancellation
+                * @link https:/duffel.com/docs/api/order-cancellations/get-order-cancellation-by-id
+                */
+            get: (id: string) => Promise<DuffelResponse<OrderCancellation>>;
+            /**
+                * Retrieves a page of order cancellations. The results may be returned in any order.
+                * @param {Object.<ListOrderCancellationsParams>} params - Endpoint options (optional: limit, after, before, order_id)
+                * @link https://duffel.com/docs/api/order-cancellations/get-order-cancellations
+                */
+            list: (params?: ListOrderCancellationsParams) => Promise<DuffelResponse<OrderCancellation[]>>;
+            /**
+                * Retrieves a generator of all order cancellations. The results may be returned in any order.
+                * @param {Object.<ListOrderCancellationsParams>} params - Endpoint options (optional: limit, after, before, order_id)
+                * @link https://duffel.com/docs/api/order-cancellations/get-order-cancellations
+                */
+            listWithGenerator: (params?: ListOrderCancellationsParams) => AsyncGenerator<DuffelResponse<OrderCancellation>, void, unknown>;
+            /**
+                * Create order cancellation
+                * @description To begin the process of cancelling an order you need to create an order cancellation.
+                * @param order_id - Duffel's unique identifier for the order
+                * @link https://duffel.com/docs/api/order-cancellations/create-order-cancellation
+                */
+            create: (options: CreateOrderCancellation) => Promise<DuffelResponse<OrderCancellation>>;
+            /**
+                * Confirm order cancellation
+                * @description Once you've created a pending order cancellation, you'll know the `refund_amount` you're due to get back.
+                * @param {string} id - Duffel's unique identifier for the order to cancel
+                * @link https://duffel.com/docs/api/order-cancellations/confirm-order-cancellation
+                */
+            confirm: (id: string) => Promise<DuffelResponse<OrderCancellation>>;
+    }
+}
+
+declare module '@duffel/api/booking/Orders/Orders' {
+    import { Resource } from '@duffel/api/Resource';
+    import { AddServices, CreateOrder, DuffelResponse, ListParamsOrders, Order, OrderAvailableService, PaginationMeta, UpdateSingleOrder } from '@duffel/api/types';
+    export class Orders extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(args: any);
+            /**
+                * Retrieves an order by its ID
+                * @param {string} id - Duffel's unique identifier for the order
+                */
+            get: (id: string) => Promise<DuffelResponse<Order>>;
+            /**
+                * Retrieves a page of orders. The results may be returned in any order.
+                * @param {Object} [options] - Pagination options (optional: limit, after, before)
+                * @link https://duffel.com/docs/api/orders/get-orders
+                */
+            list: (options?: PaginationMeta & ListParamsOrders) => Promise<DuffelResponse<Order[]>>;
+            /**
+                * Retrieves a generator of all orders. The results may be returned in any order.
+                * You can optionally filter the results by the `awaiting_payment` state and sort by the `payment_required_by` date.
+                * @param {Object} [options] - Optional query parameters: awaiting_payment, sort
+                * @link https://duffel.com/docs/api/orders/get-orders
+                */
+            listWithGenerator: (options?: ListParamsOrders) => AsyncGenerator<DuffelResponse<Order>, void, unknown>;
+            /**
+                * Creates a booking with an airline based on an offer.
+                */
+            create: (options: CreateOrder) => Promise<DuffelResponse<Order>>;
+            /**
+                * Updates a single order
+                * @description Some order fields are updateable. Each field that can be updated is detailed in the request object.
+                * @param {string} id - Duffel's unique identifier for the order
+                * @param {Object.UpdateSingleOrder} options
+                * @example (id: 'ord_00009hthhsUZ8W4LxQgkjo', { metadata: { 'payment_intent_id': 'pit_00009htYpSCXrwaB9DnUm2' } } )
+                * @link https://duffel.com/docs/api/orders/update-order-by-id
+                */
+            update: (id: string, options: UpdateSingleOrder) => Promise<DuffelResponse<Order>>;
+            /**
+                * Retrieves the available services for an order by its ID
+                * @param {string} id - Duffel's unique identifier for the order
+                */
+            getAvailableServices: (id: string) => Promise<DuffelResponse<OrderAvailableService[]>>;
+            /**
+                * Adds services for an order by its ID
+                * @param {string} id - Duffel's unique identifier for the order
+                * @param {Object.AddServices} options
+                * @link https://duffel.com/docs/api/orders/create-order-services
+                */
+            addServices: (id: string, options: AddServices) => Promise<DuffelResponse<Order>>;
+    }
+}
+
+declare module '@duffel/api/booking/OrderChangeRequests/OrderChangeRequests' {
+    import { Resource } from '@duffel/api/Resource';
+    import { CreateOrderChangeRequest, DuffelResponse, OrderChangeRequestResponse } from '@duffel/api/types';
+    /**
+        *
+        * To change an order, you'll need to create an order change request.
+        * This is still in PREVIEW mode
+        * @export
+        * @class OrderChangeRequests
+        * @extends {Resource}
+        */
+    export class OrderChangeRequests extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(args: any);
+            /**
+                * Retrieves an order change request by its ID
+                * @param {string} id - The ID of your order change request
+                */
+            get: (id: string) => Promise<DuffelResponse<OrderChangeRequestResponse>>;
+            /**
+                *
+                * To change flights on an existing paid order, you'll need to create an order change request.
+                * @link https://duffel.com/docs/api/order-change-requests/create-order-change-request
+                * @memberof OrderChangeRequests
+                */
+            create: (options: CreateOrderChangeRequest) => Promise<DuffelResponse<OrderChangeRequestResponse>>;
+    }
+}
+
+declare module '@duffel/api/booking/OrderChangeOffers/OrderChangeOffers' {
+    import { Resource } from '@duffel/api/Resource';
+    import { DuffelResponse, OrderChangeOffer, PaginationMeta } from '@duffel/api/types';
+    /**
+        * After you've searched for flights to add to your order by creating an order change request, we'll send your search to a range of airlines, which may return order change offers.
+        * This is still in PREVIEW mode
+        * @export
+        * @class OrderChangeOffers
+        * @extends {Resource}
+        */
+    export class OrderChangeOffers extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(args: any);
+            /**
+                * Retrieves an order change offer by its ID
+                * @param {string} id - The ID of your order change offer
+                * @link https://duffel.com/docs/api/order-change-offers/get-order-change-offer-by-id
+                */
+            get: (id: string) => Promise<DuffelResponse<OrderChangeOffer>>;
+            /**
+                * Retrieves a page of order change offers. The results may be returned in any order.
+                * @param {Object} [options] - Pagination options (optional: limit, after, before)
+                */
+            list: (options?: PaginationMeta) => Promise<DuffelResponse<OrderChangeOffer[]>>;
+            /**
+                * Retrieves a generator of all order change offers. The results may be returned in any order.
+                */
+            listWithGenerator: () => AsyncGenerator<DuffelResponse<OrderChangeOffer>, void, unknown>;
+    }
+}
+
+declare module '@duffel/api/booking/OrderChanges/OrderChanges' {
+    import { Resource } from '@duffel/api/Resource';
+    import { ConfirmOrderChangePayment, CreateOrderChangeParameters, DuffelResponse, OrderChangeOfferSlice } from '@duffel/api/types';
+    /**
+        * Once you've created an order change request, and you've chosen which slices to add and remove, you'll then want to create an order change.
+        */
+    export class OrderChanges extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(args: any);
+            /**
+                * 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.
+                * @link https://duffel.com/docs/api/order-changes/create-order-change
+                */
+            create: (options: CreateOrderChangeParameters) => Promise<DuffelResponse<OrderChangeOfferSlice>>;
+            /**
+                * Retrieves an order change by its ID
+                * @param {string} id - Duffel's unique identifier for the order change
+                * @link https://duffel.com/docs/api/order-changes/get-order-change-by-id
+                */
+            get: (id: string) => Promise<DuffelResponse<OrderChangeOfferSlice>>;
+            /**
+                * Once you've created a pending order change, you'll know the change_total_amount due for the change.
+                * @param {string} id - Duffel's unique identifier for the order change
+                * @param {payment} Object - The payment details to use to pay for the order change, if there is an amount to be paid. Some order changes may not need this if they instead refund an amount. In those cases, you can pass any empty object.
+                * @link https://duffel.com/docs/api/order-changes/confirm-order-change
+                */
+            confirm: (id: string, options: Partial<ConfirmOrderChangePayment>) => Promise<DuffelResponse<OrderChangeOfferSlice>>;
+    }
+}
+
+declare module '@duffel/api/booking/Payments/Payments' {
+    import { Resource } from '@duffel/api/Resource';
+    import { CreatePayment, DuffelResponse, Payment } from '@duffel/api/types';
+    export class Payments extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(args: any);
+            /**
+                * Creates a payment for an existing pay later order.
+                * An 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.
+                * @param {string} order_id
+                * @param {string} payment
+                */
+            create: (options: CreatePayment) => Promise<DuffelResponse<Payment>>;
+    }
+}
+
+declare module '@duffel/api/booking/PartialOfferRequests/PartialOfferRequests' {
+    import { Client } from 'Client';
+    import { Resource } from '@duffel/api/Resource';
+    import { CreateOfferRequest, DuffelResponse, OfferRequest } from '@duffel/api/types';
+    import { SelectedPartialOffersParams } from '@duffel/api/booking/PartialOfferRequests/PartialOfferRequestTypes';
+    /**
+        * 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).
+        * @class
+        * @link https://duffel.com/docs/api/partial-offer-requests
+        */
+    export class PartialOfferRequests extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(client: Client);
+            /**
+                * Retrieves a partial offers request by its ID, only including partial offers for the current slice of multi-step search flow.
+                * @param {string} id - Duffel's unique identifier for the partial offer request
+                * @param {Object} [options] - Selected partial offers
+                * @link https:/duffel.com/docs/api/partial-offer-requests/get-partial-offer-request-by-id
+                */
+            get: (id: string, options?: SelectedPartialOffersParams) => Promise<DuffelResponse<OfferRequest>>;
+            /**
+                * 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).
+                * @param {Object} [options] - the parameters for making a partial offer requests (required: slices, passengers; optional: cabin_class)
+                * @link https://duffel.com/docs/api/partial-offer-requests/create-partial-offer-request
+                */
+            create: <QueryParams>(options: CreateOfferRequest & QueryParams) => Promise<DuffelResponse<OfferRequest>>;
+            /**
+                * Retrieves an offer request with offers for fares matching selected partial offers..
+                * @param {string} id - Duffel's unique identifier for the partial offer request
+                * @param {Object} [options] - Selected partial offers
+                * @link https:/duffel.com/docs/api/partial-offer-requests/get-partial-offer-request-fares-by-id
+                */
+            getFaresById: (id: string, options?: SelectedPartialOffersParams) => Promise<DuffelResponse<OfferRequest>>;
+    }
+}
+
+declare module '@duffel/api/booking/SeatMaps/SeatMaps' {
+    import { Resource } from '@duffel/api/Resource';
+    import { DuffelResponse, SeatMap } from '@duffel/api/types';
+    export class SeatMaps extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(args: any);
+            /**
+                * Gets seat maps by specific parameters. At the moment we only support querying by an offer ID.
+                * @param {string} offer_id - Duffel's unique identifier for the offer
+                * @link https://duffel.com/docs/api/seat-maps/get-seat-maps
+                */
+            get: (params: {
+                    offer_id: string;
+            }) => Promise<DuffelResponse<SeatMap>>;
+    }
+}
+
+declare module '@duffel/api/booking/AirlineInitiatedChanges/AirlineInitiatedChangesTypes' {
+    import { OrderSlice } from 'types';
+    export type AirlineInitiatedChangeActionTaken = 'accepted' | 'cancelled' | 'changed';
+    export type AirlineInitiatedChangeAvailableAction = 'accept' | 'cancel' | 'change' | 'update';
+    export interface AirlineInitiatedChange {
+            /**
+                * The action taken in response to this airline-initiated change. Accepted,
+                * cancelled and changed reflect your action in accepting the change,
+                * cancelling the order or changing the order respectively.
+                */
+            action_taken: AirlineInitiatedChangeActionTaken | null;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which an
+                * action was taken.
+                */
+            action_taken_at: string | null;
+            /**
+                * List of updated (slices and segments)[https://duffel.com/docs/api/orders/schema#orders-schema-slices]
+                * following the change. These slices and segments may each have a new ID as a
+                * result of the changes.
+                */
+            added: OrderSlice[];
+            /**
+                * The available actions you can take on this Airline-Initiated Change through
+                * our API.`"update"` means that you can use the update endpoint for an
+                * Airline-Initiated Change.
+                */
+            available_actions: AirlineInitiatedChangeAvailableAction[];
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which we
+                * detected the airline-initiated change.
+                */
+            created_at: string;
+            /**
+                * Duffel's unique identifier for the airline-initiated change.
+                */
+            id: string;
+            /**
+                * Duffel's unique identifier for the order.
+                */
+            order_id: string;
+            /**
+                * List of (slices and segments)[https://duffel.com/docs/api/orders/schema#orders-schema-slices]
+                * as they were before the change.
+                */
+            removed: OrderSlice[];
+            /**
+                * The associated Travel Agent Ticket, if any, for this Airline-Initiated
+                * Change. This value will be present for Airline-Initiated changes that take
+                * some time to be processed.
+                */
+            travel_agent_ticket: any | null;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which
+                * the airline-initiated change was last updated.
+                */
+            updated_at: string;
+    }
+}
+
+declare module '@duffel/api/booking/OfferRequests/OfferRequestsTypes' {
+    import { Airline, CabinClass, DuffelPassengerType, Place, PlaceType } from '@duffel/api/types';
+    import { Offer } from '@duffel/api/booking/Offers/OfferTypes';
+    export interface OfferRequestSlice {
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date on which the passengers want to depart
+                */
+            departure_date: string;
+            /**
+                * The city or airport the passengers want to travel to
+                */
+            destination: Place | string;
+            /**
+                * The city or airport the passengers want to depart from
+                */
+            origin: Place | string;
+            /**
+                * The type of the origin
+                */
+            origin_type: PlaceType;
+            /**
+                * The type of the destination
+                */
+            destination_type: PlaceType;
+    }
+    interface CreateOfferRequestPassengerCommon {
+            /**
+                * The passenger's family name. Only `space`, `-`, `'`, and letters from the
+                * `ASCII`, `Latin-1 Supplement` and `Latin Extended-A` (with the exceptions
+                * of `Æ`, `æ`, `IJ`, `ij`, `Œ`, `œ`, `Þ`, and `ð`) Unicode charts are accepted.
+                * All other characters will result in a validation error. The minimum length
+                * is 1 character, and the maximum is 20 characters.
+                *
+                * This is only required if you're also including
+                * **Loyalty Programme Accounts**.
+                */
+            family_name?: string;
+            /**
+                * The passenger's given name. Only `space`, `-`, `'`, and letters from the
+                * `ASCII`, `Latin-1 Supplement` and `Latin Extended-A` (with the exceptions
+                * of `Æ`, `æ`, `IJ`, `ij`, `Œ`, `œ`, `Þ`, and `ð`) Unicode charts are accepted.
+                * All other characters will result in a validation error. The minimum length
+                * is 1 character, and the maximum is 20 characters.
+                *
+                * This is only required if you're also including
+                * **Loyalty Programme Accounts**.
+                */
+            given_name?: string;
+            /**
+                * The **Loyalty Programme Accounts** for this passenger.
+                */
+            loyalty_programme_accounts?: LoyaltyProgrammeAccount[];
+    }
+    interface CreateOfferRequestAdultPassenger extends CreateOfferRequestPassengerCommon {
+            age?: never;
+            fare_type?: never;
+            /**
+                * The type of the passenger. If the passenger is aged 18 or over, you should
+                * specify a `type` of `adult`. If a passenger is aged under 18, you should
+                * specify their `age` instead of a `type`. A passenger can have only a type
+                * or an age, but not both.
+                */
+            type: Extract<DuffelPassengerType, 'adult'>;
+    }
+    interface CreateOfferRequestNonAdultPassenger extends CreateOfferRequestPassengerCommon {
+            /**
+                * The age of the passenger on the `departure_date` of the final slice. e.g.
+                * if you a searching for a round trip and the passenger is 15 years old at
+                * the time of the outbound flight, but they then have their birthday and are
+                * 16 years old for the inbound flight, you must set the age to 16. You should
+                * specify an `age` for passengers who are under 18 years old. A passenger can
+                * have only a type or an age, but not both. You can optionally pass age with
+                * `fare_type` though.
+                */
+            age: number;
+            fare_type?: never;
+            type?: never;
+    }
+    export type CreateOfferRequestPassengerFareType = 'accompanying_adult' | 'contract_bulk' | 'contract_bulk_child' | 'contract_bulk_infant_with_seat' | 'contract_bulk_infant_without_seat' | 'frequent_flyer' | 'group_inclusive_tour' | 'group_inclusive_tour_child' | 'humanitarian' | 'individual_inclusive_tour_child' | 'marine' | 'seat_only' | 'student' | 'teacher' | 'tour_operator_inclusive' | 'tour_operator_inclusive_infant' | 'unaccompanied_child' | 'visiting_friends_and_family';
+    interface CreateOfferRequestPassengerWithFareType extends CreateOfferRequestPassengerCommon {
+            /**
+                * The age of the passenger on the `departure_date` of the final slice. e.g.
+                * if you a searching for a round trip and the passenger is 15 years old at
+                * the time of the outbound flight, but they then have their birthday and are
+                * 16 years old for the inbound flight, you must set the age to 16. You should
+                * specify an `age` for passengers who are under 18 years old. A passenger can
+                * have only a type or an age, but not both. You can optionally pass age with
+                * `fare_type` though.
+                */
+            age?: number;
+            /**
+                * The fare type of the passenger. If the passenger is aged less than 18, you
+                * should pass in age as well.
+                */
+            fare_type: CreateOfferRequestPassengerFareType;
+            type?: never;
+    }
+    export type CreateOfferRequestPassenger = CreateOfferRequestAdultPassenger | CreateOfferRequestNonAdultPassenger | CreateOfferRequestPassengerWithFareType;
+    export interface CreateOfferRequestPrivateFare {
+            corporate_code: string;
+            tracking_reference: string;
+    }
+    /**
+        * The passengers who want to travel. A passenger will have only a type or an age.
+        */
+    export interface OfferRequestPassenger {
+            /**
+                * The age of the passenger on the `departure_date` of the final slice.
+                */
+            age?: number;
+            /**
+                * The type of the passenger.
+                */
+            type?: DuffelPassengerType;
+            /**
+                * The passenger's family name. Only `space`, `-`, `'`, and letters from the `ASCII`, `Latin-1 Supplement` and `Latin
+                * Extended-A` (with the exceptions of `Æ`, `æ`, `IJ`, `ij`, `Œ`, `œ`, `Þ`, , and `ð`) Unicode charts are accepted. All
+                * other characters will result in a validation error. The minimum length is 1 character, and the maximum is 20
+                * characters.
+                *
+                * This is only required if you're also including **Loyalty Programme Accounts**.
+                */
+            family_name?: string;
+            /**
+                * The passenger's given name. Only `space`, `-`, `'`, and letters from the `ASCII`, `Latin-1 Supplement` and `Latin
+                * Extended-A` (with the exceptions of `Æ`, `æ`, `IJ`, `ij`, `Œ`, `œ`, `Þ`, , and `ð`) Unicode charts are accepted. All
+                * other characters will result in a validation error. The minimum length is 1 character, and the maximum is 20
+                * characters.
+                *
+                * This is only required if you're also including **Loyalty Programme Accounts**.
+                */
+            given_name?: string;
+            /**
+                * The **Loyalty Programme Accounts** for this passenger.
+                */
+            loyalty_programme_accounts?: LoyaltyProgrammeAccount[];
+            /**
+                * The identifier for the passenger, unique within this Offer Request and across all Offer Requests.
+                * This ID will be generated by Duffel unless you had optionally provided one.
+                * Optionally providing one has been deprecated.
+                */
+            id: string;
+    }
+    /**
+        * The **Loyalty Programme Account** details.
+        */
+    export interface LoyaltyProgrammeAccount {
+            /**
+                * The passenger's account number for this **Loyalty Programme Account**.
+                */
+            account_number: string;
+            /**
+                * The IATA code for the airline that this **Loyalty Programme Account** belongs to.
+                */
+            airline_iata_code: Airline['iata_code'];
+    }
+    /**
+        * 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).
+        * @link https://duffel.com/docs/api/offer-requests/schema
+        */
+    export interface OfferRequest {
+            /**
+                * The slices that make up this offer request.
+                * One-way journeys can be expressed using one slice, whereas return trips will need two.
+                * @link https://duffel.com/docs/api/overview/key-principles
+                */
+            slices: OfferRequestSlice[];
+            /**
+                * The cabin that the passengers want to travel in
+                */
+            cabin_class?: CabinClass;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the offer request was created
+                */
+            created_at: string;
+            /**
+                * Duffel's unique identifier for the offer request
+                */
+            id: string;
+            /**
+                * Whether the offer request was created in live mode. This field will be set to true if the offer request was created in live mode, or false if it was created in test mode.
+                */
+            live_mode: boolean;
+            /**
+                * The offers returned by the airlines
+                */
+            offers: Omit<Offer, 'available_services'>[];
+            /**
+                * The passengers who want to travel. A passenger will have only a type or an age.
+                */
+            passengers: OfferRequestPassenger[];
+    }
+    export interface CreateOfferRequest {
+            /**
+                * The cabin that the passengers want to travel in.
+                */
+            cabin_class?: CabinClass;
+            /**
+                * The maximum number of connections within any slice of the offer. For
+                * example 0 means a direct flight which will have a single segment within
+                * each slice and 1 means a maximum of two segments within each slice of the
+                * offer.
+                */
+            max_connections?: 0 | 1 | 2;
+            /**
+                * The passengers who want to travel. If you specify an `age` for a passenger,
+                * the `type` may differ for the same passenger in different offers due to
+                * airline's different rules. E.g. one airline may treat a 14 year old as an
+                * adult, and another as a young adult. You may only specify an `age` or a
+                * `type` – not both.
+                */
+            passengers: CreateOfferRequestPassenger[];
+            /**
+                * The private fare codes for this Offer Request. You can pass in multiple
+                * airlines with their specific private fare codes. The key is the airline's
+                * IATA code that provided the private fare code. The `corporate_code` is
+                * provided to you by the airline and the `tracking_reference` is to identify
+                * your business by the airlines.
+                */
+            private_fares?: {
+                    [iataCode: string]: CreateOfferRequestPrivateFare[];
+            };
+            /**
+                * The [slices](https://duffel.com/docs/api/overview/key-principles) that make
+                * up this offer request. One-way journeys can be expressed using one slice,
+                * whereas return trips will need two.
+                */
+            slices: Omit<OfferRequestSlice, 'origin_type' | 'destination_type'>[];
+    }
+    export interface CreateOfferRequestQueryParameters {
+            /**
+                * When set to `true`, the offer request resource returned will include all the offers returned by the airlines.
+                * If set to `false`, the offer request resource won't include any offers.
+                * To retrieve the associated `offers` later, use the [List Offers](https://duffel.com/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](https://duffel.com/docs/api/offers/get-offers) endpoint provides.
+                */
+            return_offers?: boolean;
+    }
+    export {};
+}
+
+declare module '@duffel/api/booking/Offers/OfferTypes' {
+    import { CabinClass, FlightsConditions, LoyaltyProgrammeAccount, PassengerIdentityDocumentType, Place, PlaceType, Aircraft, Airline, Airport, PaginationMeta, DuffelPassengerType } from '@duffel/api/types';
+    /**
+        * Each offer represents flights you can buy from an airline at a particular price that meet your search criteria.
+        * @link https://duffel.com/docs/api/offers/schema
+        */
+    export interface Offer {
+            /**
+                * The types of identity documents that may be provided for the passengers when creating an order based on this offer.
+                * If this is `[]`, then you must not provide identity documents.
+                */
+            allowed_passenger_identity_document_types: PassengerIdentityDocumentType[];
+            /**
+                * The services that can be booked along with the offer but are not included by default, for example an additional checked bag.
+                * This field is only returned in the Get single offer endpoint.
+                * When there are no services available, or we don't support services for the airline, this list will be empty.
+                */
+            available_services: OfferAvailableService[];
+            /**
+                * The base price of the offer for all passengers, excluding taxes.
+                * It does not include the base amount of any service(s) that might be booked with the offer.
+                */
+            base_amount: string;
+            /**
+                * The currency of the `base_amount`, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code
+                */
+            base_currency: string;
+            /**
+                * The conditions associated with this offer, describing the kinds of modifications you can make post-booking and any penalties that will apply to those modifications.
+                * This information assumes the condition is applied to all of the slices and passengers associated with this offer - for information at the slice level (e.g. "what happens if I just want to change the first slice?") refer to the `slices`.
+                * If a particular kind of modification is allowed, you may not always be able to take action through the Duffel API.
+                * In some cases, you may need to contact the Duffel support team or the airline directly.
+                */
+            conditions: FlightsConditions;
+            /**
+                * The ISO 8601 datetime at which the offer was created
+                */
+            created_at: string;
+            /**
+                * The ISO 8601 datetime at which the offer will expire and no longer be usable to create an order
+                */
+            expires_at: string;
+            /**
+                * Duffel's unique identifier for the offer
+                */
+            id: string;
+            /**
+                * Whether the offer request was created in live mode.
+                * This field will be set to `true` if the offer request was created in live mode, or `false` if it was created in test mode.
+                */
+            live_mode: boolean;
+            /**
+                * The airline which provided the offer
+                */
+            owner: Airline;
+            /**
+                * Whether identity documents must be provided for each of the passengers when creating an order based on this offer.
+                * If this is `true`, you must provide an identity document for every passenger.
+                */
+            passenger_identity_documents_required: boolean;
+            /**
+                * The passengers included in the offer
+                */
+            passengers: OfferPassenger[];
+            /**
+                * The payment requirements for this offer
+                */
+            payment_requirements: PaymentRequirements;
+            /**
+                * The private fares applied on this offer.
+                */
+            private_fares: OfferPrivateFare[];
+            /**
+                * The slices that make up this offer. Each slice will include one or more segments,
+                * the specific flights that the airline is offering to take the passengers from the slice's `origin` to its `destination`.
+                */
+            slices: OfferSlice[];
+            /**
+                * The amount of tax payable on the offer for all passengers
+                */
+            tax_amount: string | null;
+            /**
+                * The currency of the `tax_amount`, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code
+                */
+            tax_currency: string | null;
+            /**
+                * The total price of the offer for all passengers, including taxes.
+                * It does not include the total price of any service(s) that might be booked with the offer.
+                */
+            total_amount: string;
+            /**
+                * An estimate of the total carbon dioxide (CO₂) emissions when
+                * all of the passengers fly this offer's itinerary, measured in kilograms
+                */
+            total_emissions_kg: string;
+            /**
+                * The currency of the `total_amount`, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code
+                */
+            total_currency: string;
+            /**
+                * The ISO 8601 datetime at which the offer was last updated
+                */
+            updated_at: string;
+            /**
+                * Whether this is a partial or full offer.
+                * A partial offer can't be booked directly, but it can be combined with other partial offers to form a full offer.
+                * Partial offers are only ever returned through the multi-step search flow.
+                */
+            partial: boolean;
+    }
+    export interface OfferAvailableServiceBaggageMetadata {
+            /**
+                * The maximum weight that the baggage can have in kilograms.
+                */
+            maximum_weight_kg: number | null;
+            /**
+                * The maximum height that the baggage can have in centimetres.
+                */
+            maximum_height_cm: number | null;
+            /**
+                * The maximum length that the baggage can have in centimetres.
+                */
+            maximum_length_cm: number | null;
+            /**
+                * The maximum depth that the baggage can have in centimetres.
+                */
+            maximum_depth_cm: number | null;
+            /**
+                * The type of the baggage
+                */
+            type: BaggageType;
+    }
+    export interface OfferAvailableServiceCFARMetadata {
+            /**
+                * The amount the customer will receive back if the service is used, in
+                * `offer.total_currency`.
+                */
+            refund_amount: string;
+            /**
+                * Information to display to customers.
+                */
+            merchant_copy: string;
+            /**
+                * URL with the T&Cs for customers.
+                */
+            terms_and_conditions_url: string;
+            type: 'cancel_for_any_reason';
+    }
+    export interface OfferAvailableServiceCommon {
+            /**
+                * Duffel's unique identifier for the service.
+                */
+            id: string;
+            /**
+                * The maximum quantity of this service that can be booked with an order.
+                */
+            maximum_quantity: number;
+            /**
+                * The list of passenger `id`s the service applies to. If you add this
+                * service to an order it will apply to all the passengers in this list.
+                * For services where the type is `baggage`, this list will include only a
+                * single passenger.
+                */
+            passenger_ids: string[];
+            /**
+                * The list of segment `id`s the service applies to. If you add this
+                * service to an order it will apply to all the segments in this list. For
+                * services where the type is `baggage`, depending on the airline, this
+                * list includes all the segments of all slices or all the segments of a
+                * single slice.
+                */
+            segment_ids: string[];
+            /**
+                * The total price of the service for all passengers and segments it
+                * applies to, including taxes. This price is for a single unit of the
+                * service.
+                */
+            total_amount: string;
+            /**
+                * The currency of the `total_amount`, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217)
+                * currency code. It will match your organisation's billing currency unless
+                * you’re using Duffel as an accredited IATA agent, in which case it will be
+                * in the currency provided by the airline (which will usually be based on the
+                * country where your IATA agency is registered).
+                */
+            total_currency: string;
+    }
+    export interface OfferAvailableServiceBaggage extends OfferAvailableServiceCommon {
+            /**
+                * The metadata varies by the type of service. It includes further data
+                * about the service. For example, for baggages, it may have data about
+                * size and weight restrictions.
+                */
+            metadata: OfferAvailableServiceBaggageMetadata;
+            /**
+                * The type of the service.
+                */
+            type: 'baggage';
+    }
+    export interface OfferAvailableServiceCFAR extends OfferAvailableServiceCommon {
+            /**
+                * The metadata varies by the type of service. It includes further data
+                * about the service. For example, for baggages, it may have data about
+                * size and weight restrictions.
+                */
+            metadata: OfferAvailableServiceCFARMetadata;
+            /**
+                * The type of the service.
+                */
+            type: 'cancel_for_any_reason';
+    }
+    export type OfferAvailableService = OfferAvailableServiceBaggage | OfferAvailableServiceCFAR;
+    export interface PaymentRequirements {
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime by which
+                * you must pay for this order. At this time, if still unpaid, the reserved
+                * space on the flight(s) will be released and you will have to create a new
+                * order. This will be null only for orders where `awaiting_payment` is
+                * `false`.
+                */
+            payment_required_by: string | null;
+            /**
+                * The ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the
+                * price associated with the order will no longer be guaranteed by the airline
+                * and may change before payment. This will be null when
+                * `requires_instant_payment` is `true`.
+                */
+            price_guarantee_expires_at: string | null;
+            /**
+                * When payment is required at the time of booking this will be true and
+                * `payment_required_by` and `price_guarantee_expires_at` will be `null`. When
+                * payment can be made at a time after booking, this will be `false` and the
+                * time limits on the payment will be provided in `payment_required_by` and
+                * `price_guarantee_expires_at`.
+                */
+            requires_instant_payment: boolean;
+    }
+    export interface OfferPrivateFare {
+            /**
+                * The corporate code that was applied, if any.
+                */
+            corporate_code?: string;
+            /**
+                * The tracking reference that was applied, if any.
+                */
+            tracking_reference?: string;
+            /**
+                * The type of private fare applied.
+                */
+            type: 'corporate' | 'leisure' | 'negotiated';
+    }
+    export interface OfferPassenger {
+            /**
+                * The age of the passenger on the departure_date of the final slice.
+                */
+            age?: number;
+            /**
+                * The type of the passenger.
+                */
+            type?: DuffelPassengerType;
+            /**
+                * The passenger's family name. Only `space`, `-`, `'`, and letters from the `ASCII`, `Latin-1 Supplement` and `Latin
+                * Extended-A` (with the exceptions of `Æ`, `æ`, `IJ`, `ij`, `Œ`, `œ`, `Þ`, , and `ð`) Unicode charts are accepted. All
+                * other characters will result in a validation error. The minimum length is 1 character, and the maximum is 20
+                * characters.
+                *
+                * This is only required if you're also including **Loyalty Programme Accounts**.
+                */
+            family_name?: string;
+            /**
+                * The passenger's given name. Only `space`, `-`, `'`, and letters from the `ASCII`, `Latin-1 Supplement` and `Latin
+                * Extended-A` (with the exceptions of `Æ`, `æ`, `IJ`, `ij`, `Œ`, `œ`, `Þ`, , and `ð`) Unicode charts are accepted. All
+                * other characters will result in a validation error. The minimum length is 1 character, and the maximum is 20
+                * characters.
+                *
+                * This is only required if you're also including **Loyalty Programme Accounts**.
+                */
+            given_name?: string;
+            /**
+                * The **Loyalty Programme Accounts** for this passenger.
+                */
+            loyalty_programme_accounts?: LoyaltyProgrammeAccount[];
+            /**
+                * The identifier for the passenger, unique within this Offer Request and across all Offer Requests.
+                * This ID will be generated by Duffel unless you had optionally provided one.
+                * Optionally providing one has been deprecated.
+                */
+            id: string;
+    }
+    export interface OfferSlice {
+            /**
+                * The type of the destination
+                */
+            destination_type: PlaceType;
+            /**
+                * The city or airport where this slice ends
+                */
+            destination: Place;
+            /**
+                * The type of the origin
+                */
+            origin_type: PlaceType;
+            /**
+                * The city or airport where this slice begins
+                */
+            origin: Place;
+            /**
+                * The duration of the slice, represented as a ISO 8601 duration
+                */
+            duration: string | null;
+            /**
+                * The name of the fare brand associated with this slice.
+                * A fare brand specifies the travel conditions you get on your slice made available
+                * by the airline. e.g. a British Airways Economy Basic fare will only include a hand baggage allowance.
+                * It is worth noting that the fare brand names are defined by the airlines themselves and therefore they
+                * are subject to change without any prior notice. We're in the process of adding support for fare_brand_name across
+                * all our airlines, so for now, this field may be null in some offers.
+                * This will become a non-nullable attribute in the near future.
+                */
+            fare_brand_name: string | null;
+            /**
+                * Duffel's unique identifier for the slice. It identifies the slice of an offer (i.e. the same slice across offers will have different `id`s
+                */
+            id: string;
+            /**
+                * The segments - that is, specific flights - that the airline is offering to get the passengers from the `origin` to the `destination`
+                */
+            segments: OfferSliceSegment[];
+            /**
+                * The conditions associated with this slice, describing the kinds of modifications you can make post-booking and any penalties that will apply to those modifications.
+                * This condition is applied only to this slice and to all the passengers associated with this offer - for information at the offer level (e.g. "what happens if I want to change all the slices?") refer to the conditions at the top level.
+                * If a particular kind of modification is allowed, you may not always be able to take action through the Duffel API.
+                * In some cases, you may need to contact the Duffel support team or the airline directly.
+                */
+            conditions: FlightsConditions;
+    }
+    export interface OfferSliceSegment {
+            /**
+                * The aircraft that the operating carrier will use to operate this segment
+                */
+            aircraft: Aircraft;
+            /**
+                * The ISO 8601 datetime at which the segment is scheduled to arrive
+                */
+            arriving_at: string;
+            /**
+                * The terminal at the destination airport where the segment is scheduled to arrive
+                */
+            destination_terminal: string | null;
+            /**
+                * The ISO 8601 datetime at which the segment is scheduled to depart
+                */
+            departing_at: string;
+            /**
+                * The terminal at the origin airport from which the segment is scheduled to depart
+                */
+            origin_terminal: string | null;
+            /**
+                * The airport at which the segment is scheduled to arrive
+                */
+            destination: Airport;
+            /**
+                * The distance of the segment in kilometres
+                */
+            distance: string | null;
+            /**
+                * The duration of the segment, represented as a ISO 8601 duration
+                */
+            duration: string | null;
+            /**
+                * Duffel's unique identifier for the segment. It identifies the segment of an offer (i.e. the same segment across offers will have different `id`s
+                */
+            id: string;
+            /**
+                * The airline selling the tickets for this segment.
+                * This may differ from the `operating_carrier` in the case of a "codeshare", where one airline sells flights operated by another airline.
+                */
+            marketing_carrier: Airline;
+            /**
+                * The flight number assigned by the marketing carrier
+                */
+            marketing_carrier_flight_number: string;
+            /**
+                * The airport from which the flight is scheduled to depart
+                */
+            origin: Airport;
+            /**
+                * The airline actually operating this segment.
+                * This may differ from the marketing_carrier in the case of a "codeshare", where one airline sells flights operated by another airline.
+                */
+            operating_carrier: Airline;
+            /**
+                * The flight number assigned by the operating carrier
+                */
+            operating_carrier_flight_number: string;
+            /**
+                * Additional segment-specific information about the passengers included in the offer (e.g. their baggage allowance and the cabin class they will be travelling in)
+                */
+            passengers: OfferSliceSegmentPassenger[];
+            /**
+                * Additional segment-specific information about the stops, if any, included in the segment
+                */
+            stops?: OfferSliceSegmentStop[];
+    }
+    export interface OfferSliceSegmentStop {
+            /**
+                * Duffel's unique identifier for the Stop
+                */
+            id: string;
+            /**
+                * The airport at which the Stop happens
+                */
+            airport: Airport;
+            /**
+                * The ISO 8601 datetime at which the Stop is scheduled to arrive, in the airport's timezone (see destination.timezone)
+                */
+            arrivingAt: string;
+            /**
+                * The ISO 8601 datetime at which the Stop is scheduled to depart, in the airport's timezone (see origin.timezone)
+                */
+            departingAt: string;
+            /**
+                * The duration of the Stop, represented as a ISO 8601 duration
+                */
+            duration: string;
+    }
+    export interface OfferSliceSegmentPassenger {
+            /**
+                * The baggage allowances for the passenger on this segment included in the offer.
+                * Some airlines may allow additional baggage to be booked as a service - see the offer's available_services.
+                */
+            baggages: OfferSliceSegmentPassengerBaggage[];
+            /**
+                * The cabin class that the passenger will travel in on this segment
+                */
+            cabin_class: CabinClass;
+            /**
+                * The name that the marketing carrier uses to market this cabin class
+                */
+            cabin_class_marketing_name: string;
+            /**
+                * The identifier for the passenger.
+                * You may have specified this ID yourself when creating the offer request, or otherwise, Duffel will have generated its own random ID.
+                */
+            passenger_id: string;
+            /**
+                * The airline's alphanumeric code for the fare that the passenger is using to travel. Where this is `null`, it means that either the
+                * fare basis code is not available or the airline does not use fare basis codes.
+                */
+            fare_basis_code: string;
+    }
+    export type BaggageType = 'carry_on' | 'checked';
+    export interface OfferSliceSegmentPassengerBaggage {
+            /**
+                * The type of the baggage allowance
+                */
+            type: BaggageType;
+            /**
+                * The number of this type of bag allowed on the segment. Note that this can currently be 0 in some cases.
+                */
+            quantity: number;
+    }
+    export interface ListOffersParams extends PaginationMeta {
+            /**
+                * Duffel's unique identifier for the offer request, returned when it was created
+                */
+            offer_request_id: string;
+            /**
+                * 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.
+                */
+            max_connections?: number;
+            /**
+                * 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`).
+                */
+            sort?: 'total_amount' | 'total_duration';
+    }
+    export interface LoyaltyProgrammeAccounts {
+            /**
+                * The passenger's account number for this Loyalty Programme Account
+                */
+            account_number: string;
+            /**
+                * The IATA code for the airline that this Loyalty Programme Account belongs to
+                */
+            airline_iata_code: string;
+    }
+    export interface UpdateOffer {
+            type: string;
+            loyalty_programme_accounts: LoyaltyProgrammeAccounts;
+            id: string;
+            given_name: string;
+            family_name: string;
+            age: number;
+    }
+}
+
+declare module '@duffel/api/booking/OrderCancellations/OrderCancellationsTypes' {
+    import { PaginationMeta } from '@duffel/api/types';
+    export interface CreateOrderCancellation {
+            /**
+                * Duffel's unique identifier for the order
+                */
+            order_id: string;
+    }
+    export interface ListOrderCancellationsParams extends PaginationMeta {
+            /**
+                * Duffel's unique identifier for the order, returned when it was created
+                */
+            order_id?: string;
+    }
+    export interface OrderCancellation {
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime that indicates when the order cancellation was confirmed
+                */
+            confirmed_at: string;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the order cancellation was created
+                */
+            created_at: string;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime by which this cancellation must be confirmed
+                */
+            expires_at: string;
+            /**
+                * Duffel's unique identifier for the order cancellation
+                */
+            id: string;
+            /**
+                * Whether the order cancellation was created in live mode. This field will be set to `true` if the order cancellation was created in live mode, or `false` if it was created in test mode.
+                */
+            live_mode: boolean;
+            /**
+                * Duffel's unique identifier for the order
+                */
+            order_id: string;
+            /**
+                * The amount that will be returned to the original payment method if the order is cancelled, determined according to the fare conditions. This may be `0.00` if the fare is non-refundable. It will include the refund amount of the flights and the services booked.
+                */
+            refund_amount: string;
+            /**
+                * The currency of the `refund_amount`, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code.
+                * It will match your organisation's billing currency unless you're using Duffel as an accredited IATA agent, in which case it will be in the currency provided by the airline (which will usually be based on the country where your IATA agency is registered).
+                * For pay later orders that are awaiting payment, the refund amount will always be 0.00.
+                */
+            refund_currency: string;
+            /**
+                * Where the refund, once confirmed, will be sent. `card` is currently a restricted feature. `awaiting_payment` is for pay later orders where no payment has been made yet.
+                */
+            refund_to: 'arc_bsp_cash' | 'balance' | 'card' | 'voucher' | 'awaiting_payment';
+    }
+}
+
+declare module '@duffel/api/booking/OrderChangeOffers/OrderChangeOfferTypes' {
+    import { OfferSliceSegment } from '@duffel/api/booking/Offers/OfferTypes';
+    import { PlaceType, Place } from '@duffel/api/types';
+    /**
+        * @link https://duffel.com/docs/api/order-change-offers/schema
+        */
+    export interface OrderChangeOffer {
+            /**
+                * The price of this offer as a change to your existing order, excluding taxes
+                */
+            change_total_amount: string | null;
+            /**
+                * The currency of the change_total_amount, as an ISO 4217 currency code.
+                * It will match your organisation's billing currency unless you're using Duffel
+                * as an accredited IATA agent, in which case it will be in the currency provided
+                * by the airline (which will usually be based on the country where your
+                * IATA agency is registered).
+                */
+            change_total_currency: string | null;
+            /**
+                * The ISO 8601 datetime at which the offer was created
+                */
+            created_at: string;
+            /**
+                * The ISO 8601 datetime at which the offer will expire
+                * and no longer be usable to create an order
+                */
+            expires_at: string;
+            /**
+                * Duffel's unique identifier for the order change offer
+                */
+            id: string;
+            /**
+                * The price of this offer if it was newly purchased, excluding taxes
+                */
+            new_total_amount: string | null;
+            /**
+                * The currency of the new_total_amount, as an ISO 4217 currency code.
+                * It will match your organisation's billing currency unless you're using
+                * Duffel as an accredited IATA agent, in which case it will be in the
+                * currency provided by the airline (which will usually be based on the
+                * country where your IATA agency is registered).
+                */
+            new_total_currency: string;
+            /**
+                * The ID for an order change if one has already been created from this order change offer
+                */
+            order_change_id: string;
+            /**
+                * The penalty price imposed by the airline for making this change
+                */
+            penalty_amount: string;
+            /**
+                * The currency of the penalty_amount, as an ISO 4217 currency code.
+                * It will match your organisation's billing currency unless you're using
+                * Duffel as an accredited IATA agent, in which case it will be in the
+                * currency provided by the airline (which will usually be based on
+                * the country where your IATA agency is registered).
+                */
+            penalty_currency: string;
+            /**
+                * Where the refund, once confirmed, will be sent. card is currently a restricted feature.
+                * `awaiting_payment` is for pay later orders where no payment has been made yet.
+                */
+            refund_to: 'arc_bsp_cash' | 'balance' | 'card' | 'voucher' | 'awaiting_payment' | 'original_form_of_payment';
+            /**
+                * The slices to be added and/or removed
+                */
+            slices: OrderChangeOfferSlices;
+            /**
+                *  The ISO 8601 datetime at which the offer was last updated
+                */
+            updated_at: string;
+    }
+    export interface OrderChangeOfferSlices {
+            /**
+                * The slices that will be added to the order
+                */
+            add: OrderChangeOfferSlice[];
+            /**
+                * The slices that will be removed from the order
+                */
+            remove: OrderChangeOfferSlice[];
+    }
+    export interface OrderChangeOfferSlice {
+            /**
+                * The city or airport where this slice ends
+                */
+            destination: Place;
+            /**
+                * The type of the destination
+                */
+            destination_type: PlaceType;
+            /**
+                * The duration of the slice, represented as a [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) duration
+                */
+            duration?: string | null;
+            /**
+                * Duffel's unique identifier for the slice. It identifies the slice of an order (i.e. the same slice across orders will have different `id`s.
+                */
+            id: string;
+            /**
+                * The city or airport where this slice begins
+                */
+            origin: Place;
+            /**
+                * The type of the origin
+                */
+            origin_type: PlaceType;
+            /**
+                * The segments - that is, specific flights - that the airline is offering to get the passengers from the `origin` to the `destination`
+                */
+            segments: Array<Omit<OfferSliceSegment, 'passengers'>>;
+    }
+}
+
+declare module '@duffel/api/booking/OrderChangeRequests/OrderChangeRequestsTypes' {
+    import { CabinClass, Place } from '@duffel/api/types';
+    import { OrderChangeOfferSlices } from '@duffel/api/booking/OrderChangeOffers/OrderChangeOfferTypes';
+    export interface OrderChangeSliceResponse {
+            remove: {
+                    slice_id: string;
+            };
+            add: {
+                    /**
+                        * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date on which the passengers want to depart
+                        */
+                    departure_date: string;
+                    /**
+                        * The city or airport where this slice ends
+                        */
+                    destination: Place;
+                    /**
+                        * The city or airport where this slice begins
+                        */
+                    origin: Place;
+                    /**
+                        * The cabin that the passengers want to travel in
+                        */
+                    cabin_class: CabinClass;
+            };
+    }
+    export interface OrderChangeOffers {
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the offer was last updated
+                */
+            updated_at: string;
+            /**
+                * The price of this offer as a change to your existing order, excluding taxes
+                */
+            change_total_amount: string | null;
+            /**
+                * The currency of the `change_total_amount`, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code.
+                * It will match your organisation's billing currency unless you're using Duffel as an accredited IATA agent, in which case it will be in the currency provided by the airline (which will usually be based on the country where your IATA agency is registered).
+                */
+            change_total_currency: string | null;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the offer was created
+                */
+            created_at: string;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the offer will expire and no longer be usable to create an order
+                */
+            expires_at: string;
+            /**
+                * Duffel's unique identifier for the order change offer
+                */
+            id: string;
+            /**
+                * The price of this offer if it was newly purchased, excluding taxes
+                */
+            new_total_amount: string | null;
+            /**
+                * The currency of the `new_total_amount`, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code. It will match your organisation's billing currency unless you're using Duffel as an accredited IATA agent, in which case it will be in the currency provided by the airline (which will usually be based on the country where your IATA agency is registered).
+                */
+            new_total_currency: string;
+            /**
+                * The ID for an `order change` if one has already been created from this `order change offer`
+                */
+            order_change_id: string;
+            /**
+                * The penalty price imposed by the airline for making this change
+                */
+            penalty_amount: string | null;
+            /**
+                * The currency of the `penalty_amount`, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code.
+                * It will match your organisation's billing currency unless you're using Duffel as an accredited IATA agent, in which case it will be in the currency provided by the airline (which will usually be based on the country where your IATA agency is registered).
+                */
+            penalty_currency: string | null;
+            /**
+                * Where the refund, once confirmed, will be sent. `card` is currently a restricted feature. `awaiting_payment` is for pay later orders where no payment has been made yet.
+                */
+            refund_to: 'arc_bsp_cash' | 'balance' | 'card' | 'voucher' | 'awaiting_payment';
+            /**
+                * The slices within an order change that are being added to and/or removed from the order
+                */
+            slices: OrderChangeOfferSlices;
+    }
+    export interface OrderChangeRequestResponse {
+            /**
+                * The ID of your order change request
+                */
+            id: string;
+            /**
+                * Whether the order was created in live mode. This field will be set to `true` if the order was created in live mode, or `false` if it was created in test mode.
+                */
+            live_mode: boolean;
+            /**
+                * The list of the offers available to perform change on the order.
+                */
+            order_change_offers: OrderChangeOffers[];
+            /**
+                * The order ID that you want to change
+                */
+            order_id: string;
+            /**
+                * The slices to be added and/or removed
+                */
+            slices: OrderChangeSliceResponse;
+    }
+    export interface CreateOrderChangeRequest {
+            /**
+                * The changes you wish to make to your order
+                */
+            changes: {
+                    /**
+                        * The [slices](https://duffel.com/docs/api/overview/key-principles) that make up this offer request. One-way journeys can be expressed using one slice, whereas return trips will need two.
+                        */
+                    slices: {
+                            /**
+                                * The search criteria for slices which you wish to add to your order
+                                */
+                            add: {
+                                    /**
+                                        * The cabin that the passengers want to travel in
+                                        */
+                                    cabin_class: CabinClass;
+                                    /**
+                                        * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date on which the passengers want to depart
+                                        */
+                                    departure_date: string;
+                                    /**
+                                        * The 3-letter IATA code for the city or airport where this slice ends
+                                        */
+                                    destination: string;
+                                    /**
+                                        * The 3-letter IATA code for the city or airport where this slice starts
+                                        */
+                                    origin: string;
+                            }[];
+                            /**
+                                * The slices that you wish to remove from your order
+                                */
+                            remove: {
+                                    slice_id: string;
+                            }[];
+                    };
+            };
+            /**
+                * The order ID you wish to change
+                */
+            order_id: string;
+    }
+}
+
+declare module '@duffel/api/booking/OrderChanges/OrderChangesTypes' {
+    import { OrderChangeOfferSlices, PaymentType } from '@duffel/api/types';
+    export interface OrderChange {
+            /**
+                * The price of this offer as a change to your existing order, excluding taxes
+                */
+            change_total_amount: string | null;
+            /**
+                * The currency of the change_total_amount, as an ISO 4217 currency code.
+                * It will match your organisation's billing currency unless you're using Duffel
+                * as an accredited IATA agent, in which case it will be in the currency provided
+                * by the airline (which will usually be based on the country where your
+                * IATA agency is registered).
+                */
+            change_total_currency: string | null;
+            /**
+                * Whether the order was created in live mode. This field will be set to `true`
+                * if the order was created in live mode, or `false` if it was created in test mode.
+                */
+            live_mode: boolean;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the offer was created
+                */
+            created_at: string;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime that indicates when the order change was confirmed
+                */
+            confirmed_at: string;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the offer will expire
+                * and no longer be usable to create an order
+                */
+            expires_at: string;
+            /**
+                * Duffel's unique identifier for the order change offer
+                */
+            id: string;
+            /**
+                * The price of this offer if it was newly purchased, excluding taxes
+                */
+            new_total_amount: string | null;
+            /**
+                * The currency of the new_total_amount, as an ISO 4217 currency code.
+                * It will match your organisation's billing currency unless you're using
+                * Duffel as an accredited IATA agent, in which case it will be in the
+                * currency provided by the airline (which will usually be based on the
+                * country where your IATA agency is registered).
+                */
+            new_total_currency: string;
+            /**
+                * Duffel's unique identifier for the order which is being changed
+                */
+            order_id: string;
+            /**
+                * The penalty price imposed by the airline for making this change
+                */
+            penalty_amount: string | null;
+            /**
+                * The currency of the penalty_amount, as an ISO 4217 currency code.
+                * It will match your organisation's billing currency unless you're using
+                * Duffel as an accredited IATA agent, in which case it will be in the
+                * currency provided by the airline (which will usually be based on
+                * the country where your IATA agency is registered).
+                */
+            penalty_currency: string | null;
+            /**
+                * Where the refund, once confirmed, will be sent. card is currently a restricted feature.
+                * `awaiting_payment` is for pay later orders where no payment has been made yet.
+                */
+            refund_to: 'arc_bsp_cash' | 'balance' | 'card' | 'voucher' | 'awaiting_payment' | 'original_form_of_payment';
+            /**
+                * The slices to be added and/or removed
+                */
+            slices: OrderChangeOfferSlices;
+            /**
+                * The available payment types to complete the order change.
+                */
+            available_payment_types?: PaymentType[] | null;
+    }
+    export interface CreateOrderChangeParameters {
+            /**
+                * Duffel's unique identifier for the order change offer
+                */
+            selected_order_change_offer: string;
+    }
+    export interface ConfirmOrderChangePayment {
+            /**
+                * The amount of the payment. This should be the same as the change_total_amount of the order change.
+                */
+            amount: string;
+            /**
+                * The currency of the change_total_amount, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code.
+                */
+            currency: string;
+            /**
+                * The type of payment you want to use for the Order Change.
+                * If you are an IATA agent with your own agreements with airlines, in some cases, you can pay using ARC/BSP cash by specifying arc_bsp_cash.
+                * Otherwise, you must pay using your Duffel account's balance by specifying balance.
+                * In test mode, your balance is unlimited.
+                * If you're not sure which of these options applies to you, get in touch with the Duffel support team at [help@duffel.com](mailto:help@duffel.com).
+                */
+            type: PaymentType;
+    }
+}
+
+declare module '@duffel/api/booking/Orders/OrdersTypes' {
+    import { Aircraft, Airline, AirlineInitiatedChange, CabinClass, DuffelPassengerGender, DuffelPassengerTitle, DuffelPassengerType, FlightsConditions, LoyaltyProgrammeAccount, OfferAvailableServiceBaggage, OfferAvailableServiceBaggageMetadata, PassengerIdentityDocumentType, PaymentType, Place, PlaceType } from '@duffel/api/types';
+    /**
+        * An object containing metadata about the service, like the designator of the seat.
+        */
+    export interface Seat {
+            /**
+                * The designator used to uniquely identify the seat, usually made up of a row number and a column letter
+                * @example "14B"
+                */
+            designator: string;
+            /**
+                * Each disclosure is text, in English, provided by the airline that describes the terms and conditions of this seat. We recommend showing this in your user interface to make sure that customers understand any restrictions and limitations.
+                * @example "["Do not seat children in exit row seats","Do not seat passengers with special needs in exit row seats"]"
+                */
+            disclosures: string[];
+            /**
+                * A name which describes the type of seat, which you can display in your user interface to help customers to understand its features
+                * @example "Exit row seat"
+                */
+            name: string;
+    }
+    /**
+        * An object containing metadata about the service, like the maximum weight and dimensions of the baggage.
+        */
+    export type OrderServiceBaggageMetadata = OfferAvailableServiceBaggageMetadata;
+    export interface OrderSegmentPassengerBaggage {
+            /**
+                * The number of this type of bag allowed on the segment. Note that this can currently be 0 in some cases.
+                */
+            quantity: number;
+            /**
+                * The type of the baggage allowance
+                */
+            type: 'checked' | 'carry_on';
+    }
+    /**
+        * Once you've searched for flights by creating an offer request, and you've chosen which offer you want to book, you'll then want to create an order.
+        * @link https://duffel.com/docs/api/orders/schema
+        */
+    export interface OrderService {
+            /**
+                * Duffel's unique identifier for the booked service
+                * @example "ser_00009UhD4ongolulWd9123"
+                */
+            id: string;
+            /**
+                * The metadata varies by the type of service. It includes further data about the service.
+                * For example, for baggages, it may have data about size and weight restrictions.
+                */
+            metadata?: OrderServiceBaggageMetadata | Seat;
+            /**
+                * List of passenger ids the service applies to. The service applies to all the passengers in this list.
+                * @example ["pas_00009hj8USM7Ncg31cBCLL"]
+                */
+            passenger_ids: string[];
+            /**
+                * The quantity of the service that was booked
+                * @example 1
+                */
+            quantity: number;
+            /**
+                * List of segment `ids` the service applies to. The service applies to all the segments in this list.
+                * @example "["seg_00009hj8USM7Ncg31cB456"]"
+                */
+            segment_ids: string[];
+            /**
+                * The total price of the service for all passengers and segments it applies to, accounting for quantity and including taxes
+                * @example "15.00"
+                */
+            total_amount: string;
+            /**
+                * The currency of the `total_amount`, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code.
+                * It will match your organisation's billing currency unless you're using Duffel as an accredited IATA agent, in which case it will be in the currency provided by the airline (which will usually be based on the country where your IATA agency is registered).
+                * @example "GBP"
+                */
+            total_currency: string;
+            /**
+                * The type of the service.
+                * For now we only return services of type `baggage` and `seat` but we will return other types in the future. We won't consider adding new service types a breaking change.
+                */
+            type: 'baggage' | 'seat';
+    }
+    export interface OrderSegmentPassenger {
+            /**
+                * The baggage allowances for the passenger on this segment that were included in the original offer.
+                * Any extra baggage items which were booked as services will be listed in the services field instead of here.
+                */
+            baggages: OrderSegmentPassengerBaggage[];
+            /**
+                * The cabin class that the passenger will travel in on this segment
+                */
+            cabin_class: CabinClass;
+            /**
+                * The name that the marketing carrier uses to market this cabin class
+                */
+            cabin_class_marketing_name: string;
+            /**
+                * The identifier for the passenger. You may have specified this ID yourself when creating the offer request, or otherwise, Duffel will have generated its own random ID.
+                */
+            passenger_id?: string;
+            /**
+                * An object containing metadata about the service, like the designator of the seat.
+                */
+            seat?: Seat;
+    }
+    export interface OrderPassenger {
+            id: string;
+            /**
+                * The passenger's date of birth
+                * @example "1987-07-24"
+                */
+            born_on: string;
+            /**
+                * The passenger's family name
+                * @example "Earheart"
+                */
+            family_name: string;
+            /**
+                * The passenger's given name
+                * @xample "Amelia"
+                */
+            given_name: string;
+            /**
+                * The passenger's gender
+                * @return "m" or "f"
+                */
+            gender: DuffelPassengerGender;
+            /**
+                * The passenger's title
+                * @returns "mr", "ms", "mrs", or "miss"
+                */
+            title: DuffelPassengerTitle;
+            /**
+                * The type of the passenger
+                * @return "adult", "child", or "infant_without_seat"
+                */
+            type: DuffelPassengerType;
+            /**
+                * The id of the infant associated with this passenger
+                * @return "adult", "child", or "infant_without_seat"
+                */
+            infant_passenger_id?: string | null;
+            /**
+                * The **Loyalty Programme Accounts** for this passenger.
+                */
+            loyalty_programme_accounts?: LoyaltyProgrammeAccount[];
+    }
+    export interface OrderPassengerIdentityDocument {
+            /**
+                * The type of the identity document. This must be one of the allowed_passenger_identity_document_types on the offer.
+                */
+            type: PassengerIdentityDocumentType;
+            /**
+                * The unique identifier of the identity document
+                */
+            unique_identifier: string;
+            /**
+                * The ISO 3166-1 alpha-2 code of the country that issued this identity document
+                */
+            issuing_country_code: string;
+            /**
+                * The date on which the identity document expires
+                */
+            expires_on: string;
+    }
+    export interface CreateOrderPassenger extends Omit<OrderPassenger, 'type'> {
+            /**
+                * The passenger's identity documents. You may only provide one identity document per passenger. The identity document's type must be included in the offer's allowed_passenger_identity_document_types. If the offer's passenger_identity_documents_required is set to true, then an identity document must be provided.
+                */
+            identity_documents?: OrderPassengerIdentityDocument[];
+            /**
+                * The passenger's email address
+                * @example "amelia@duffel.com"
+                */
+            email: string;
+            /**
+                * The passenger's phone number in [E.164](https://www.twilio.com/docs/glossary/what-e164) (international) format
+                * @example "+442080160509"
+                */
+            phone_number: string;
+            /**
+                * @deprecated This type is here just for the backward-compatibility until the field is officially removed from the API
+                *
+                * The type of the passenger
+                * @example "adult", "child", or "infant_without_seat"
+                */
+            type?: DuffelPassengerType;
+    }
+    export interface OrderSliceSegment {
+            /**
+                * The aircraft that the operating carrier will use to operate this segment
+                */
+            aircraft?: Aircraft;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the segment is scheduled to arrive, in the destination airport timezone (see destination.timezone)
+                */
+            arriving_at: string;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the segment is scheduled to depart, in the origin airport timezone
+                */
+            departing_at: string;
+            /**
+                * The city or airport where this slice ends
+                */
+            destination: Place;
+            /**
+                * The terminal at the destination airport where the segment is scheduled to arrive
+                * @example "5"
+                */
+            destination_terminal?: string | null;
+            /**
+                * The duration of the segment, represented as a [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) duration
+                */
+            duration?: string;
+            /**
+                * Duffel's unique identifier for the segment.
+                * It identifies the segment of an order (i.e. the same segment across orders will have different ids.
+                */
+            id: string;
+            /**
+                * The airline selling the tickets for this segment. This may differ from the `operating_carrier` in the case of a "codeshare", where one airline sells flights operated by another airline.
+                */
+            marketing_carrier: Airline;
+            /**
+                * The flight number assigned by the marketing carrier
+                * @example "1234"
+                */
+            marketing_carrier_flight_number: string;
+            /**
+                * The airline actually operating this segment. This may differ from the `marketing_carrier` in the case of a "codeshare", where one airline sells flights operated by another airline.
+                */
+            operating_carrier: Airline;
+            /**
+                * The flight number assigned by the operating carrier. This may not be present, in which case you should display the `marketing_carrier`'s information and the `marketing_carrier_flight_number`, and simply state the name of the `operating_carrier`.
+                * @example "4321"
+                */
+            operating_carrier_flight_number: string;
+            /**
+                * The city or airport where this slice begins
+                */
+            origin: Place;
+            /**
+                * The terminal at the origin airport from which the segment is scheduled to depart
+                * @example "B"
+                */
+            origin_terminal?: string | null;
+            /**
+                * Additional segment-specific information about the passengers included in the offer (e.g. their baggage allowance and the cabin class they will be travelling in)
+                */
+            passengers: OrderSegmentPassenger[];
+            /**
+                * The distance of the segment in kilometres
+                * @example "424.2"
+                */
+            distance?: string | null;
+    }
+    export interface OrderSlice {
+            /**
+                * Whether this slice can be changed. This can only be true for paid orders.
+                */
+            changeable: boolean | null;
+            /**
+                * The conditions associated with this slice, describing the kinds of modifications you can make and any penalties that will apply to those modifications.
+                * This condition is applied only to this slice and to all the passengers associated with this order - for information at the order level (e.g. "what happens if I want to change all the slices?") refer to the `conditions` at the top level. If a particular kind of modification is allowed, you may not always be able to take action through the Duffel API. In some cases, you may need to contact the Duffel support team or the airline directly.
+                */
+            conditions: FlightsConditions;
+            /**
+                * The city or airport where this slice ends
+                */
+            destination: Place;
+            /**
+                * The type of the destination
+                */
+            destination_type: PlaceType;
+            /**
+                * The city or airport where this slice begins
+                */
+            origin: Place;
+            /**
+                * The type of the origin
+                */
+            origin_type: PlaceType;
+            /**
+                * Duffel's unique identifier for the slice. It identifies the slice of an order (i.e. the same slice across orders will have different ids.
+                */
+            id: string;
+            /**
+                * The duration of the slice, represented as a ISO 8601 duration
+                */
+            duration: string | null;
+            /**
+                * The segments - that is, specific flights - that the airline is offering to get the passengers from the origin to the destination
+                */
+            segments: OrderSliceSegment[];
+    }
+    export interface OrderPaymentStatus {
+            /**
+                * Whether a payment has been made, or the airline is waiting for a payment to be made
+                */
+            awaiting_payment: boolean;
+            /**
+                *  The ISO 8601 datetime by which you must pay for this order.
+                * At this time, if still unpaid, the reserved space on the flight(s)
+                * will be released and you will have to create a new order.
+                * This will be null only for orders where `awaiting_payment` is `false`.
+                * Payment Required by means it will hold space
+                */
+            payment_required_by?: string;
+            /**
+                *  The ISO 8601 datetime at which the price associated
+                * with the order will no longer be guaranteed by the airline
+                * and the order will need to be repriced before payment.
+                * This can be null when there is no price guarantee.
+                * Price Guarantee means it will hold price
+                */
+            price_guarantee_expires_at?: string;
+    }
+    /**
+        * The type of document
+        * @returns "electronic_ticket", "electronic_miscellaneous_document_associated", or "electronic_miscellaneous_document_standalone"
+        */
+    export type OrderDocumentsType = 'electronic_ticket' | 'electronic_miscellaneous_document_associated' | 'electronic_miscellaneous_document_standalone';
+    export interface OrderDocument {
+            /**
+                *  The identifier for the document, in the case of electronic
+                *  tickets this string represents the payment or the entitlement to fly.
+                * @example "1252106312810"
+                */
+            unique_identifier: string;
+            /**
+                * The type of document
+                */
+            type: OrderDocumentsType;
+    }
+    export interface OrderPayment {
+            /**
+                * The type of payment you want to apply to the order.
+                * If you are an IATA agent with your own agreements with airlines, in some cases, you can pay using ARC/BSP cash by specifying `arc_bsp_cash`.
+                * Otherwise, you must pay using your Duffel account's `balance` by specifying balance. In test mode, your balance is unlimited.
+                * If you're not sure which of these options applies to you, get in touch with the Duffel support team at [help@duffel.com](mailto:help@duffel.com).
+                */
+            type: PaymentType;
+            /**
+                * The amount of the payment. This should be the same as the `total_amount` of the offer specified in `selected_offers` for an instant order or the `total_amount` of the previously created pay later order specified in `order_id`, plus the `total_amount` of all the services specified in `services`.
+                * @example "30.20"
+                */
+            amount: string;
+            /**
+                * The currency of the amount, as an ISO 4217 currency code. For an instant order, this should be the same as the total_currency of the offer specified in selected_offers. For a pay later order, this should be the same as the total_currency of the previously created order specified in order_id.
+                * @example "GBP"
+                */
+            currency: string;
+    }
+    export interface Order {
+            /**
+                * The amount of tax payable on the order for all the flights booked
+                */
+            tax_amount?: string;
+            /**
+                * The currency of the `tax_amount`, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code
+                */
+            tax_currency: string;
+            /**
+                * The total price of the order for all the flights and services booked, including taxes
+                */
+            total_amount: string;
+            /**
+                * The currency of the `total_amount`, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code
+                */
+            total_currency: string;
+            /**
+                * The [slices](https://duffel.com/docs/api/overview/key-principles) that make up the itinerary of this order.
+                * One-way journeys can be expressed using one slice,
+                * whereas return trips will need two.
+                */
+            slices: OrderSlice[];
+            /**
+                * The services booked along with this order
+                */
+            services: OrderService[];
+            /**
+                * The passengers who are travelling
+                */
+            passengers: OrderPassenger[];
+            /**
+                * The payment status for this order
+                *
+                */
+            payment_status: OrderPaymentStatus;
+            /**
+                * The airline who owns the order
+                */
+            owner: Airline;
+            /**
+                * Whether the order was created in live mode.
+                * This field will be set to true if the order was created
+                * in live mode, or false if it was created in test mode.
+                */
+            live_mode: boolean;
+            /**
+                * Duffel's unique identifier for the order
+                */
+            id: string;
+            /**
+                *  The documents issued for this order.
+                */
+            documents?: OrderDocument[];
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) datetime at which the order was created
+                */
+            created_at: string;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) datetime at which the order was cancelled, if it has been cancelled
+                */
+            cancelled_at?: string | null;
+            /**
+                * The airline's reference for the order, sometimes known as a
+                * "passenger name record" (PNR) or "record locator".
+                * Your customers can use this to check in and manage
+                * their booking on the airline's website.
+                */
+            booking_reference: string;
+            /**
+                * The currency of the base_amount, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code.
+                * It will match your organisation's billing currency unless you're
+                * using Duffel as an accredited IATA agent, in which case it will
+                * be in the currency provided by the airline (which will usually
+                * be based on the country where your IATA agency is registered).
+                */
+            base_currency: string;
+            /**
+                *  The base price of the order for all flights and services booked, excluding taxes
+                */
+            base_amount: string;
+            /**
+                * The conditions associated with this order, describing the kinds of modifications you can make post-booking and any penalties that will apply to those modifications.
+                *
+                * This information assumes the condition is applied to all of the slices and passengers associated with this order - for information at the slice level (e.g. "what happens if I just want to change the first slice?") refer to the `slices`.
+                *
+                * If a particular kind of modification is allowed, you may not always be able to take action through the Duffel API.
+                *
+                * In some cases, you may need to contact the Duffel support team or the airline directly.
+                */
+            conditions: FlightsConditions;
+            /**
+                * Metadata contains a set of key-value pairs that you can attach to an object.
+                * It can be useful for storing additional information about the object, in a structured format.
+                * Duffel does not use this information.
+                * You should not store sensitive information in this field.
+                */
+            metadata: Record<string, string>;
+            /**
+                * The airline-initiated changes for this order.
+                */
+            airline_initiated_changes?: AirlineInitiatedChange[];
+    }
+    export interface CreateOrder {
+            /**
+                * The `id`s of the offers you want to book. You must specify an array containing exactly one selected offer.
+                */
+            selected_offers: string[];
+            /**
+                * The services you want to book along with the first selected offer.
+                */
+            services?: Pick<OrderService, 'id' | 'quantity'>[];
+            /**
+                * The personal details of the passengers, expanding on the information initially provided when creating the offer request
+                */
+            passengers: CreateOrderPassenger[];
+            /**
+                * The payment details to use to pay for the order
+                */
+            payments?: OrderPayment[];
+            /**
+                * The payment action you want to take for your order. You can only use pay_later with offers that contain requires_instant_payment: false.
+                */
+            type: 'instant' | 'pay_later';
+    }
+    export interface ListParamsOrders {
+            /**
+                * Whether to filter orders that are awaiting payment or not. If not specified, all orders regardless of their payment state will be returned.
+                */
+            awaiting_payment?: boolean;
+            /**
+                * Whether to filter orders matching a passenger name. Partial and exact matches in given and family names will be returned.
+                */
+            'passenger_name[]'?: string[];
+            /**
+                * Whether to filter orders matching a given passenger name record (PNR)
+                */
+            booking_reference?: string;
+    }
+    export interface UpdateSingleOrder {
+            metadata: Order['metadata'];
+    }
+    export interface AddServices {
+            payment: OrderPayment;
+            add_services: Pick<OrderService, 'id' | 'quantity'>[];
+    }
+    export type OrderAvailableService = OfferAvailableServiceBaggage;
+}
+
+declare module '@duffel/api/booking/Payments/PaymentsTypes' {
+    import { PaymentType } from '@duffel/api/types';
+    /**
+        * To pay for an unpaid order you've previously created, you'll need to create a payment for it.
+        * @link https:/duffel.com/docs/api/payments/schema
+        */
+    export interface Payment {
+            /**
+                * The amount of the payment.
+                * This should be the same as the `total_amount` of the offer specified in `selected_offers` for an instant order or the `total_amount` of the previously created pay later order specified in `order_id`, plus the `total_amount` of all the services specified in services.
+                */
+            amount: string;
+            /**
+                * The currency of the amount, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code.
+                * For an instant order, this should be the same as the `total_currency` of the offer specified in selected_offers.
+                * For a pay later order, this should be the same as the `total_currency` of the previously created order specified in `order_id`.
+                */
+            currency?: string | null;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the payment was created
+                */
+            created_at: string;
+            /**
+                * Duffel's unique identifier for the payment
+                */
+            id: string;
+            /**
+                * The type of payment you want to apply to the order.
+                * If you are an IATA agent with your own agreements with airlines, in some cases, you can pay using ARC/BSP cash by specifying `arc_bsp_cash`.
+                * Otherwise, you must pay using your Duffel account's balance by specifying `balance`. In [test mode](https://duffel.com/docs/api/overview/test-mode), your balance is unlimited.
+                * If you're not sure which of these options applies to you, get in touch with the Duffel support team at [help@duffel.com](mailto:help@duffel.com).
+                */
+            type: PaymentType;
+    }
+    export interface CreatePayment {
+            /**
+                * The `id` of the order you want to pay for.
+                */
+            order_id: string;
+            /**
+                * The payment details to use to pay for the order
+                */
+            payment: Omit<Payment, 'created_at' | 'id'>;
+    }
+}
+
+declare module '@duffel/api/booking/SeatMaps/SeatMapTypes' {
+    /**
+        * Seat maps are used to build a rich experience for your customers so they can select a seat as part of an order.
+        * A seat map includes the data for rendering seats in the relevant cabins, along with their total cost and other information such as disclosures.
+        * @link https://duffel.com/docs/api/seat-maps/schema
+        */
+    export interface SeatMap {
+            /**
+                * Duffel's unique identifier for the seat map
+                */
+            id: string;
+            /**
+                * Duffel's unique identifier for the slice. It identifies the slice of an offer (i.e. the same slice across offers will have different ids.)
+                */
+            slice_id: string;
+            /**
+                * Duffel's unique identifier for the segment. It identifies the segment of an offer (i.e. the same segment across offers will have different ids).
+                */
+            segment_id: string;
+            /**
+                * The list of cabins in this seat map.
+                * Cabins are ordered by deck from lowest to highest, and then within each deck from the front to back of the aircraft.
+                */
+            cabins: SeatMapCabin[];
+    }
+    export interface SeatMapCabin {
+            /**
+                * Level 0 is the main deck and level 1 is the upper deck above that, which is found on some large aircraft.
+                */
+            deck: number;
+            /**
+                * The cabin class that the passenger will travel in on this segment
+                */
+            cabin_class: string;
+            /**
+                * Where the wings of the aircraft are in relation to rows in the cabin.
+                * The numbers correspond to the indices of the first and the last row which are overwing. You can use this to draw a visual representation of the wings to help users get a better idea of what they will see outside their window.
+                * The indices are 0 th-based and are for all rows, not just those that have seats.
+                * This is null when no rows of the cabin are overwing.
+                */
+            wings: {
+                    /**
+                        * The index of the first row which is overwing, starting from the front of the aircraft.
+                        */
+                    first_row_index: number;
+                    /**
+                        * The index of the last row which is overwing, starting from the front of the aircraft.
+                        */
+                    last_row_index: number;
+            } | null;
+            /**
+                * The number of aisles in this cabin.
+                * If this is set to 1, each row of the cabin is split into two sections. If this is set to 2, each row of the cabin is split into three section.
+                */
+            aisles: number;
+            /**
+                * A list of rows in this cabin.
+                * Row sections are broken up by aisles. Rows are ordered from front to back of the aircraft.
+                */
+            rows: SeatMapCabinRow[];
+    }
+    export interface SeatMapCabinRow {
+            /**
+                * A list of sections.
+                * Each row is divided into sections by one or more aisles.
+                */
+            sections: SeatMapCabinRowSection[];
+    }
+    export interface SeatMapCabinRowSection {
+            /**
+                * The elements that make up this section.
+                */
+            elements: SeatMapCabinRowSectionElement[];
+    }
+    /**
+        * A seat for a passenger. If the available_services list is empty (which will be represented as an empty list : []), the seat is unavailable.
+        * For display, all seats should be displayed with the same static width.
+        */
+    export interface SeatMapCabinRowSectionElementSeat {
+            /**
+                * The type of this element.
+                */
+            type: 'seat';
+            /**
+                * The designator used to uniquely identify the seat, usually made up of a row number and a column letter
+                */
+            designator: string;
+            /**
+                * A name which describes the type of seat, which you can display in your user interface to help customers to understand its features
+                */
+            name?: string;
+            /**
+                * Each disclosure is text, in English, provided by the airline that describes the terms and conditions of this seat. We recommend showing this in your user interface to make sure that customers understand any restrictions and limitations.
+                */
+            disclosures: string[];
+            /**
+                * Seats are considered a special kind of service. There will be at most one service per seat per passenger. A seat can only be booked for one passenger. If a seat has no available services (which will be represented as an empty list : []) then it's unavailable.
+                */
+            available_services: SeatMapCabinRowSectionAvailableService[];
+    }
+    export interface SeatMapCabinRowSectionAvailableService {
+            /**
+                * Duffel's unique identifier for the service
+                */
+            id: string;
+            /**
+                * The passenger that this seat is for
+                */
+            passenger_id: string;
+            /**
+                * The total price of the seat, including taxes
+                */
+            total_amount: string;
+            /**
+                * The currency of the total_amount, as an ISO 4217 currency code
+                */
+            total_currency: string;
+    }
+    /**
+        * A bassinet is a child's cradle. This element will be aligned with the corresponding seat in the following row.
+        * For display, this element should have the same width as a seat for proper alignment.
+        */
+    export interface SeatMapCabinRowSectionElementBassinet {
+            /**
+                * The type of this element.
+                */
+            type: 'bassinet';
+    }
+    /**
+        * An empty space used for padding in some non-standard seat arrangements.
+        * For display, this element should have the same dimensions as a seat for proper alignment.
+        */
+    export interface SeatMapCabinRowSectionElementEmpty {
+            /**
+                * The type of this element.
+                */
+            type: 'empty';
+    }
+    /**
+        * An exit row represents the extra wide legroom used to reach aircraft exits. There is one exit_row element per row section.
+        * Exit row elements only occur in their own row, so they can be displayed as one element across the whole row. Displaying an exit row element filling all available space in its section or using the same width as the seat is also reasonable.
+        */
+    export interface SeatMapCabinRowSectionElementExitRow {
+            /**
+                * The type of this element.
+                */
+            type: 'exit_row';
+    }
+    /**
+        * A lavatory for use by passengers.
+        * For display, this element should ideally fill or shrink to available space in a row section. Displaying it with the same width as seat is also reasonable.
+        */
+    export interface SeatMapCabinRowSectionElementLavatory {
+            /**
+                * The type of this element.
+                */
+            type: 'lavatory';
+    }
+    /**
+        * A galley is the compartment where food is cooked or prepared. These are conventionally marked with a teacup symbol.
+        * For display, this element should ideally fill or shrink to available space in a row section. Displaying it with the same width as seat is also reasonable.
+        */
+    export interface SeatMapCabinRowSectionElementGalley {
+            /**
+                * The type of this element.
+                */
+            type: 'galley';
+    }
+    /**
+        * A closet used for storage. These are conventionally marked with a clothes hanger symbol.
+        * For display, this element should ideally fill or shrink to available space in a row section. Displaying it with the same width as seat is also reasonable.
+        */
+    export interface SeatMapCabinRowSectionElementCloset {
+            /**
+                * The type of this element.
+                */
+            type: 'closet';
+    }
+    /**
+        * A set of stairs to another deck.
+        * For display, this element should ideally fill or shrink to available space in a row section. Displaying it with the same width as seat is also reasonable.
+        */
+    export interface SeatMapCabinRowSectionElementStairs {
+            /**
+                * The type of this element.
+                */
+            type: 'stairs';
+    }
+    export type SeatMapCabinRowSectionElement = SeatMapCabinRowSectionElementSeat | SeatMapCabinRowSectionElementBassinet | SeatMapCabinRowSectionElementEmpty | SeatMapCabinRowSectionElementExitRow | SeatMapCabinRowSectionElementLavatory | SeatMapCabinRowSectionElementGalley | SeatMapCabinRowSectionElementCloset | SeatMapCabinRowSectionElementStairs;
+    export type SeatMapCabinRowSectionElementType = SeatMapCabinRowSectionElement['type'];
+    export type SeatMapCabinRowSectionElementAmenity = Exclude<SeatMapCabinRowSectionElementType, 'empty' | 'seat'>;
+}
+
+declare module '@duffel/api/supportingResources/Aircraft/AircraftTypes' {
+    /**
+        * Aircraft are used to describe what passengers will fly in for a given trip
+        * @link https://duffel.com/docs/api/aircraft/schema
+        */
+    export interface Aircraft {
+            /**
+                * The name of the aircraft
+                */
+            name: string;
+            /**
+                * Duffel's unique identifier for the aircraft
+                */
+            id: string;
+            /**
+                * The three-character IATA code for the aircraft
+                */
+            iata_code: string;
+    }
+}
+
+declare module '@duffel/api/supportingResources/Airlines/AirlinesTypes' {
+    /**
+        * Airlines are used to identify the air travel companies selling and operating flights
+        * @link https://duffel.com/docs/api/airlines/schema
+        */
+    export interface Airline {
+            /**
+                * The three-character IATA code for the airline
+                */
+            name: string;
+            /**
+                * Duffel's unique identifier for the airline
+                */
+            id: string;
+            iata_code: string;
+            logo_lockup_url?: string;
+            logo_symbol_url?: string;
+    }
+}
+
+declare module '@duffel/api/supportingResources/Airports/AirportsTypes' {
+    import { City } from '@duffel/api/types';
+    /**
+        * Airports are used to identify origins and destinations in journey slices
+        * @link https://duffel.com/docs/api/airports/schema
+        */
+    export interface Airport {
+            /**
+                * The metropolitan area where the airport is located.
+                * Only present for airports which are registered with IATA as belonging to a metropolitan area.
+                */
+            city?: City | null;
+            /**
+                * The name of the city (or cities separated by a `/`) where the airport is located
+                */
+            city_name: string;
+            /**
+                * The three-character IATA code for the airport
+                */
+            iata_code?: string;
+            /**
+                * The ISO 3166-1 alpha-2 code for the country where the city is located
+                * @link https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
+                * @example "GB"
+                */
+            iata_country_code: string;
+            /**
+                * The 3-letter IATA code for the city where the place is located.
+                * Only present for airports which are registered with IATA as belonging to a [metropolitan area](https://portal.iata.org/faq/articles/en_US/FAQ/How-do-I-create-a-new-Metropolitan-Area).
+                */
+            iata_city_code?: string | null;
+            /**
+                * The four-character ICAO code for the airport
+                */
+            icao_code?: string;
+            /**
+                * Duffel's unique identifier for the airport
+                */
+            id: string;
+            /**
+                * The latitude position of the airport represented in Decimal degrees with 6 decimal points with a range between -90° and 90°
+                */
+            latitude: number;
+            /**
+                * The longitude position of the airport represented in Decimal degrees with 6 decimal points with a range between -180° and 180°
+                */
+            longitude: number;
+            /**
+                * The name of the airport
+                */
+            name: string;
+            /**
+                * The time zone of the airport, specified by name from the [tz database](https://en.wikipedia.org/wiki/Tz_database)
+                */
+            time_zone: string;
+    }
+}
+
+declare module '@duffel/api/DuffelPayments/PaymentIntents/PaymentIntentsType' {
+    export interface PaymentIntent {
+            /**
+                * The amount of the Payment Intent that covers the cost of the flight being sold and any additional markup.
+                * The card payment will be charged this amount.
+                */
+            amount: string;
+            /**
+                * The [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) code of the country that issued the card used to confirm the Payment Intent.
+                * It will be null until the Payment Intent is confirmed.
+                */
+            card_country_code: string | null;
+            /**
+                * The last four digits of the card used to confirm the Payment Intent.
+                * It will be null until the Payment Intent is confirmed.
+                */
+            card_last_four_digits: string | null;
+            /**
+                * The card network in which the Payment Intent was processed on.
+                * It will be null until the Payment Intent is confirmed.
+                */
+            card_network: 'amex' | 'cartes_bancaires' | 'diners' | 'discover' | 'interac' | 'jcb' | 'mastercard' | 'unionpay' | 'visa' | 'unknown' | null;
+            /**
+                * This value is used when displaying the payment collection form to securely identify and transmit the values to Duffel.
+                */
+            client_token: string;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the Payment Intent was confirmed
+                */
+            confirmed_at: string;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the Payment Intent was created
+                */
+            created_at: string;
+            /**
+                * The currency of the `amount`, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code.
+                * The card payment will be charged in this currency.
+                * If it's different to your Balance currency, it will be converted to your Balance currency before the Balance is topped up.
+                */
+            currency: string;
+            /**
+                * The amount of the fees to process the Payment Intent.
+                * It will be `null` until the Payment Intent is confirmed.
+                */
+            fees_amount: string | null;
+            /**
+                * The currency of the fees_amount, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code.
+                * This currency will match your Balance currency.
+                * It will be null until the Payment Intent is confirmed.
+                */
+            fees_currency: string | null;
+            /**
+                * Duffel's unique identifier for the `Payment Intent`
+                */
+            id: string;
+            /**
+                * Whether the Payment Intent was created in live mode. This field will be set to `true` if the Payment Intent was created in live mode, or `false` if it was created in test mode.
+                */
+            live_mode: boolean;
+            /**
+                * The amount of the Payment Intent that was added to the Balance.
+                * It'll be `amount` (in the Balance currency) less the `fees_amount`.
+                * It will be `null` until the Payment Intent is confirmed.
+                */
+            net_amount: string | null;
+            /**
+                * The currency of the net_amount, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code.
+                * This currency will match your Balance currency.
+                * It will be null until the Payment Intent is confirmed.
+                */
+            net_currency: string | null;
+            /**
+                * The Refunds for this Payment Intent
+                * @link https://duffel.com/docs/api/payment-intents/schema#payment-intents-schema-refunds
+                */
+            refunds: {
+                    amount: string;
+                    arrival: string;
+                    created_at: string;
+                    currency: string;
+                    destination: string;
+                    id: string;
+                    live_mode: boolean;
+                    net_amount: string;
+                    net_currency: string;
+                    payment_intent_id: string;
+                    status: 'succeeded' | 'pending' | 'failed';
+                    updated_at: string;
+            }[];
+            /**
+                * The status of this Payment Intent
+                */
+            status: null | 'requires_payment_method' | 'requires_confirmation' | 'requires_action' | 'processing' | 'requires_capture' | 'cancelled' | 'succeeded';
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the Payment Intent was updated
+                */
+            updated_at: string;
+    }
+    export interface CreatePaymentIntent {
+            /**
+                * This is the amount that the card payment being taken will be charged.
+                * It should be enough to cover the service(s) you want to sell (enough to book an Offer for example) and the processing fees.
+                * If the currency is different from your Balance currency you should also account for foreign exchange.
+                * It can be higher than that, in which case the remainder will be considered your markup.
+                * If it's higher than the maximum allowed for you organisation you will get a validation error. By default the maximum is 5,000.00 GBP (or equivalent in the same currency). If you need a maximum higher than the default please get in touch with us via help@duffel.com.
+                */
+            amount: string;
+            /**
+                * The currency of the amount, as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code.
+                * This is going to be the currency that the card payment being taken in will be charged in.
+                */
+            currency: string;
+    }
+}
+
+declare module '@duffel/api/Places/Suggestions/SuggestionsType' {
+    import { Airport, City } from '@duffel/api/types';
+    export interface Places {
+            /**
+                * The type of the place
+                */
+            type: string;
+            /**
+                * The time zone of the airport, specified by name from the tz database
+                */
+            time_zone: string | null;
+            /**
+                * The name of the place
+                */
+            name: string;
+            /**
+                * The longitude position of the airport represented in Decimal degrees with 6 decimal points with a range between -180° and 180°
+                */
+            longitude: number | null;
+            /**
+                * The latitude position of the airport represented in Decimal degrees with 6 decimal points with a range between -90° and 90°
+                */
+            latitude: number | null;
+            /**
+                * Duffel's unique identifier for the place
+                */
+            id: string;
+            /**
+                * The four-character ICAO code for the airport
+                */
+            icao_code: string | null;
+            /**
+                * The ISO 3166-1 alpha-2 code for the country where the city is located
+                */
+            iata_country_code: string;
+            /**
+                * The 3-letter IATA code for the place
+                */
+            iata_code: string;
+            /**
+                * The 3-letter IATA code for the city where the place is located. Only present for airports which are registered with IATA as belonging to a metropolitan area.
+                */
+            iata_city_code: string | null;
+            /**
+                * The name of the country where the city or airport is located
+                */
+            country_name: string | null;
+            /**
+                * The name of the city (or cities separated by a /) where the airport is located
+                */
+            city_name: string | null;
+            /**
+                * The metropolitan area where the airport is located. Only present for airports which are registered with IATA as belonging to a metropolitan area.
+                */
+            city: City | null;
+            /**
+                * The airports associated to a city. This will only be provided where the type is city.
+                */
+            airports: Airport[] | null;
+    }
+}
+
+declare module '@duffel/api/types/shared' {
+    import { Airport } from '@duffel/api/supportingResources/Airports/AirportsTypes';
+    /**
+        * The metropolitan area where the airport is located.
+        * Only present for airports which are registered with IATA as belonging to a metropolitan area.
+        * @link https://portal.iata.org/faq/articles/en_US/FAQ/How-do-I-create-a-new-Metropolitan-Area
+        */
+    export interface City {
+            /**
+                * The type of the place
+                */
+            type?: 'city';
+            /**
+                * The three-character IATA code for the city
+                * @example "LON"
+                */
+            iata_code: string;
+            /**
+                * The ISO 3166-1 alpha-2 code for the country where the city is located
+                * @link https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
+                * @example "GB"
+                */
+            iata_country_code: string;
+            /**
+                * Duffel's unique identifier for the city
+                * @example "cit_lon_gb"
+                */
+            id: string;
+            /**
+                * The name of the city
+                * @example "London"
+                */
+            name: string;
+            /**
+                * The time zone of the airport, specified by name from the [tz database](https://en.wikipedia.org/wiki/Tz_database)
+                */
+            time_zone?: string | null;
+            /**
+                * The longitude position of the airport represented in [Decimal degrees](https://en.wikipedia.org/wiki/Decimal_degrees) with 6 decimal points with a range between -180° and 180°
+                */
+            longitude?: number | null;
+            /**
+                * The latitude position of the airport represented in [Decimal degrees](https://en.wikipedia.org/wiki/Decimal_degrees) with 6 decimal points with a range between -90° and 90°
+                */
+            latitude?: number | null;
+            /**
+                * The 3-letter IATA code for the city where the place is located.
+                * Only present for airports which are registered with IATA as belonging to a [metropolitan area](https://portal.iata.org/faq/articles/en_US/FAQ/How-do-I-create-a-new-Metropolitan-Area).
+                */
+            iata_city_code?: string | null;
+            /**
+                * The name of the city (or cities separated by a `/`) where the airport is located
+                */
+            city_name?: string | null;
+    }
+    /**
+        * The cabin class that the passenger will travel in on this segment
+        */
+    export type CabinClass = 'first' | 'business' | 'premium_economy' | 'economy';
+    /**
+        * The type of the passenger
+        */
+    export type DuffelPassengerType = 'adult' | 'child' | 'infant_without_seat';
+    /**
+        * The passenger's title
+        */
+    export type DuffelPassengerTitle = 'mr' | 'ms' | 'mrs' | 'MR' | 'MS' | 'MRS';
+    /**
+        * The passenger's gender
+        */
+    export type DuffelPassengerGender = 'm' | 'f';
+    /**
+        * The type of the identity document.
+        * This must be one of the `allowed_passenger_identity_document_types` on the offer.
+        */
+    export type PassengerIdentityDocumentType = 'passport' | 'tax_id';
+    /**
+        * The type of the origin or destination
+        */
+    export type PlaceType = 'airport' | 'city';
+    export type Place = (Airport & {
+            type?: 'airport';
+            airports?: Airport[] | null;
+    }) | (City & {
+            type?: 'city';
+    });
+    /**
+        * The conditions associated with this offer, describing the kinds of modifications you can make post-booking and any penalties that will apply to those modifications.
+        * This information assumes the condition is applied to all of the slices and passengers associated with this offer - for information at the slice level (e.g. "what happens if I just want to change the first slice?") refer to the slices.
+        * If a particular kind of modification is allowed, you may not always be able to take action through the Duffel API.
+        * In some cases, you may need to contact the Duffel support team or the airline directly.
+        */
+    export type FlightsConditions = {
+            /**
+                * Whether the whole order or offer can be refunded before the departure of the first slice.
+                * If all of the slices on the order or offer can be refunded then the `allowed` property will be `true` and information will be provided about any penalties.
+                * If any of the slices on the order or offer can't be refunded then the `allowed` property will be `false`.
+                * If the airline hasn't provided any information about whether this order or offer can be refunded then this property will be `null`.
+                */
+            refund_before_departure?: {
+                    /**
+                        * The currency of the `penalty_amount` as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code.
+                        * This will be in a currency determined by the airline, which is not necessarily the same as the currency of the order or offer.
+                        * If this is `null` then `penalty_amount` will also be `null`.
+                        * @example "GBP"
+                        */
+                    penalty_currency: string;
+                    /**
+                        * If the modification is `allowed` then this is the amount payable to apply the modification to all passengers.
+                        * If there is no penalty, the value will be zero. If the modification isn't `allowed` or the penalty is not known then this field will be `null`.
+                        * If this is `null` then the `penalty_currency` will also be null.
+                        * @example "100.00"
+                        */
+                    penalty_amount?: string;
+                    /**
+                        * Whether this kind of modification is allowed post-booking
+                        *
+                        * @example "true"
+                        */
+                    allowed: boolean;
+            } | null;
+            /**
+                * Whether the whole order or offer can be changed before the departure of the first slice.
+                * If all of the slices on the order or offer can be changed then the `allowed` property will be `true`.
+                * Refer to the `slices` for information about change penalties.
+                * If any of the slices on the order or offer can't be changed then the `allowed` property will be `false`.
+                * In this case you should refer to the slices conditions to determine if any part of the order or offer is changeable.
+                * If the airline hasn't provided any information about whether this order or offer can be changed then this property will be `null`.
+                */
+            change_before_departure?: {
+                    /**
+                        * The currency of the `penalty_amount` as an [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code.
+                        * This will be in a currency determined by the airline, which is not necessarily the same as the currency of the order or offer.
+                        * If this is `null` then `penalty_amount` will also be `null`.
+                        * @example "GBP"
+                        */
+                    penalty_currency: string;
+                    /**
+                        * If the modification is `allowed` then this is the amount payable to apply the modification to all passengers.
+                        * If there is no penalty, the value will be zero. If the modification isn't `allowed` or the penalty is not known then this field will be `null`.
+                        * If this is `null` then the `penalty_currency` will also be null.
+                        * @example "100.00"
+                        */
+                    penalty_amount?: string;
+                    /**
+                        * Whether this kind of modification is allowed post-booking
+                        *
+                        * @example "true"
+                        */
+                    allowed: boolean;
+            } | null;
+    };
+    /**
+        * The type of payment you want to apply to the order.
+        * If you are an IATA agent with your own agreements with airlines, in some cases, you can pay using ARC/BSP cash by specifying `arc_bsp_cash`. Otherwise, you must pay using your Duffel account's balance by specifying `balance`.
+        * In test mode, your balance is unlimited. If you're not sure which of these options applies to you, get in touch with the Duffel support team at [help@duffel.com](mailto:help@duffel.com).
+        */
+    export type PaymentType = 'arc_bsp_cash' | 'balance';
+}
+
+declare module '@duffel/api/types/ClientType' {
+    import { Headers } from 'node-fetch';
+    /**
+        * Our list APIs will only return a limited number of results at a time.
+        * By default, we'll return 50 results per page, but you can set this to any number between 1 and 200.
+        * @link https://duffel.com/docs/api/overview/pagination
+        */
+    export interface PaginationMeta {
+            /**
+                * The number of results to be returned in a page, between 1 and 200 (optional, default is 50)
+                */
+            limit?: number;
+            /**
+                * "Before" cursor for pagination
+                */
+            before?: string;
+            /**
+                * "After" cursor for pagination
+                */
+            after?: string | null;
+    }
+    export interface ApiResponseMeta {
+            /**
+                * The identifier of the request
+                */
+            request_id: string;
+            /**
+                * The [HTTP status](https://httpstatuses.com/) of the request
+                */
+            status: number;
+    }
+    /**
+        * Duffel uses standard [HTTP response codes](https://httpstatuses.com/) to indicate the success or failure of API requests.
+        * @link https://duffel.com/docs/api/overview/errors
+        */
+    export interface ApiResponseError {
+            /**
+                * A machine-readable identifier for this specific error
+                */
+            code: string;
+            /**
+                * A URL pointing to a place in our documentation where you can read about the error
+                */
+            documentation_url: string;
+            /**
+                * A more detailed human-readable description of what went wrong
+                */
+            message: string;
+            /**
+                * A quick and simple description of what went wrong
+                */
+            title: string;
+            /**
+                * A machine-readable identifier for the general category of error
+                */
+            type: string;
+    }
+    export interface DuffelResponse<T_Data> {
+            /**
+                * The body of the response
+                */
+            data: T_Data;
+            /**
+                * Optional metadata for the request
+                */
+            meta?: PaginationMeta;
+            /**
+                * The headers from the http response
+                */
+            headers?: Headers;
+    }
+    export interface SDKOptions {
+            /**
+                * If `true` it will output the path and the method called
+                */
+            verbose?: boolean;
+    }
+}
+
+declare module '@duffel/api/notifications/Webhooks/WebhooksType' {
+    import { PaginationMeta } from 'types';
+    export interface Webhooks {
+            /**
+                * Whether the webhook receiver is actively being notified or not
+                */
+            active: boolean;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the webhook was created
+                */
+            created_at: string;
+            /**
+                * The events that this webhook will be subscribed to
+                */
+            events: string[];
+            /**
+                * Duffel's unique identifier for the webhook receiver
+                */
+            id: string;
+            /**
+                * The live mode that the webhook was created in. It will only receive events for that same live mode. For example, you won't receive order.created events for orders that you created in the sandbox, if your webhook is for live_mode: true.
+                */
+            live_mode: boolean;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the order change was updated
+                */
+            updated_at: string;
+            /**
+                * The URL where your webhook will be received
+                */
+            url: string;
+    }
+    export interface WebhooksListDeliveriesParams extends PaginationMeta {
+            delivery_success: boolean;
+            /**
+                * Filters the returned webhook deliveries by creation datetime.
+                */
+            created_at?: PaginationMeta;
+            /**
+                * Filters webhook deliveries by the type of their related webhook event.
+                */
+            type?: string;
+            /**
+                * Filters webhook deliveries by the ID of the related webhook endpoint.
+                */
+            endpoint_id: string;
+    }
+    export interface WebhooksUpdateParams {
+            /**
+                * The desired active status of the webhook
+                */
+            active: boolean;
+            /**
+                * The desired events that the webhook should subscribe to
+                */
+            events: string[];
+            /**
+                * The desired url of the webhook
+                */
+            url: string;
+    }
+    export interface WebhooksCreateParams {
+            /**
+                * The desired events that the webhook should subscribe to
+                */
+            events: string[];
+            /**
+                * The desired url of the webhook
+                */
+            url: string;
+    }
+    export interface WebhooksListDeliveriesResponse {
+            /**
+                * The URL where your webhook will be received
+                */
+            url: string;
+            endpoint_id: string;
+            /**
+                * Webhook deliveries will be included if they were successful.
+                */
+            delivery_success?: boolean;
+            type: string;
+            response_status_code: 200;
+            response_body: string;
+            event_id: string;
+            /**
+                * The live mode that the webhook was created in. It will only receive events for that same live mode. For example, you won't receive order.created events for orders that you created in the sandbox, if your webhook is for live_mode: true.
+                */
+            live_mode: boolean;
+            /**
+                * Duffel's unique identifier for the webhook receiver
+                */
+            id: string;
+            /**
+                * The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) datetime at which the webhook was created
+                */
+            created_at: string;
+    }
+    export interface WebhooksListResponse extends Webhooks {
+            /**
+                * Webhook deliveries will be included if they were successful.
+                */
+            delivery_success?: boolean;
+    }
+    export interface WebhooksCreateResponse {
+            secret: string;
+            url: string;
+            updated_at: string;
+            live_mode: boolean;
+            id: string;
+            events: string[];
+            created_at: string;
+            active: boolean;
+    }
+}
+
+declare module '@duffel/api/supportingResources/Aircraft/Aircraft' {
+    import { Resource } from '@duffel/api/Resource';
+    import { Aircraft as AircraftType, DuffelResponse, PaginationMeta } from '@duffel/api/types';
+    /** Aircraft are used to describe what passengers will fly in for a given trip
+        * @class
+        * @link https://duffel.com/docs/api/aircraft
+        */
+    export class Aircraft extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(args: any);
+            /**
+                * Retrieves an aircraft by its ID
+                * @param {string} id - Duffel's unique identifier for the aircraft
+                * @link https://duffel.com/docs/api/aircraft/get-aircraft-by-id
+                */
+            get: (id: string) => Promise<DuffelResponse<AircraftType>>;
+            /**
+                * Retrieves a page of aircraft. The results may be returned in any order.
+                * @param {Object} [options] - Pagination options (optional: limit, after, before)
+                * @link https://duffel.com/docs/api/aircraft/get-aircraft
+                */
+            list: (options?: PaginationMeta) => Promise<DuffelResponse<AircraftType[]>>;
+            /**
+                * Retrieves a generator of all aircraft. The results may be returned in any order.
+                * @link https://duffel.com/docs/api/aircraft/get-aircraft
+                */
+            listWithGenerator: () => AsyncGenerator<DuffelResponse<AircraftType>, void, unknown>;
+    }
+}
+
+declare module '@duffel/api/supportingResources/Airlines/Airlines' {
+    import { Resource } from '@duffel/api/Resource';
+    import { Airline, DuffelResponse, PaginationMeta } from '@duffel/api/types';
+    /** Airlines are used to identify the air travel companies selling and operating flights
+        * @class
+        * @link https://duffel.com/docs/api/airlines */
+    export declare class Airlines extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(args: any);
+            /**
+                * Retrieves an airline by its ID
+                * @param {string} id - Duffel's unique identifier for the airline
+                * @link https://duffel.com/docs/api/airlines/get-airline-by-id
+                */
+            get: (id: string) => Promise<DuffelResponse<Airline>>;
+            /**
+                * Retrieves a page of airlines. The results may be returned in any order.
+                * @param {Object} [options] - Pagination options (optional: limit, after, before)
+                * @link https://duffel.com/docs/api/airlines/get-airlines
+                */
+            list: (options?: PaginationMeta) => Promise<DuffelResponse<Airline[]>>;
+            /**
+                * Retrieves a generator of all airlines. The results may be returned in any order.
+                * @link https://duffel.com/docs/api/airlines/get-airlines
+                */
+            listWithGenerator: () => AsyncGenerator<DuffelResponse<Airline>, void, unknown>;
+    }
+}
+
+declare module '@duffel/api/supportingResources/Airports/Airports' {
+    import { Resource } from '@duffel/api/Resource';
+    import { Airport, DuffelResponse, PaginationMeta } from '@duffel/api/types';
+    /** Airports are used to identify origins and destinations in journey slices
+        * @class
+        * @link https://duffel.com/docs/api/airports
+        */
+    export class Airports extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(args: any);
+            /**
+                * Retrieves an airport by its ID
+                * @param {string} id - Duffel's unique identifier for the airport
+                * @link https://duffel.com/docs/api/airports/get-airport-by-id
+                */
+            get: (id: string) => Promise<DuffelResponse<Airport>>;
+            /**
+                * Retrieves a page of airports. The results may be returned in any order.
+                * @param {Object} [options] - Pagination options (optional: limit, after, before)
+                * @link https://duffel.com/docs/api/airports/get-airports
+                */
+            list: (options?: PaginationMeta) => Promise<DuffelResponse<Airport[]>>;
+            /**
+                * Retrieves a generator of all airports. The results may be returned in any order.
+                * @link https://duffel.com/docs/api/airports/get-airports
+                */
+            listWithGenerator: () => AsyncGenerator<DuffelResponse<Airport>, void, unknown>;
+    }
+}
+
+declare module '@duffel/api/Resource' {
+    import { Client } from '@duffel/api/Client';
+    import { DuffelResponse } from '@duffel/api/types';
+    export class Resource {
+        constructor(client: Client);
+        protected request: <T_Data = any>({ method, path, data, params, }: {
+            method: string;
+            path: string;
+            data?: Record<string, any> | undefined;
+            params?: Record<string, any> | undefined;
+        }) => Promise<DuffelResponse<T_Data>>;
+        protected paginatedRequest: <T_Data = any>({ path, params, }: {
+            path: string;
+            params?: Record<string, any> | undefined;
+        }) => AsyncGenerator<DuffelResponse<T_Data>, void, unknown>;
+    }
+}
+
+declare module '@duffel/api/DuffelPayments/Refunds/RefundsType' {
+    export interface Refund {
+            /**
+                * The amount of the Payment Intent that will be refunded to the customer
+                */
+            amount: string;
+            /**
+                * When the refund is expected to arrive in the destination
+                */
+            arrival: string;
+            /**
+                * The ISO 8601 datetime at which the Refund was created
+                */
+            created_at: string;
+            /**
+                * The currency of the amount, as an ISO 4217 currency code.
+                * It will always match the currency of the Payment Intent.
+                */
+            currency: string;
+            /**
+                * Where the Refund amount will be sent to
+                */
+            destination: 'original_form_of_payment';
+            /**
+                * Duffel's unique identifier for the Refund
+                */
+            id: string;
+            /**
+                * Whether the Refund was created in live mode. This field will be set to true if the Refund was created in live mode, or false if it was created in test mode.
+                */
+            live_mode: boolean;
+            /**
+                * The amount deducted from your Balance to cover the Refund amount
+                */
+            net_amount: string;
+            /**
+                * The currency of the net_amount, as an ISO 4217 currency code.
+                * This currency will match your Balance currency.
+                */
+            net_currency: string;
+            /**
+                * Duffel's unique identifier for the Payment Intent that the Refund is for
+                */
+            payment_intent_id: string;
+            /**
+                * The status of the Refund.
+                * Succeeded: The refund is on its way to the destination.
+                * Pending: The Refund could not be processed immediately, and is pending processing.
+                * Failed: A refund can fail if the customer’s bank or card issuer has been unable to process it correctly (e.g., a closed bank account or a problem with the card). The bank returns the refunded amount to us and we add it back to your Balance. This process can take up to 30 days from the post date.
+                */
+            status: 'succeeded' | 'pending' | 'failed';
+            /**
+                * The ISO 8601 datetime at which the Refund was updated
+                */
+            updated_at: string;
+    }
+    export interface CreateRefund {
+            /**
+                * This amount that will be refunded to the customer's card.
+                */
+            amount: string;
+            /**
+                * The currency of the amount, as an ISO 4217 currency code.
+                * It must match the Payment Intent currency.
+                */
+            currency: string;
+            /**
+                * Duffel's unique identifier for the Payment Intent that the Refund is for
+                */
+            payment_intent_id: string;
+    }
+}
+
+declare module '@duffel/api/Links/Sessions/Sessions' {
+    import { Client } from 'Client';
+    import { Resource } from '@duffel/api/Resource';
+    import { DuffelResponse } from '@duffel/api/types';
+    interface SessionParameters {
+            /**
+                * A tracking reference for the booking that may be created within this Duffel Links session
+                */
+            reference: string;
+            /**
+                * A url to return to when a flight is booked via Duffel Links
+                */
+            success_url: string;
+            /**
+                * A url to return to when there is an error within Duffel Links
+                */
+            failure_url: string;
+            /**
+                * A url to return to when the user exits Duffel Links before booking
+                */
+            abandonment_url: string;
+            /**
+                * A primary color to show within Duffel Links
+                */
+            primary_color?: string;
+            /**
+                * A url of the logo to show within Duffel Links
+                */
+            logo_url?: string;
+            /**
+                * A markup amount to be added to the flights shown within Duffel Links
+                */
+            markup_amount?: number;
+            /**
+                * A markup amount to be added to the flights shown within Duffel Links
+                */
+            markup_currency?: string;
+            /**
+                * A markup percentage to be added to the flights shown within Duffel Links
+                */
+            markup_rate?: number;
+            /**
+                * A text to be shown on the checkout page within Duffel Links
+                */
+            checkout_display_text?: string;
+    }
+    interface Session {
+            /**
+                * The Duffel Links url that contains the specified configuration
+                */
+            url: string;
+    }
+    export class Sessions extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(client: Client);
+            /**
+                * Create a Duffel Links Session per the configuration
+                */
+            create: (data: SessionParameters) => Promise<DuffelResponse<Session>>;
+    }
+    export {};
+}
+
+declare module '@duffel/api/notifications/Webhooks/Webhooks' {
+    import { DuffelResponse, PaginationMeta, Webhooks as WebhooksType, WebhooksCreateParams, WebhooksCreateResponse, WebhooksListDeliveriesParams, WebhooksListDeliveriesResponse, WebhooksListResponse, WebhooksUpdateParams } from '@duffel/api/types';
+    import { Resource } from '@duffel/api/Resource';
+    import { Client } from 'Client';
+    export class Webhooks extends Resource {
+            /**
+                * Endpoint path
+                */
+            path: string;
+            constructor(client: Client);
+            /**
+                * Trigger a re-delivery of an event to a webhook.
+                * @param {string} id - Duffel's unique identifier for the webhook event
+                * @link https://duffel.com/docs/api/v1/webhooks/schema#webhooks-retry-delivering-a-webhook-event-url-parameters-id
+                */
+            redeliver: (id: string) => Promise<DuffelResponse<unknown>>;
+            /**
+                * Send a ping, a "fake event" notification, to a webhook.
+                * @param {string} id - Duffel's unique identifier for the webhook receiver
+                */
+            ping: (id: string) => Promise<DuffelResponse<unknown>>;
+            /**
+                * Retrieves a webhook event by its ID.
+                * @param {string} id- Duffel's unique identifier for the webhook event
+                */
+            get: (id: string) => Promise<DuffelResponse<WebhooksType>>;
+            /**
+                * Retrieve a paginated list of webhook deliveries
+                * @param {Object.<WebhooksListDeliveriesParams>} params - Endpoint options
+                */
+            listDeliveries: ({ ...params }: WebhooksListDeliveriesParams) => Promise<DuffelResponse<WebhooksListDeliveriesResponse[]>>;
+            /**
+                * Delete a webhook
+                * @param {string} id - Duffel's unique identifier for the webhook receiver
+                */
+            delete: (id: string) => Promise<DuffelResponse<any>>;
+            /**
+                * Update a webhook
+                * @param {string} id - Duffel's unique identifier for the webhook receiver
+                */
+            update: (id: string, { active, events, url }: WebhooksUpdateParams) => Promise<DuffelResponse<any>>;
+            /**
+                * Retrieve a paginated list of webhook
+                * @param {Object.<PaginationMeta>} params - Endpoint options
+                */
+            list: ({ ...params }: PaginationMeta) => Promise<DuffelResponse<WebhooksListResponse[]>>;
+            /**
+                * Create a webhook
+                * @param {Object.<WebhooksCreateParams>} params - Endpoint options
+                */
+            create: ({ events, url, }: WebhooksCreateParams) => Promise<DuffelResponse<WebhooksCreateResponse>>;
+    }
+}
+
+declare module '@duffel/api/booking/PartialOfferRequests/PartialOfferRequestTypes' {
+    export interface SelectedPartialOffersParams {
+        /**
+          * Whether to filter orders that are awaiting payment or not. If not specified, all orders regardless of their payment state will be returned.
+          */
+        'selected_partial_offer[]'?: string[];
+    }
+}
+