export declare interface AddPaymentCardParams extends ClientNonceParams {
    nonce: string;
}

export declare interface Address {
    display_address: string;
    position?: LatLng;
    place_id: string;
    poi_type?: 'NOT_SET_POI_TYPE' | CommonPoiType;
    timezone?: string;
}

export declare interface Agent {
    user_id?: string;
    user_name?: string;
    organisation_id?: string;
    organisation_name?: string;
}

export declare type Api = {
    locationService: LocationService;
    poiService: PoiService;
    quotesService: QuotesService;
    quotesV2Service: QuotesV2Service;
    tripService: TripService;
    fareService: FareService;
    loyaltyService: LoyaltyService;
    paymentService: PaymentService;
    flagsService: FlagsService;
    userService: UserService;
    authService: AuthService;
};

export declare type ApiError = {
    code?: string;
    message: string;
};

export declare type ApiOptions = Partial<{
    url: string;
    defaultRequestOptionsGetter: DefaultRequestOptionsGetter;
    authServiceDefaultOptionsGetter: DefaultRequestOptionsGetter;
    responseMiddleware: HttpResponseMiddleware;
    correlationIdPrefix: string;
}>;

export declare class AuthService {
    private url;
    private http;
    constructor(http: Http);
    login(params: LoginParams): Promise<HttpResponse<LoginResponse, ApiError>>;
    refreshToken(params: RefreshTokenParams): Promise<HttpResponse<RefreshTokenResponse, ApiError>>;
}

export declare type BookATripParams = {
    meta?: object;
    quote_id: string;
    passengers: Passengers;
    partner_trip_id?: string;
    flight_number?: string;
    train_number?: string;
    cost_center_reference?: string;
    payment_nonce: string;
    train_time?: string;
    loyalty_programme?: string;
    loyalty_points?: number;
};

export declare interface BookATripResponse {
    id: string;
    passengers?: Passengers;
    partner_traveller_id?: string;
    status: TripStatuses;
    state_details?: StateDetails;
    origin: Address;
    destination: Address;
    date_scheduled?: string;
    quote: Quote;
    fare?: BookingFare;
    external_trip_id?: string;
    display_trip_id?: string;
    fleet_info?: FleetInfo;
    vehicle?: Vehicle;
    partner_trip_id?: string;
    comments?: string;
    flight_number?: string;
    train_number?: string;
    date_booked?: string;
    meeting_point: MeetingPoint;
    agent?: Agent;
    cost_center_reference?: string;
    cancelled_by?: CancelledBy;
    follow_code?: string;
    meta?: Record<string, string>;
    train_time?: string;
    service_level_agreements?: ServiceLevelAgreements;
}

export declare type BookATripWithoutNonceParams = {
    quote_id: string;
    passengers: Passengers;
    meta?: object;
    partner_trip_id?: string;
    comments?: string;
    flight_number?: string;
    train_number?: string;
    cost_center_reference?: string;
    train_time?: string;
};

export declare interface BookingFare {
    total: number;
    currency: string;
    gratuity_percent?: number;
    breakdown?: Breakdown[];
}

export declare interface Breakdown {
    value: number;
    name: string;
    description?: string;
}

export declare type BurnPointsCalcParams = {
    amount: number;
    currency: string;
};

export declare type BurnPointsCalcResponse = {
    points: number;
};

export declare type CancellationParams = {
    reason: string;
    explanation?: string;
};

export declare interface CancelledBy {
    first_name?: string;
    last_name?: string;
    id?: string;
    email?: string;
}

export declare type ClientId = string;

export declare type ClientNonceParams = {
    organisation_id: string;
};

export declare type ClientNonceResponse = {
    nonce?: string;
    last_four?: string;
    card_type?: string;
};

export declare type CommonDetailsType = keyof typeof PlaceDetailTypes;

export declare type CommonPoiType = keyof typeof PoiTypes;

export declare type CreateTokenParams = {
    organisation_id: string;
    currency: string;
};

export declare type CreateTokenResponse = {
    token?: string;
};

export declare type DefaultRequestOptions = Omit<RequestOptions, 'body' | 'method' | 'signal'>;

export declare type DefaultRequestOptionsGetter = () => DefaultRequestOptions | Promise<DefaultRequestOptions>;

declare interface Direction {
    kph: number;
    heading: number;
}

export declare interface Driver {
    first_name: string;
    last_name: string;
    phone_number: string;
    photo_url?: string;
    license_number?: string;
}

export declare type EarnPointsCalcParams = {
    total_amount: number;
    burn_points?: number;
    currency: string;
};

export declare type EarnPointsCalcResponse = {
    points: number;
};

export declare const errorCodes: {
    ERR_UNKNOWN: string;
    ERR_OFFLINE: string;
    K0001: string;
    K0002: string;
    K0003: string;
    K0004: string;
    K0005: string;
    K0006: string;
    K0007: string;
    K1001: string;
    K1002: string;
    K1003: string;
    K1004: string;
    K1005: string;
    K1006: string;
    K2001: string;
    K3001: string;
    K3002: string;
    K3003: string;
    K4001: string;
    K4002: string;
    K4003: string;
    K4004: string;
    K4005: string;
    K4006: string;
    K4007: string;
    K4008: string;
    K4009: string;
    K4010: string;
    K4011: string;
    K4012: string;
    K4013: string;
    K4020: string;
    K5001: string;
    K5002: string;
    K5003: string;
    K5004: string;
    K6001: string;
    K7001: string;
    K7002: string;
    K7003: string;
    K7004: string;
    K7005: string;
    KP001: string;
    KP002: string;
    KP003: string;
    KP004: string;
    KP005: string;
    P0002: string;
    Q0001: string;
    Q0002: string;
    Q0006: string;
    Q0007: string;
    Q0008: string;
};

export declare interface Fare {
    status(id: string): Promise<HttpResponse<FinalFareResponse>>;
}

export declare type FareBreakdown = {
    base: FareBreakdownItem;
    commission?: FareBreakdownItem;
    extras?: FareBreakdownItem[];
    expenses?: FareBreakdownItem[];
    total: number;
    currency: string;
};

export declare type FareBreakdownItem = {
    tax_percentage: number;
    discount_percentage?: number;
    commission_percentage?: number;
    tax_amount: number;
    list_price: number;
    net_price: number;
};

export declare class FareService implements Fare {
    private url;
    private http;
    constructor(http: Http);
    status(tripId: string): Promise<HttpResponse<FinalFareResponse, ApiError>>;
}

export declare type FinalFareResponse = {
    state: keyof typeof FinalFareStatuses;
    expected_final_time?: string;
    expected_in?: number;
    breakdown?: FareBreakdown;
};

export declare enum FinalFareStatuses {
    PENDING = "PENDING",
    FINAL = "FINAL",
    CANCELLED = "CANCELLED",
    FAILED = "FAILED"
}

export declare type FlagsRequestPathParameters = {
    identifier: string;
    platform: string;
};

export declare type FlagsResponse = {
    identifier: string;
    version: string;
    flags: v1FlagsType;
};

export declare class FlagsService {
    private url;
    private http;
    constructor(http: Http);
    getByVersion(params: FlagsRequestPathParameters, query?: FlagsVersionType): Promise<HttpResponse<FlagsResponse, ApiError>>;
    getLatestVersion(params: FlagsRequestPathParameters): Promise<HttpResponse<FlagsResponse, ApiError>>;
    getCurrentVersion(params: FlagsRequestPathParameters): Promise<HttpResponse<FlagsVersionType, ApiError>>;
}

export declare type FlagsVersionType = {
    version: string;
};

export declare interface FleetInfo {
    fleet_id?: string;
    name?: string;
    logo_url?: string;
    description?: string;
    phone_number?: string;
    terms_conditions_url?: string;
    email?: string;
}

export declare interface FreeCancellation {
    type: string;
    minutes: number;
}

export declare interface FreeWaitingTime {
    minutes: number;
}

export declare function getApi(apiOptions?: ApiOptions): Api;

export declare type GetCurrentUserResponse = {
    user_id?: string;
    email?: string;
    first_name?: string;
    last_name?: string;
    phone_number?: string;
    locale?: string;
    primary_organisation_id?: string;
    organisations?: UserOrganisation[];
    avatar_url?: string;
};

export declare type GetOrganisationConfigurationResponse = {
    id?: string;
    name?: string;
    salesforce_id?: string;
    client_config?: string;
    config?: {
        send_sms_trip_updates?: boolean;
        send_custom_comment_to_fleets?: string;
        payment_by_invoice?: boolean;
    };
    fleet_name_overrides?: object;
};

export declare type GetTripCancelFeeResponse = {
    cancellation_fee: boolean;
    fee?: {
        currency: string;
        type: string;
        value: number;
    };
};

export declare type GetTripPositionResponse = {
    position?: LatLng;
    direction?: {
        kph: number;
        heading: number;
    };
    origin_eta?: number;
    destination_eta?: number;
};

export declare type GetTripStatusResponse = {
    status: TripStatus;
    position?: LatLng;
    timestamp?: string;
};

export declare interface Http {
    get<T>(url: string, query?: Query, options?: MethodRequestOptions): Promise<HttpResponse<T>>;
    post<T>(url: string, body: object, options?: MethodRequestOptions, query?: Query): Promise<HttpResponse<T>>;
    put<T>(url: string, body: object, options?: MethodRequestOptions): Promise<HttpResponse<T>>;
    remove<T>(url: string, options?: MethodRequestOptions): Promise<HttpResponse<T>>;
    patch<T>(url: string, body: object, options?: MethodRequestOptions): Promise<HttpResponse<T>>;
}

export declare type HttpResponse<T, TError = ApiError> = HttpResponseOk<T> | HttpResponseError<TError>;

export declare type HttpResponseError<T> = HttpResponsePayload & {
    ok: false;
    error: T;
};

export declare type HttpResponseMiddleware = <T>(response: HttpResponse<T>, requestInfo: MiddlewareRequestInfo) => HttpResponse<T> | Promise<HttpResponse<T>>;

export declare type HttpResponseOk<T> = HttpResponsePayload & {
    ok: true;
    body: T;
};

declare type HttpResponsePayload = {
    status: number;
    headers: Headers;
};

export declare class HttpService implements Http {
    private url;
    private getDefaultRequestOptions;
    private correlationIdPrefix;
    private responseMiddleware;
    constructor(url: string);
    setDefaultRequestOptionsGetter(getter: DefaultRequestOptionsGetter): this;
    setCorrelationIdPrefix(prefix: string): this;
    setResponseMiddleware(middleware: HttpResponseMiddleware): this;
    get<T>(url: string, query?: Query, options?: MethodRequestOptions): Promise<HttpResponse<T>>;
    post<T>(url: string, body: object, options?: MethodRequestOptions, query?: Query): Promise<HttpResponse<T>>;
    put<T>(url: string, body: object, options?: MethodRequestOptions): Promise<HttpResponse<T>>;
    remove<T>(url: string, options?: MethodRequestOptions): Promise<HttpResponse<T>>;
    patch<T>(url: string, body: object, options?: MethodRequestOptions): Promise<HttpResponse<T>>;
    private request;
    private createFullUrl;
}

export declare type LatLng = {
    latitude: number | string;
    longitude: number | string;
};

export declare type LocationAddressAutocompleteParams = {
    query: string;
    position?: LatLng;
    radius?: number;
    sessionToken?: string;
};

export declare type LocationAddressAutocompleteResponse = {
    locations: LocationAddressAutocompleteResponseItem[];
};

export declare type LocationAddressAutocompleteResponseItem = {
    place_id: string;
    display_address: string;
    type?: LocationDetailsType;
};

export declare type LocationAddressDetailsParameters = {
    placeId: string;
    sessionToken?: string;
};

export declare type LocationAddressDetailsResponse = {
    place_id: string;
    address?: {
        display_address: string;
        line_1: string;
        line_2?: string;
        building_number?: string;
        street_name?: string;
        city: string;
        postal_code?: string;
        postal_code_ext?: string;
        region?: string;
        country_code?: string;
    };
    position?: LatLng;
    poi_type?: LocationPoiType;
    time_zone?: string;
    current_local_time?: string;
    details?: {
        iata?: string;
        terminal?: string;
        type?: LocationDetailsType;
    };
    meeting_point?: {
        position: LatLng;
        instructions?: string;
        type: 'NOT_SET' | MeetingPointType;
    };
};

export declare type LocationDetailsType = 'NOT_SET_DETAILS_TYPE' | CommonDetailsType;

export declare type LocationPoiType = 'NOT_SET_POI_TYPE' | CommonPoiType;

export declare interface Locations {
    getAddressDetails(params: LocationAddressDetailsParameters): Promise<HttpResponse<LocationAddressDetailsResponse>>;
    getAddressAutocompleteData(params: LocationAddressAutocompleteParams): Promise<HttpResponse<LocationAddressAutocompleteResponse>>;
    getReverseGeocode(params: LatLng): Promise<HttpResponse<LocationAddressDetailsResponse>>;
}

export declare class LocationService implements Locations {
    private url;
    private http;
    constructor(http: Http);
    /** @deprecated use getReverseGeocode method instead */
    getAddressDetails({ placeId, sessionToken }: LocationAddressDetailsParameters): Promise<HttpResponse<LocationAddressDetailsResponse, ApiError>>;
    getReverseGeocode({ latitude, longitude }: LatLng): Promise<HttpResponse<LocationAddressDetailsResponse, ApiError>>;
    getAddressAutocompleteData(data: LocationAddressAutocompleteParams): Promise<HttpResponse<LocationAddressAutocompleteResponse, ApiError>>;
}

export declare type LoginParams = {
    username: string;
    password: string;
};

export declare type LoginResponse = {
    access_token: string;
    expires_in: number;
    refresh_token?: string;
};

export declare interface Loyalty {
    getStatus(clientId: ClientId): Promise<HttpResponse<LoyaltyStatusResponse>>;
    convertMoneyToPoints(clientId: ClientId, params: BurnPointsCalcParams): Promise<HttpResponse<BurnPointsCalcResponse>>;
    calculatePointsToEarn(clientId: ClientId, params: EarnPointsCalcParams): Promise<HttpResponse<EarnPointsCalcResponse>>;
    preAuth(clientId: ClientId, params: PreAuthParams): Promise<HttpResponse<PreAuthResponse>>;
}

export declare type LoyaltyProgram = {
    id?: string;
    name?: string;
};

declare class LoyaltyService implements Loyalty {
    private http;
    constructor(http: Http);
    private createUrl;
    getStatus(clientId: ClientId): Promise<HttpResponse<LoyaltyStatusResponse, ApiError>>;
    convertMoneyToPoints(clientId: ClientId, params: BurnPointsCalcParams): Promise<HttpResponse<BurnPointsCalcResponse, ApiError>>;
    calculatePointsToEarn(clientId: ClientId, params: EarnPointsCalcParams): Promise<HttpResponse<EarnPointsCalcResponse, ApiError>>;
    preAuth(clientId: ClientId, params: PreAuthParams): Promise<HttpResponse<PreAuthResponse, ApiError>>;
}

export declare type LoyaltyStatusResponse = {
    balance?: number;
    can_burn: boolean;
    can_earn: boolean;
};

export declare interface Luggage {
    total: number;
}

export declare interface MeetingPoint {
    position: LatLng;
    type: 'NOT_SET' | MeetingPointType;
    instructions?: string;
    note?: string;
}

export declare type MeetingPointType = keyof typeof MeetingPointTypes;

export declare enum MeetingPointTypes {
    DEFAULT = "DEFAULT",
    PICK_UP = "PICK_UP",
    DROP_OFF = "DROP_OFF",
    MEET_AND_GREET = "MEET_AND_GREET",
    CURB_SIDE = "CURB_SIDE",
    STAND_BY = "STAND_BY"
}

export declare type MethodRequestOptions = Omit<RequestOptions, 'body' | 'method'>;

export declare type MiddlewareRequestInfo = {
    url: string;
    timestamp: string;
    options: Omit<RequestOptions, 'headers'> & {
        headers: Headers;
    };
};

export declare type OrderOptions = 'id' | 'date' | 'booking_date' | 'reference' | 'name' | 'surname' | 'vehicle' | 'state' | 'fleet' | 'origin' | 'destination' | '-id' | '-date' | '-booking_date' | '-reference' | '-name' | '-surname' | '-vehicle' | '-state' | '-fleet' | '-origin' | '-destination';

export declare interface PassengerDetails {
    first_name?: string;
    last_name: string;
    email?: string;
    phone_number: string;
    locale?: string;
}

export declare interface Passengers {
    additional_passengers?: number;
    passenger_details: PassengerDetails[];
    luggage?: Luggage;
}

export declare interface Payment {
    createClientToken(params: CreateTokenParams): Promise<HttpResponse<CreateTokenResponse>>;
    getClientNonce(params: ClientNonceParams): Promise<HttpResponse<ClientNonceResponse>>;
    addPaymentCard(params: AddPaymentCardParams): Promise<HttpResponse<ClientNonceResponse>>;
    createBraintreeClientToken(params: CreateTokenParams): Promise<HttpResponse<CreateTokenResponse>>;
    getBraintreeClientNonce(params: ClientNonceParams): Promise<HttpResponse<ClientNonceResponse>>;
    addBraintreePaymentCard(params: AddPaymentCardParams): Promise<HttpResponse<ClientNonceResponse>>;
    getPaymentProvider(): Promise<HttpResponse<PaymentProvidersResponse>>;
}

export declare type PaymentProvidersResponse = {
    provider?: Provider;
    loyalty_programme?: LoyaltyProgram;
};

declare class PaymentService implements Payment {
    private url;
    private apiV2;
    private apiV3;
    private http;
    constructor(http: Http);
    /** @deprecated use createBraintreeClientToken instead */
    createClientToken(params: CreateTokenParams): Promise<HttpResponse<CreateTokenResponse, ApiError>>;
    /** @deprecated use getBraintreeClientNonce instead */
    getClientNonce(params: ClientNonceParams): Promise<HttpResponse<ClientNonceResponse, ApiError>>;
    /** @deprecated use addBraintreePaymentCard instead */
    addPaymentCard(params: AddPaymentCardParams): Promise<HttpResponse<ClientNonceResponse, ApiError>>;
    createBraintreeClientToken(params: CreateTokenParams): Promise<HttpResponse<CreateTokenResponse, ApiError>>;
    getBraintreeClientNonce(params: ClientNonceParams): Promise<HttpResponse<ClientNonceResponse, ApiError>>;
    addBraintreePaymentCard(params: AddPaymentCardParams): Promise<HttpResponse<ClientNonceResponse, ApiError>>;
    getPaymentProvider(): Promise<HttpResponse<PaymentProvidersResponse, ApiError>>;
}

export declare enum PlaceDetailTypes {
    AIRPORT = "AIRPORT",
    TRAIN_STATION = "TRAIN_STATION",
    METRO_STATION = "METRO_STATION",
    PORT = "PORT",
    HOTEL = "HOTEL",
    OTHER = "OTHER"
}

declare type POIDetailsType = 'UNSPECIFIED' | CommonDetailsType;

export declare type PoiResponse = {
    id?: string;
    address: {
        building_number?: string;
        city?: string;
        country_code?: string;
        display_address: string;
        line_1?: string;
        line_2?: string;
        postal_code?: string;
        postal_code_ext?: string;
        region?: string;
        street_name?: string;
    };
    description?: string;
    details: {
        dispatch_id?: string;
        external_id?: string;
        fleet_id?: string;
        iata?: string;
        terminal?: string;
        type?: POIDetailsType;
    };
    geojson: string;
    is_valid?: boolean;
    meeting_points: {
        id?: string;
        instructions?: string;
        position: LatLng;
        type: MeetingPointType;
    }[];
    name: string;
    position: LatLng;
    search_keys?: string[];
    type?: POIType;
};

export declare type PoiSearchParams = {
    paginationRowCount: number;
    paginationOffset: number;
    searchTerm?: string;
    searchKey?: string;
};

export declare type PoiSearchResponse = {
    pois?: PoiResponse[];
};

export declare class PoiService {
    private url;
    private http;
    constructor(http: Http);
    search(params: PoiSearchParams): Promise<HttpResponse<PoiSearchResponse, ApiError>>;
}

declare type POIType = 'UNSET' | CommonPoiType;

export declare enum PoiTypes {
    ENRICHED = "ENRICHED",
    REGULATED = "REGULATED",
    NEAREST = "NEAREST"
}

export declare type PreAuthParams = {
    currency: string;
    points: number;
    flexpay: boolean;
    loyalty_membership?: string;
};

export declare type PreAuthResponse = {
    nonce: string;
};

export declare type Provider = {
    id: ProviderId;
};

export declare type ProviderId = 'Braintree';

export declare type Query = Record<string, string | number>;

export declare type Quote = {
    type?: 'QUOTE_TYPE_NOT_SET' | QuotePriceType;
    total: number;
    currency: string;
    gratuity_percent?: number;
    /** @depricated */
    breakdown?: Breakdown[];
    vehicle_class?: string;
    qta_high_minutes?: number;
    qta_low_minutes?: number;
    vehicle_attributes?: VehicleAttributes;
    source?: QuoteSource;
    high_price?: number;
    low_price?: number;
};

export declare type QuoteCoverageParams = LatLng & {
    localTimeOfPickup?: string;
};

export declare type QuoteItem = {
    quote_id: string;
    fleet_id?: string;
    fleet_description?: string;
    availability_id?: string;
    fleet_name: string;
    phone_number?: string;
    pick_up_type?: QuotePickUpType;
    supplier_logo_url?: string;
    vehicle_class?: string;
    quote_type: QuotePriceType;
    high_price?: number;
    low_price?: number;
    currency_code?: string;
    qta_high_minutes?: number;
    qta_low_minutes?: number;
    terms_conditions_url?: string;
    category_name?: string;
    vehicle_attributes?: VehicleAttributes;
    source?: QuoteSource;
    validity?: number;
};

export declare interface QuoteLocationParams extends LatLng {
    displayAddress?: string;
}

export declare type QuotePickUpType = keyof typeof QuotePickUpTypes;

export declare enum QuotePickUpTypes {
    DEFAULT = "DEFAULT",
    STAND_BY = "STAND_BY",
    CURB_SIDE = "CURB_SIDE",
    MEET_AND_GREET = "MEET_AND_GREET"
}

export declare type QuotePrice = {
    currency_code?: string;
    high?: number;
    low?: number;
    net?: {
        high?: number;
        low?: number;
    };
};

export declare type QuotePriceType = keyof typeof QuotePriceTypes;

export declare enum QuotePriceTypes {
    FIXED = "FIXED",
    ESTIMATED = "ESTIMATED",
    METERED = "METERED"
}

export declare type QuoteResponseStatuse = keyof typeof QuoteResponseStatuses;

export declare enum QuoteResponseStatuses {
    PROGRESSING = "PROGRESSING",
    COMPLETED = "COMPLETED"
}

export declare interface Quotes {
    checkAvailability(params: QuotesAvailabilityParams): Promise<HttpResponse<QuotesAvailabilityResponse>>;
    quotesSearch(params: QuotesSearchParams): Promise<HttpResponse<QuotesResponse>>;
    quotesSearchById(id: string, locale?: string): Promise<HttpResponse<QuotesByIdResponse>>;
}

export declare type QuotesAvailabilityParams = {
    originPlaceId: string;
    destinationPlaceId?: string;
    dateRequired?: string;
};

export declare type QuotesAvailabilityResponse = {
    availabilities?: {
        availability_id?: string;
        fleet_id?: string;
        vehicle_class?: string;
        supplier_name?: string;
        logo_url?: string;
        description?: string;
        phone_number?: string;
        rating?: number;
        terms_conditions_url?: string;
        category_name?: string;
        integrated_fleet?: boolean;
    }[];
    categories?: string[];
};

export declare interface QuotesByIdResponse extends QuotesResponse {
    quote_items: QuoteItem[];
}

export declare type QuoteSource = keyof typeof QuoteSources;

export declare enum QuoteSources {
    FLEET = "FLEET",
    MARKET = "MARKET"
}

export declare type QuotesResponse = {
    id: string;
    status: QuoteResponseStatuse;
    quote_items?: QuoteItem[];
    validity?: number;
};

export declare type QuotesSearchParams = {
    originPlaceId: string;
    destinationPlaceId: string;
    localTimeOfPickup?: string;
};

/** @deprecated use QuotesV2Service instead */
export declare class QuotesService implements Quotes {
    private url;
    private http;
    constructor(http: Http);
    checkAvailability(params: QuotesAvailabilityParams): Promise<HttpResponse<QuotesAvailabilityResponse, ApiError>>;
    quotesSearch(params: QuotesSearchParams): Promise<HttpResponse<QuotesResponse, ApiError>>;
    quotesSearchById(id: string, locale?: string): Promise<HttpResponse<QuotesByIdResponse, ApiError>>;
}

export declare interface QuotesV2 {
    checkCoverage(params: QuoteCoverageParams): Promise<HttpResponse<QuotesV2CoverageResponse>>;
    quotesSearch(params: QuotesV2SearchParams): Promise<HttpResponse<QuotesV2Response>>;
    quotesSearchById(id: string, locale?: string): Promise<HttpResponse<QuotesV2ByIdResponse>>;
}

export declare interface QuotesV2ByIdResponse extends QuotesV2Response {
    quotes: QuoteV2Item[];
}

export declare type QuotesV2CoverageResponse = {
    coverage: boolean;
};

export declare type QuotesV2Fleet = {
    id: string;
    name: string;
    description?: string;
    rating?: QuotesV2FleetRating;
    logo_url?: string;
    terms_conditions_url?: string;
    phone_number?: string;
    capabilities?: string[];
};

export declare type QuotesV2FleetRating = {
    count?: number;
    score?: number;
};

export declare type QuotesV2Response = {
    id: string;
    status: QuoteResponseStatuse;
    quotes: QuoteV2Item[];
    availability: {
        vehicles?: {
            classes?: string[];
        };
    };
    validity?: number;
};

export declare type QuotesV2SearchParams = {
    origin: QuoteLocationParams;
    destination?: QuoteLocationParams;
    localTimeOfPickup?: string;
};

export declare class QuotesV2Service implements QuotesV2 {
    private url;
    private http;
    constructor(http: Http);
    private formatPickUpTime;
    private isValidPickupTime;
    private rejectWithWrongTimeFormat;
    quotesSearch(params: QuotesV2SearchParams): Promise<HttpResponse<QuotesV2Response, ApiError>>;
    checkCoverage(params: QuoteCoverageParams): Promise<HttpResponse<QuotesV2CoverageResponse, ApiError>>;
    quotesSearchById(id: string, locale?: string): Promise<HttpResponse<QuotesV2ByIdResponse, ApiError>>;
}

export declare type QuotesV2Vehicle = {
    qta?: {
        high_minutes: number;
        low_minutes: number;
    };
    class: string;
    passenger_capacity?: number;
    luggage_capacity?: number;
    vehicle_list?: string[];
    image?: string;
    tags: string[];
    type: string;
};

export declare type QuoteV2Item = {
    id: string;
    price: QuotePrice;
    pick_up_type?: QuotePickUpType;
    quote_type: QuotePriceType;
    source?: QuoteSource;
    fleet: QuotesV2Fleet;
    vehicle?: QuotesV2Vehicle;
    service_level_agreements?: ServiceLevelAgreements;
};

export declare type RefreshTokenParams = {
    refresh_token: string;
};

export declare type RefreshTokenResponse = {
    access_token: string;
    expires_in: number;
};

export declare type RequestOptions = Omit<RequestInit, 'window' | 'headers'> & {
    method: string;
    headers?: Record<string, string>;
};

export declare type ResetPasswordParams = {
    email: string;
};

export declare type SearchParams = {
    trip_states?: TripStatus[];
    trip_type?: 'BOTH' | 'PREBOOK' | 'ASAP';
    created_after?: string;
    email?: string;
    traveller_id?: string;
    prebook_time_after?: string;
    prebook_time_before?: string;
    trip_time_before?: string;
    trip_time_after?: string;
    only_without_final_price?: boolean;
    pagination_offset?: number;
    pagination_row_count?: number;
    fleet_id?: string;
    partner_trip_id?: string;
    external_trip_id?: string;
    forename?: string;
    lastname?: string;
    display_trip_id?: string;
    order_by?: OrderOptions[];
};

export declare type SearchResponse = {
    bookings?: BookATripResponse[];
};

export declare type ServiceLevelAgreements = {
    free_cancellation: {
        type: string;
        minutes: number;
    };
    free_waiting_time: {
        minutes: number;
    };
};

export declare enum StateDetails {
    REQUESTED_BY_USER = "REQUESTED_BY_USER",
    PASSENGER_DIDNT_SHOW_UP = "PASSENGER_DIDNT_SHOW_UP",
    DRIVER_CANCELED = "DRIVER_CANCELED",
    SUPPLIER_CANCELLED = "SUPPLIER_CANCELLED",
    DISPATCH_CANCELLED = "DISPATCH_CANCELLED",
    NO_AVAILABILITY_IN_THE_AREA = "NO_AVAILABILITY_IN_THE_AREA",
    NO_FEE = "NO_FEE",
    OTHER_DISPATCH_REASON = "OTHER_DISPATCH_REASON",
    DRIVER_DIDNT_SHOW_UP = "DRIVER_DIDNT_SHOW_UP",
    ETA_TOO_LONG = "ETA_TOO_LONG",
    DRIVER_IS_LATE = "DRIVER_IS_LATE",
    CAN_NOT_FIND_VEHICLE = "CAN_NOT_FIND_VEHICLE",
    NOT_NEEDED_ANYMORE = "NOT_NEEDED_ANYMORE",
    ASKED_BY_DRIVER_TO_CANCEL = "ASKED_BY_DRIVER_TO_CANCEL",
    FOUND_BETTER_PRICE = "FOUND_BETTER_PRICE",
    NOT_CLEAR_MEETING_INSTRUCTIONS = "NOT_CLEAR_MEETING_INSTRUCTIONS",
    COULD_NOT_CONTACT_CARRIER = "COULD_NOT_CONTACT_CARRIER",
    OTHER_USER_REASON = "OTHER_USER_REASON",
    FRAUD = "FRAUD",
    NO_AVAILABILITY = "NO_AVAILABILITY",
    ASKED_BY_USER = "ASKED_BY_USER",
    ASKED_BY_DISPATCH = "ASKED_BY_DISPATCH",
    ASKED_BY_DRIVER = "ASKED_BY_DRIVER",
    FAILIURE = "FAILIURE",
    PREAUTH_FAILED = "PREAUTH_FAILED",
    OTHER_KARHOO_REASON = "OTHER_KARHOO_REASON"
}

export declare interface Tracking {
    position?: LatLng;
    direction?: Direction;
    origin_eta?: number;
    destination_eta?: number;
}

export declare interface Trip {
    trackTrip(id: string): Promise<HttpResponse<TripFollowResponse>>;
    book(params: BookATripParams): Promise<HttpResponse<BookATripResponse>>;
    bookWithoutNonce(params: BookATripWithoutNonceParams): Promise<HttpResponse<BookATripResponse>>;
    getBookingDetails(id: string): Promise<HttpResponse<BookATripResponse>>;
    getTripStatus(id: string): Promise<HttpResponse<GetTripStatusResponse>>;
    getTripPosition(id: string): Promise<HttpResponse<GetTripPositionResponse>>;
    cancel(id: string, params: CancellationParams): Promise<HttpResponse<object>>;
    cancelByFollowCode(code: string, params: CancellationParams): Promise<HttpResponse<object>>;
    search(params: SearchParams): Promise<HttpResponse<SearchResponse>>;
    getCancelFee(id: string): Promise<HttpResponse<GetTripCancelFeeResponse>>;
}

export declare type TripFollowResponse = {
    origin?: Address;
    destination?: Address;
    date_booked?: string;
    date_scheduled?: string;
    status: TripStatuses;
    state_details?: StateDetails;
    vehicle?: Vehicle;
    tracking?: Tracking;
    fleet_info?: FleetInfo;
    train_number?: string;
    trip_id?: string;
    display_trip_id?: string;
    passengers?: Passengers;
    quote?: Quote;
    meeting_point?: MeetingPoint;
    meta?: Record<string, string>;
    train_time?: string;
    flight_number?: string;
    service_level_agreements?: ServiceLevelAgreements;
};

export declare class TripService implements Trip {
    private url;
    private http;
    constructor(http: Http);
    trackTrip(id: string): Promise<HttpResponse<TripFollowResponse, ApiError>>;
    book(params: BookATripParams): Promise<HttpResponse<BookATripResponse, ApiError>>;
    bookWithoutNonce(params: BookATripWithoutNonceParams): Promise<HttpResponse<BookATripResponse, ApiError>>;
    getBookingDetails(id: string): Promise<HttpResponse<BookATripResponse, ApiError>>;
    getTripStatus(id: string): Promise<HttpResponse<GetTripStatusResponse, ApiError>>;
    getTripPosition(id: string): Promise<HttpResponse<GetTripPositionResponse, ApiError>>;
    cancel(id: string, params: CancellationParams): Promise<HttpResponse<object, ApiError>>;
    cancelByFollowCode(code: string, params: CancellationParams): Promise<HttpResponse<object, ApiError>>;
    search(params: SearchParams): Promise<HttpResponse<SearchResponse, ApiError>>;
    getCancelFee(id: string): Promise<HttpResponse<GetTripCancelFeeResponse, ApiError>>;
    getCancelFeeByFollowCode(id: string): Promise<HttpResponse<GetTripCancelFeeResponse, ApiError>>;
}

export declare type TripStatus = keyof typeof TripStatuses;

export declare enum TripStatuses {
    CONFIRMED = "CONFIRMED",
    DRIVER_EN_ROUTE = "DRIVER_EN_ROUTE",
    ARRIVED = "ARRIVED",
    POB = "POB",
    COMPLETED = "COMPLETED",
    NO_DRIVERS_AVAILABLE = "NO_DRIVERS_AVAILABLE",
    DRIVER_CANCELLED = "DRIVER_CANCELLED",
    BOOKER_CANCELLED = "BOOKER_CANCELLED",
    KARHOO_CANCELLED = "KARHOO_CANCELLED",
    FAILED = "FAILED",
    PREAUTH_DECLINED = "PREAUTH_DECLINED",
    INCOMPLETE = "INCOMPLETE",
    /** @deprecated no longer in use by API, left for backward compability */
    REQUESTED = "REQUESTED"
}

declare type UserOrganisation = {
    id?: string;
    name?: string;
    roles?: string[];
};

export declare class UserService {
    private url;
    private http;
    constructor(http: Http);
    getCurrentUser(): Promise<HttpResponse<GetCurrentUserResponse, ApiError>>;
    resetPassword(params: ResetPasswordParams): Promise<HttpResponse<object, ApiError>>;
    getOrganisationConfiguration(id: string): Promise<HttpResponse<GetOrganisationConfigurationResponse, ApiError>>;
}

declare type v1FlagsType = Record<string, boolean | string>;

export declare interface Vehicle {
    type?: string;
    tags?: string[];
    vehicle_class: string;
    description?: string;
    vehicle_license_plate: string;
    driver: Driver;
    attributes?: VehicleAttributes;
}

export declare type VehicleAttributes = Partial<{
    child_seat: boolean;
    electric: boolean;
    hybrid: boolean;
    luggage_capacity: number;
    passenger_capacity: number;
}>;

export { }