skyhook-graphql-sdk/dist/codegen/API.d.ts

Node SDK for the Skyhook graphql API

export declare type Maybe<T> = T | null;
export declare type InputMaybe<T> = Maybe<T>;
export declare type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
/** All built-in and custom scalars, mapped to their actual values */
export declare type Scalars = {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
    AWSDate: string;
    AWSDateTime: string;
    AWSEmail: string;
    AWSIPAddress: string;
    AWSJSON: {
        [key: string]: any;
    };
    AWSPhone: string;
    AWSTime: string;
    AWSTimestamp: string;
    AWSURL: string;
};
export declare enum AccountingAccountName {
    ACCOUNTS_PAYABLE = "ACCOUNTS_PAYABLE",
    ACCOUNTS_RECEIVABLE = "ACCOUNTS_RECEIVABLE",
    PAYPAL_EUR = "PAYPAL_EUR",
    PAYPAL_GBP = "PAYPAL_GBP",
    PAYPAL_NOK = "PAYPAL_NOK",
    PAYPAL_USD = "PAYPAL_USD",
    STRIPE_CAD = "STRIPE_CAD",
    STRIPE_EUR = "STRIPE_EUR",
    STRIPE_GBP = "STRIPE_GBP",
    STRIPE_NOK = "STRIPE_NOK",
    STRIPE_NZD = "STRIPE_NZD",
    STRIPE_SGD = "STRIPE_SGD",
    STRIPE_USD = "STRIPE_USD",
    TMTV2_EUR = "TMTV2_EUR",
    TMTV2_GBP = "TMTV2_GBP",
    TMTV2_USD = "TMTV2_USD",
    TMT_EUR = "TMT_EUR",
    TMT_GBP = "TMT_GBP",
    TMT_USD = "TMT_USD",
    TRAVEL_AGENT_COMMISSION = "TRAVEL_AGENT_COMMISSION"
}
/**
 * Accounting Journal
 *
 * For internal use only.
 *
 * Inspired by the
 * [QuickBooks API](https://developer.intuit.com/app/developer/qbo/docs/api/accounting/all-entities/journalentry) but
 * designed to be used universally with other tools as needed.
 *
 * Also designed to work with the [Zoho Books API](https://www.zoho.com/books/api/v3/#Journals).
 */
export declare type AccountingJournal = Node & {
    /** Date the journal should be posted */
    date: Scalars['AWSDateTime'];
    /**
     * Description of journal being posted
     *
     * @example
     * Booking Space
     *
     * @example
     * Transaction
     *
     * @example
     * Cancellation
     */
    description: Scalars['String'];
    /**
     * Journal ID
     *
     * Should be the id of the booking invoice.
     *
     * @example
     * ln_UUID
     */
    id: Scalars['ID'];
    /**
     * Journal Lines
     *
     * Must contain exactly two lines.
     */
    lines: Array<AccountingJournalLine>;
};
export declare type AccountingJournalLine = {
    account: AccountingAccountName;
    currency: Currency;
    /**
     * Customer (host) ID
     *
     * @example
     * host_UUID
     */
    customer: Scalars['String'];
    /**
     * Gross Amount in ZD (i.e. cents not dollars)
     *
     * This is before any taxes, and is always positive.
     */
    grossAmountZD: Scalars['Int'];
    /**
     * Journal line ID
     *
     * Should be based on the line ID plus an integer postfix
     *
     * @example
     * ln_UUID_1
     */
    id: Scalars['ID'];
    journalType: AccountingJournalType;
    /** Tax code */
    taxCode?: Maybe<BookingCommissionTaxRate>;
    /**
     * Country within which sales tax may be due
     *
     * Should be set as the country of the host.
     */
    taxCountry?: Maybe<CountryCodes>;
};
export declare enum AccountingJournalType {
    /**
     * Credit
     *
     * A credit either increases equity, liability, or revenue accounts or decreases an asset or expense account. Record the
     * corresponding credit for the purchase of a new computer by crediting your expense account.
     */
    CREDIT = "CREDIT",
    /**
     * Debit
     *
     * A debit either increases an asset or expense account or decreases equity, liability, or revenue accounts. For example,
     *  you would debit the purchase of a new computer by entering the asset gained on the left side of your asset account.
     */
    DEBIT = "DEBIT"
}
/**
 * ActivityObject
 *
 * The Activity object represents the direct object upon which an activity was
 * performed on e.g. space for space cancellation or booking for booking created.
 */
export declare type ActivityObject = {
    id: Scalars['String'];
    name: Scalars['String'];
};
/**
 * ActivityStream
 *
 * The activity stream is based on Activity Stream Spec v2 and represents an
 * activity that has been performed on the system.
 *
 * https://www.w3.org/TR/activitystreams-vocabulary/#introduction
 */
export declare type ActivityStream = {
    /**
     * ActivityStreamActor
     *
     * Actors represent entities capable of carrying out an Activity - for example the
     * actor for a booking created activity is the person/user who made the booking.
     *
     * @example
     * {
     *   id: "user_UUID",
     *   name: "John Doe",
     * }
     *
     * https://www.w3.org/TR/activitystreams-core/#actors
     */
    actor: ActivityStreamActor;
    /**
     * A unique ID for the activity stream object. This is created by the Notification
     * service and not by the service emitting the activity.
     *
     * You can pass an activity stream object without id.
     *
     * @example
     * as_UUID
     */
    id: Scalars['String'];
    /**
     * isRead
     *
     * Indicates whether a notification has been viewed and read by the user.
     */
    isRead?: Maybe<NotificationIsRead>;
    /**
     * The Activity object represents the direct object upon which an activity was
     * performed on e.g. space for space cancellation or booking for booking created.
     *
     * @example
     * {
     *   id: "space_UUID",
     *   name: "space",
     * }
     *
     * https://www.w3.org/TR/activitystreams-vocabulary/#dfn-object
     */
    object: ActivityObject;
    /**
     * The date and time at which the object was published
     *
     * https://www.w3.org/TR/activitystreams-vocabulary/#dfn-published
     */
    published: Scalars['AWSDateTime'];
    /**
     * An optional ID to group activities together i.e. for a space cancellation you
     * can group by groupID, allowing all cancellation for a specific departure date to
     * be grouped together. This is not part of the ActivityStreams spec.
     *
     * @example
     * group_UUID
     *
     * @example
     * trip_UUID
     */
    serviceBatchID?: Maybe<Scalars['ID']>;
    /**
     * The activity target represents the indirect object of the activity e.g. for
     * space cancellation, the direct object is Space, the target is the Trip   that
     * the space was cancelled on.
     *
     * @example
     * {
     *   id: "group_UUID",
     *   name: "Trip Title, 1 Jan 2020",
     * }
     *
     * https://www.w3.org/TR/activitystreams-vocabulary/#dfn-target
     */
    target?: Maybe<ActivityStreamTarget>;
    /**
     * The id of the user or host affected by the activity (i.e the person to receive the
     * notification from this activity)
     *
     * @example
     * user_UUID
     *
     * @example
     * host_UUID
     *
     * https://www.w3.org/TR/activitystreams-vocabulary/#dfn-to
     */
    to: Scalars['String'];
    /**
     * The action that was performed
     *
     * Activity types are added in past tense so they are ready to displayed to the user without
     * need for conversion from present tense i.e. Cancelled, Received, etc
     *
     * https://www.w3.org/TR/activitystreams-vocabulary/#activity-types
     */
    type: Scalars['String'];
    /**
     * A url or link to a dashboard or web page where the user can view the activity
     * or activities or take action in relationship to the activity or set of
     * activities.
     *
     * For batched activities, this is the url to the page where the user can view
     * and taken action for the batch of activities.
     *
     * @example
     * https://www.skyhookadventure.com/hosts/dashboard/host-url/bookings/group_UUID
     *
     * https://www.w3.org/TR/activitystreams-vocabulary/#dfn-url
     */
    url: Scalars['AWSURL'];
    /**
     * A generated ID that is unique but deterministic in a certain period of time
     * for a given user, object, and activity stream type.
     *
     * NB: This is generated by the Notification service and not by the emitting
     * service.
     *
     * @example
     * cancelled-space-host_UUID-1640696400000
     *
     * @example
     * booked-space-host_UUID-1640696400000
     */
    userBatchID: Scalars['ID'];
};
/**
 * ActivityStreamPerson
 *
 * Actors represent entities capable of carrying out an Activity - for example the
 * actor for a booking created activity is the person/user who made the booking.
 */
export declare type ActivityStreamActor = {
    host?: Maybe<Host>;
    /**
     * Describes an Icon for An Actor in the activity stream i.e. Profile Picture or
     * Host Image.
     *
     * https://www.w3.org/ns/activitystreams#icon
     */
    icon?: Maybe<ActivityStreamIcon>;
    /**
     * The user id or host id of the host or guest who performed the action.
     *
     * @example
     * user_UUID
     *
     * @example
     * host_UUID
     */
    id?: Maybe<Scalars['String']>;
    /**
     * The full name of the host or the guest who performed the action.
     *
     * @example
     * John Doe
     *
     * @example
     * Skyhook Mountaineering LTD
     */
    name?: Maybe<Scalars['String']>;
    /** The role of user who performed the action within Skyhook hook i.e. Host or Guest. */
    type: ActivityStreamActorType;
    user?: Maybe<UserPublicProfile>;
};
export declare enum ActivityStreamActorType {
    GUEST = "GUEST",
    HOST = "HOST",
    SYSTEM = "SYSTEM"
}
export declare type ActivityStreamConnection = {
    items: Array<ActivityStream>;
    nextToken?: Maybe<Scalars['String']>;
};
/**
 * Describes an Icon for An Actor in the activity stream i.e. Profile Picture or
 * Host Image.
 *
 * https://www.w3.org/ns/activitystreams#icon
 */
export declare type ActivityStreamIcon = {
    height?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
    type?: Maybe<ActivityStreamIconType>;
    url: Scalars['AWSURL'];
    width?: Maybe<Scalars['Int']>;
};
export declare enum ActivityStreamIconType {
    Image = "Image"
}
/**
 * ActivityStreamTarget
 *
 * The direct object upon which an activity was performed on i.e. space or booking.
 */
export declare type ActivityStreamTarget = {
    /**
     * Web link to the target object i.e. Link to host group dashboard for
     * cancellations or host inbox link for messages.
     */
    href?: Maybe<Scalars['String']>;
    id: Scalars['String'];
    name: Scalars['String'];
};
export declare type AddUserHostRoleInput = {
    hostID: Scalars['ID'];
    role: HostRoleType;
    userID: Scalars['ID'];
};
export declare type AddUserToWaitListInput = {
    groupID: Scalars['ID'];
    spacesRequested?: InputMaybe<Scalars['Int']>;
    userID: Scalars['ID'];
};
/** Address uses the OASIS [XAL](https://www.oasis-open.org/committees/ciq/download.shtml) standard */
export declare type Address = {
    additionalNames?: Maybe<Scalars['String']>;
    addressLine1?: Maybe<Scalars['String']>;
    addressLine2?: Maybe<Scalars['String']>;
    /** State, province or county */
    administrativeArea?: Maybe<Scalars['String']>;
    coordinates?: Maybe<Coordinates>;
    country: CountryCodes;
    /** Neighborhood or suburb */
    dependentLocality?: Maybe<Scalars['String']>;
    familyName?: Maybe<Scalars['String']>;
    givenName?: Maybe<Scalars['String']>;
    /** City */
    locality?: Maybe<Scalars['String']>;
    organisation?: Maybe<Scalars['String']>;
    postalCode?: Maybe<Scalars['String']>;
    sortingCode?: Maybe<Scalars['String']>;
};
export declare type AddressInput = {
    additionalNames?: InputMaybe<Scalars['String']>;
    addressLine1?: InputMaybe<Scalars['String']>;
    addressLine2?: InputMaybe<Scalars['String']>;
    administrativeArea?: InputMaybe<Scalars['String']>;
    coordinates?: InputMaybe<CoordinatesInput>;
    country: CountryCodes;
    dependentLocality?: InputMaybe<Scalars['String']>;
    familyName?: InputMaybe<Scalars['String']>;
    givenName?: InputMaybe<Scalars['String']>;
    locality?: InputMaybe<Scalars['String']>;
    organisation?: InputMaybe<Scalars['String']>;
    postalCode?: InputMaybe<Scalars['String']>;
    sortingCode?: InputMaybe<Scalars['String']>;
};
export declare type AdminAddTransactionCardInput = {
    address: TransactionAddressInput;
    cardType: Scalars['String'];
    lastFourDigits: Scalars['String'];
};
/**
 * Admin add transaction input
 *
 * These fields mirror the database fields for the most part, so that we can quickly create transactions manually where
 * they have been taken but not stored already (e.g. duplicate transactions).
 */
export declare type AdminAddTransactionInput = {
    /**  Allocations to spaces  */
    allocation: Array<AdminAddTransactionSpaceAllocation>;
    amount: PriceInput;
    baseTransaction?: InputMaybe<RefInput>;
    booking: RefInput;
    card?: InputMaybe<AdminAddTransactionCardInput>;
    created: Scalars['AWSDateTime'];
    hostAmount?: InputMaybe<PriceInput>;
    processor: TransactionProcessor;
    /**
     * For chargebacks you may need to use the same ID for both a chargeback and the corresponding reversal (e.g. for
     * Stripe). For Legacy TMT you will want to use the remote ID of the original transaction for simplicity (as this is how
     * it appears on the statement).
     */
    remoteID: Scalars['ID'];
    remoteIDHost?: InputMaybe<Scalars['ID']>;
    /**  TMT V2 Details  */
    tmt?: InputMaybe<AdminAddTransactionTMTDetails>;
    /** Transaction type */
    type: TransactionType;
};
export declare type AdminAddTransactionSpaceAllocation = {
    /**  Guest amount (+ve for payments and -ve for transactions - we'll convert it for the invoice lines)  */
    guestAmountZD: Scalars['Int'];
    /**  Guest overpayment amount (e.g. with a duplicate transaction)  */
    guestOverpaymentZD?: InputMaybe<Scalars['Int']>;
    /**  Host amount (+ve for payments and -ve for transactions - we'll convert it for the invoice lines)  */
    hostAmountZD: Scalars['Int'];
    /**  Host overpayment amount (e.g. with a duplicate transaction)  */
    hostOverpaymentZD?: InputMaybe<Scalars['Int']>;
    /**  Space ID  */
    id: Scalars['ID'];
};
export declare type AdminAddTransactionTMTDetails = {
    affiliateChannelID?: InputMaybe<Scalars['Int']>;
    bookingID: Scalars['Int'];
    channelID: Scalars['Int'];
};
export declare type AdminDiscretionaryRefundInput = {
    bookingID: Scalars['ID'];
    spaces: Array<AdminDiscretionaryRefundSpaceInput>;
};
export declare type AdminDiscretionaryRefundPayload = {
    booking: Booking;
};
export declare type AdminDiscretionaryRefundSpaceInput = {
    /**
     * Guest Amount
     *
     * Should be given as a positive zero-decimal amount.
     */
    guestAmount: Scalars['Int'];
    /**
     * Host Amount
     *
     * Should be given as a positive zero-decimal amount.
     */
    hostAmount: Scalars['Int'];
    id: Scalars['ID'];
};
export declare type ApplyCouponValue = {
    code: Scalars['String'];
    /** The amount to be deducted from the deposit. */
    depositAmountDeduction: Price;
    /** The total discount applied */
    discountApplied: Price;
    spacesRequested: Scalars['Int'];
    /** The final amount to be deducted from total price. */
    totalAmountDeduction: Price;
};
export declare type AutomatedMessage = {
    created: Scalars['AWSDateTime'];
    /** The message to send to the guest after booking */
    message: Scalars['String'];
    updated: Scalars['AWSDateTime'];
};
export declare type BackupPasswordInput = {
    password: Scalars['String'];
};
export declare type BankDetails = {
    accountNumber: Scalars['String'];
    bankAccountName: Scalars['String'];
    bankAddress: Address;
    bankName: Scalars['String'];
    ibanNumber?: Maybe<Scalars['String']>;
    routingCode?: Maybe<Scalars['String']>;
    sortCode?: Maybe<Scalars['String']>;
    swiftCode?: Maybe<Scalars['String']>;
};
export declare type BankDetailsInput = {
    accountNumber: Scalars['String'];
    bankAccountName: Scalars['String'];
    bankAddress: AddressInput;
    bankName: Scalars['String'];
    ibanNumber?: InputMaybe<Scalars['String']>;
    routingCode?: InputMaybe<Scalars['String']>;
    sortCode?: InputMaybe<Scalars['String']>;
    swiftCode?: InputMaybe<Scalars['String']>;
};
export declare type Booking = Node & {
    /**
     * Each space has net commission and cash received. This is the total of all
     * spaces.
     */
    commissionDetails: BookingCommissionDetails;
    commissionTaxRate: BookingCommissionTaxRate;
    created: Scalars['AWSDateTime'];
    group: Group;
    host: Ref;
    id: Scalars['ID'];
    invoiceSummary: Array<BookingInvoiceSummary>;
    /**
     * All actions (transactions, cancellations, refunds, credits applied...) are shown broken down by their impact on
     * individual spaces, rather than the total booking. A single transaction can still be made to pay for several spaces -
     * the full transaction will be available from the Transaction type and then here if there are 2 spaces it will show
     * half on each space (or whatever the appropriate split was).
     */
    spaces: Array<BookingSpace>;
    /**
     * User tracking details
     *
     * Only available via IAM access (on the backend).
     */
    tracking?: Maybe<Tracking>;
    trip: Trip;
    /** The booking owner */
    user: User;
};
export declare type BookingCommissionDetails = {
    cashReceived: Price;
    commission: Price;
    commissionLessCoupons: Price;
    commissionLessCredits: Price;
    commissionRefundAmount: Price;
    /** Cash received before any refunds */
    expectedCashReceived: Price;
    netCommission: Price;
    numberOfSpacesCancelled: Scalars['Int'];
    /** Commission amount cancelled (not total amount cancelled) */
    totalAmountCancelled: Price;
};
export declare enum BookingCommissionTaxRate {
    /** European Commission zero-rated (the host is responsible for sales tax) */
    ECZERORATED = "ECZERORATED",
    /** UK 20% Vat rate */
    OUTPUT = "OUTPUT",
    /** Zero rated (e.g. for hosts where the place of supply is outside of the UK and EC) */
    ZERORATED = "ZERORATED"
}
export declare type BookingConnection = Nodes & {
    items: Array<Booking>;
    nextToken?: Maybe<Scalars['String']>;
};
export declare type BookingCreditInput = {
    amountZD: Scalars['Int'];
};
export declare type BookingDiscountInput = {
    amountZD: Scalars['Int'];
    code: Scalars['String'];
};
/**
 * Booking entity type
 *
 * For DB and Events only. Note in SentenceCase for legacy reasons.
 */
export declare enum BookingEntityType {
    Booking = "Booking",
    BookingSpace = "BookingSpace",
    BookingSpaceInvoiceLine = "BookingSpaceInvoiceLine",
    Transaction = "Transaction"
}
export declare type BookingGroupInput = {
    /** Required to validate the price shown to the customer. This is the guest unit price. */
    guestPrice: PriceInput;
    id: Scalars['ID'];
};
/**
 * Invoice lines are stored on per space basis, so a booking with 2 spaces will
 * have 2 invoice lines for each transaction. This will allow us to summarize that
 * based on the invoice lines for the purpose of showing the user a summary of the
 * invoice.
 */
export declare type BookingInvoiceSummary = {
    amount: Price;
    /**
     * If Transaction (i.e. a payment or refund) is associated with this line then
     * this will be the card details used for the transaction.
     */
    card?: Maybe<TransactionCard>;
    /**
     * The coupon code applied to this invoice for the booking invoice summary if
     * type is COUPON
     */
    couponCode?: Maybe<Scalars['String']>;
    created: Scalars['AWSDateTime'];
    /** The numberOfSpaces of spaces impacted by this invoice line */
    numberOfSpaces: Scalars['Int'];
    type: BookingSpaceInvoiceSummaryType;
};
export declare type BookingPaymentInput = {
    amount: PriceInput;
    card: TransactionCardInput;
    /**
     * TMT Booking ID
     *
     * The TMT Modal will auto-create a booking ID for each transaction.
     */
    tmtBookingID?: InputMaybe<Scalars['Int']>;
    /**
     * TMT Transaction ID
     *
     * The TMT Modal will return this in the `transaction_logged` response.
     */
    tmtTransactionID?: InputMaybe<Scalars['Int']>;
};
export declare type BookingPublicDetails = {
    created: Scalars['AWSDateTime'];
    group: Group;
    trip: Trip;
    /** The booking owner */
    user: UserPublicProfile;
};
export declare type BookingSpace = {
    /** Shows if a space is active (true) or cancelled (false) */
    active: Scalars['Boolean'];
    booking: Ref;
    /** Cancellation options will show unless the space is already cancelled */
    cancellationOptions: Array<BookingSpaceCancellationOption>;
    /**
     * Cash received by us (commission - credits - refunds)
     *
     * We don't refund deposit, so even if the guest cancels, we keep the deposit.
     * This contributes to the cash received.
     */
    cashReceived: Price;
    /** Nominal sales tax (aka VAT) applicable to the host commission */
    commissionTax: Price;
    /** Sales tax (aka VAT) rate applicable to the host commission */
    commissionTaxRate: BookingCommissionTaxRate;
    created: Scalars['AWSDateTime'];
    /**
     * The exchange rate used to convert the booking price to GBP at the time of
     * booking.
     */
    gbpExchangeRate: Scalars['String'];
    /** Commission before sales tax (aka VAT) */
    grossCommission: Price;
    /**
     * Guest
     *
     * Only exists on active spaces
     */
    guest?: Maybe<Guest>;
    guestBalance: Price;
    guestDeposit: Price;
    guestTotal: Price;
    hostBalance: Price;
    hostDeposit: Price;
    hostTotal: Price;
    id: Scalars['ID'];
    /**
     * The invoice lines show, in date order, everything that has an impact on the balance owed. The first line is always
     * the total owed, and then there can be lines for payments (-ve), credits (-ve), discounts (-ve), cancellation (-ve),
     * and refunds (+ve).
     */
    invoice: Array<BookingSpaceInvoiceLine>;
    /** Commission after sales tax (aka VAT) */
    netCommission: Price;
};
export declare type BookingSpaceCancellationOption = {
    guestCredit: Price;
    /** Guest permission to use this cancellation option (true = has permission) */
    guestPermission: Scalars['Boolean'];
    guestRefund: Price;
    hostRefund: Price;
    type: BookingSpaceCancellationType;
};
export declare enum BookingSpaceCancellationType {
    BALANCE_REFUND = "BALANCE_REFUND",
    FULL_REFUND = "FULL_REFUND",
    NO_REFUND = "NO_REFUND"
}
export declare type BookingSpaceInvoiceLine = {
    booking: Booking;
    bookingSpace: BookingSpace;
    couponCode?: Maybe<Scalars['String']>;
    created: Scalars['AWSDateTime'];
    discount?: Maybe<Ref>;
    guestAmount: PriceWithOverpayment;
    hostAmount: PriceWithOverpayment;
    id: Scalars['ID'];
    /**
     * Note
     *
     * Can be used to give the reason for e.g. a discretionary change or a cancellation.
     */
    note?: Maybe<Scalars['String']>;
    transaction?: Maybe<Transaction>;
    type: BookingSpaceInvoiceLineType;
};
export declare type BookingSpaceInvoiceLineConnection = {
    items: Array<BookingSpaceInvoiceLine>;
    nextToken?: Maybe<Scalars['String']>;
};
export declare enum BookingSpaceInvoiceLineType {
    CANCELLATION = "CANCELLATION",
    COUPON = "COUPON",
    CREDIT = "CREDIT",
    DISCOUNT = "DISCOUNT",
    /**
     * A discretionary change is anything that changes the invoice for a discretionary reason, e.g. to allow for a
     * discretionary refund.
     */
    DISCRETIONARY_CHANGE = "DISCRETIONARY_CHANGE",
    TOTAL = "TOTAL",
    TRANSACTION = "TRANSACTION"
}
export declare enum BookingSpaceInvoiceSummaryType {
    BALANCE_DUE = "BALANCE_DUE",
    BALANCE_PAYMENT = "BALANCE_PAYMENT",
    BALANCE_REFUND = "BALANCE_REFUND",
    CANCELLATION = "CANCELLATION",
    COUPON = "COUPON",
    COUPON_CANCELLED = "COUPON_CANCELLED",
    CREDIT_ISSUED = "CREDIT_ISSUED",
    CREDIT_USED = "CREDIT_USED",
    DEPOSIT_PAYMENT = "DEPOSIT_PAYMENT",
    /**
     * A discretionary change is anything that changes the invoice for a discretionary reason, e.g. to allow for a
     * discretionary refund.
     */
    DISCRETIONARY_CHANGE = "DISCRETIONARY_CHANGE",
    FULL_PAYMENT = "FULL_PAYMENT",
    TOTAL_BOOKING_VALUE = "TOTAL_BOOKING_VALUE",
    TOTAL_PAID = "TOTAL_PAID"
}
export declare type BookingUserInput = {
    id: Scalars['ID'];
};
/**
 * Bookings Query Filter
 *
 * @example
 * // Get all bookings since 2010
 * {
 *   date: "2010-01-01T00:00:00Z"
 *   comparisonOperator: ">"
 *   dateType: "CREATED"
 * }
 */
export declare type BookingsQueryFilter = {
    /**
     * Comparison Operator
     *
     * Supported options include:
     *   - > Greater than
     *   - < Less than
     *   - >= Greater than or equal to
     *   - <= Less than or equal to
     *   - = Equal to
     *   - <> Not equal to
     */
    comparisonOperator?: InputMaybe<Scalars['String']>;
    date?: InputMaybe<Scalars['AWSDateTime']>;
    dateEnd?: InputMaybe<Scalars['AWSDate']>;
    /** Filter arguments used only with BETWEEN comparison Operator */
    dateStart?: InputMaybe<Scalars['AWSDate']>;
    /**
     * Date Type
     *
     * Filter by booking created date (default) or departure date.
     */
    dateType?: InputMaybe<BookingsQueryFilterDateType>;
};
export declare enum BookingsQueryFilterDateType {
    CREATED = "CREATED",
    DEPARTURE = "DEPARTURE"
}
export declare type BroadcastMessageToGuestsInGroupInput = {
    /** The group ID to target for the message being sent out */
    groupID: Scalars['ID'];
    /** The message to be sent to Guests on the group */
    text: Scalars['String'];
};
export declare type CSVExport = {
    downloadUrl: Scalars['String'];
};
export declare type CancelBookingInput = {
    bookingID: Scalars['ID'];
    note?: InputMaybe<Scalars['String']>;
    spaces: Array<Scalars['ID']>;
    type: BookingSpaceCancellationType;
};
export declare type CancelBookingPayload = {
    booking: Booking;
};
export declare type ChangeChatConversationStatusInput = {
    conversationID: Scalars['ID'];
    status: ChatConversationStatus;
};
export declare type ChatConversation = Node & {
    created: Scalars['AWSDateTime'];
    id: Scalars['ID'];
    lastMessage?: Maybe<Scalars['AWSDateTime']>;
    lastRead?: Maybe<Scalars['AWSDateTime']>;
    messages: ChatMessageConnection;
    participants: ChatParticipantConnection;
    /**
     * Title
     *
     * Typically provided for a group conversation, but not a direct chat.
     */
    title?: Maybe<Scalars['String']>;
};
export declare type ChatConversationmessagesArgs = {
    limit?: InputMaybe<Scalars['Int']>;
    nextToken?: InputMaybe<Scalars['String']>;
};
export declare type ChatConversationparticipantsArgs = {
    limit?: InputMaybe<Scalars['Int']>;
    nextToken?: InputMaybe<Scalars['String']>;
};
export declare type ChatConversationConnection = Nodes & {
    items: Array<ChatConversation>;
    nextToken?: Maybe<Scalars['String']>;
};
export declare enum ChatConversationStatus {
    CLOSED = "CLOSED",
    OPEN = "OPEN",
    WAITING_FOR_CUSTOMER_REPLY = "WAITING_FOR_CUSTOMER_REPLY"
}
export declare type ChatDirectConversationInput = {
    from: Scalars['String'];
    to: Scalars['String'];
};
export declare type ChatMessage = Node & {
    /**
     * Automated host message
     *
     * Set as true if the message was e.g. an automatic host message, sent after booking.
     */
    automatedHostMessage?: Maybe<Scalars['Boolean']>;
    created: Scalars['AWSDateTime'];
    /** Host, where the author is a host (not a user) */
    host?: Maybe<Host>;
    /**
     * hostTeamMemberUserID
     *
     * The userID of the host user admin who has sent the message, making it easier to
     * let the guest know who answered.
     */
    hostTeamMemberUserID?: Maybe<Scalars['ID']>;
    id: Scalars['ID'];
    /**
     * System message
     *
     * If set, no notifications will be sent out, and the conversation lastMessage date won't be updated.
     */
    system?: Maybe<Scalars['Boolean']>;
    text: Scalars['String'];
    /** User profile, where the author is a user (not a host) */
    user?: Maybe<UserPublicProfile>;
};
export declare type ChatMessageConnection = Nodes & {
    items: Array<ChatMessage>;
    nextToken?: Maybe<Scalars['String']>;
};
export declare type ChatMessageInput = {
    conversationID: Scalars['String'];
    /**
     * conversationStatus
     *
     * When sending a message, set the conversation status for instance a Host can
     * reply to a customer and set a conversation as closed.
     */
    conversationStatus?: InputMaybe<ChatConversationStatus>;
    /**
     * Participant ID
     *
     * The user/host participant ID of the user creating the message.
     */
    participantID: Scalars['String'];
    text: Scalars['String'];
};
export declare type ChatParticipant = {
    /** Host, where the participant is a host (not a user) */
    host?: Maybe<Host>;
    lastMessage?: Maybe<Scalars['AWSDateTime']>;
    lastRead?: Maybe<Scalars['AWSDateTime']>;
    status?: Maybe<ChatConversationStatus>;
    /** User profile, where the participant is a user (not a host) */
    user?: Maybe<UserPublicProfile>;
};
export declare type ChatParticipantConnection = Nodes & {
    items: Array<ChatParticipant>;
    nextToken?: Maybe<Scalars['String']>;
};
/**
 * Chat User Message Count
 *
 * Shows the number of unread messages for a chat user (i.e. user or host).
 */
export declare type ChatUserMessageCount = {
    id: Scalars['ID'];
    unreadMessages: Scalars['Int'];
    /** This is the chat user ID (i.e. hostID or userID) */
    userID: Scalars['ID'];
};
export declare type ClaimGuestInput = {
    accessCode: Scalars['String'];
    spaceID: Scalars['String'];
    userID: Scalars['String'];
};
export declare type CommissionOverrides = Node & {
    id: Scalars['ID'];
    percentage: Scalars['String'];
    validFrom: Scalars['AWSDateTime'];
    validTo: Scalars['AWSDateTime'];
};
export declare type CommissionOverridesTripsConnection = {
    defaultCommission: Scalars['String'];
    items: Array<CommissionOverrides>;
};
export declare enum ComparisonOperator {
    EQUAL = "EQUAL",
    GREATER_THAN = "GREATER_THAN",
    GREATER_THAN_OR_EQUAL = "GREATER_THAN_OR_EQUAL",
    LESS_THAN = "LESS_THAN",
    LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL"
}
/**
 * Confirmation
 *
 * A response for mutations that simply returns true/false.
 */
export declare type Confirmation = {
    success: Scalars['Boolean'];
};
export declare type Coordinates = {
    lat: Scalars['Float'];
    lng: Scalars['Float'];
};
export declare type CoordinatesInput = {
    lat: Scalars['Float'];
    lng: Scalars['Float'];
};
export declare type Country = {
    code?: Maybe<CountryCodes>;
    name?: Maybe<Scalars['String']>;
};
export declare enum CountryCodes {
    AD = "AD",
    AE = "AE",
    AF = "AF",
    AG = "AG",
    AI = "AI",
    AL = "AL",
    AM = "AM",
    AO = "AO",
    AQ = "AQ",
    AR = "AR",
    AS = "AS",
    AT = "AT",
    AU = "AU",
    AW = "AW",
    AX = "AX",
    AZ = "AZ",
    BA = "BA",
    BB = "BB",
    BD = "BD",
    BE = "BE",
    BF = "BF",
    BG = "BG",
    BH = "BH",
    BI = "BI",
    BJ = "BJ",
    BL = "BL",
    BM = "BM",
    BN = "BN",
    BO = "BO",
    BQ = "BQ",
    BR = "BR",
    BS = "BS",
    BT = "BT",
    BV = "BV",
    BW = "BW",
    BY = "BY",
    BZ = "BZ",
    CA = "CA",
    CC = "CC",
    CD = "CD",
    CF = "CF",
    CG = "CG",
    CH = "CH",
    CI = "CI",
    CK = "CK",
    CL = "CL",
    CM = "CM",
    CN = "CN",
    CO = "CO",
    CR = "CR",
    CU = "CU",
    CV = "CV",
    CW = "CW",
    CX = "CX",
    CY = "CY",
    CZ = "CZ",
    DE = "DE",
    DJ = "DJ",
    DK = "DK",
    DM = "DM",
    DO = "DO",
    DZ = "DZ",
    EC = "EC",
    EE = "EE",
    EG = "EG",
    EH = "EH",
    ER = "ER",
    ES = "ES",
    ET = "ET",
    FI = "FI",
    FJ = "FJ",
    FK = "FK",
    FM = "FM",
    FO = "FO",
    FR = "FR",
    GA = "GA",
    GB = "GB",
    GD = "GD",
    GE = "GE",
    GF = "GF",
    GG = "GG",
    GH = "GH",
    GI = "GI",
    GL = "GL",
    GM = "GM",
    GN = "GN",
    GP = "GP",
    GQ = "GQ",
    GR = "GR",
    GS = "GS",
    GT = "GT",
    GU = "GU",
    GW = "GW",
    GY = "GY",
    HK = "HK",
    HM = "HM",
    HN = "HN",
    HR = "HR",
    HT = "HT",
    HU = "HU",
    ID = "ID",
    IE = "IE",
    IL = "IL",
    IM = "IM",
    IN = "IN",
    IO = "IO",
    IQ = "IQ",
    IR = "IR",
    IS = "IS",
    IT = "IT",
    JE = "JE",
    JM = "JM",
    JO = "JO",
    JP = "JP",
    KE = "KE",
    KG = "KG",
    KH = "KH",
    KI = "KI",
    KM = "KM",
    KN = "KN",
    KP = "KP",
    KR = "KR",
    KW = "KW",
    KY = "KY",
    KZ = "KZ",
    LA = "LA",
    LB = "LB",
    LC = "LC",
    LI = "LI",
    LK = "LK",
    LR = "LR",
    LS = "LS",
    LT = "LT",
    LU = "LU",
    LV = "LV",
    LY = "LY",
    MA = "MA",
    MC = "MC",
    MD = "MD",
    ME = "ME",
    MF = "MF",
    MG = "MG",
    MH = "MH",
    MK = "MK",
    ML = "ML",
    MM = "MM",
    MN = "MN",
    MO = "MO",
    MP = "MP",
    MQ = "MQ",
    MR = "MR",
    MS = "MS",
    MT = "MT",
    MU = "MU",
    MV = "MV",
    MW = "MW",
    MX = "MX",
    MY = "MY",
    MZ = "MZ",
    NA = "NA",
    NC = "NC",
    NE = "NE",
    NF = "NF",
    NG = "NG",
    NI = "NI",
    NL = "NL",
    NO = "NO",
    NP = "NP",
    NR = "NR",
    NU = "NU",
    NZ = "NZ",
    OM = "OM",
    PA = "PA",
    PE = "PE",
    PF = "PF",
    PG = "PG",
    PH = "PH",
    PK = "PK",
    PL = "PL",
    PM = "PM",
    PN = "PN",
    PR = "PR",
    PS = "PS",
    PT = "PT",
    PW = "PW",
    PY = "PY",
    QA = "QA",
    RE = "RE",
    RO = "RO",
    RS = "RS",
    RU = "RU",
    RW = "RW",
    SA = "SA",
    SB = "SB",
    SC = "SC",
    SD = "SD",
    SE = "SE",
    SG = "SG",
    SH = "SH",
    SI = "SI",
    SJ = "SJ",
    SK = "SK",
    SL = "SL",
    SM = "SM",
    SN = "SN",
    SO = "SO",
    SR = "SR",
    SS = "SS",
    ST = "ST",
    SV = "SV",
    SX = "SX",
    SY = "SY",
    SZ = "SZ",
    TC = "TC",
    TD = "TD",
    TF = "TF",
    TG = "TG",
    TH = "TH",
    TJ = "TJ",
    TK = "TK",
    TL = "TL",
    TM = "TM",
    TN = "TN",
    TO = "TO",
    TR = "TR",
    TT = "TT",
    TV = "TV",
    TW = "TW",
    TZ = "TZ",
    UA = "UA",
    UG = "UG",
    UM = "UM",
    US = "US",
    UY = "UY",
    UZ = "UZ",
    VA = "VA",
    VC = "VC",
    VE = "VE",
    VG = "VG",
    VI = "VI",
    VN = "VN",
    VU = "VU",
    WF = "WF",
    WS = "WS",
    YE = "YE",
    YT = "YT",
    ZA = "ZA",
    ZM = "ZM",
    ZW = "ZW"
}
export declare type Coupon = Node & {
    active: Scalars['Boolean'];
    code: Scalars['String'];
    created: Scalars['AWSDateTime'];
    deductFrom: CouponDeductionType;
    description?: Maybe<Scalars['String']>;
    expiryDate?: Maybe<Scalars['AWSDateTime']>;
    group?: Maybe<Group>;
    id: Scalars['ID'];
    trip?: Maybe<Trip>;
    value: CouponValue;
};
export declare type CouponConnection = {
    items: Array<Coupon>;
    nextToken?: Maybe<Scalars['String']>;
};
export declare enum CouponDeductionType {
    FULL = "FULL",
    HOST = "HOST",
    SKYHOOK = "SKYHOOK"
}
export declare enum CouponType {
    FIXED = "FIXED",
    PERCENTAGE = "PERCENTAGE"
}
export declare type CouponValue = {
    fixed?: Maybe<Price>;
    percentage?: Maybe<Scalars['Float']>;
    type: CouponType;
};
export declare type CouponValueInput = {
    percentage?: InputMaybe<Scalars['Float']>;
    type: CouponType;
    value?: InputMaybe<PriceInput>;
};
export declare type CreateBookingInput = {
    couponCode?: InputMaybe<Scalars['String']>;
    credit?: InputMaybe<BookingCreditInput>;
    group: BookingGroupInput;
    payment?: InputMaybe<BookingPaymentInput>;
    spacesRequired: Scalars['Int'];
    tracking?: InputMaybe<TrackingInput>;
    user: BookingUserInput;
};
export declare type CreateBookingPayload = {
    booking: Booking;
};
export declare type CreateTMTBookingInput = {
    couponCode?: InputMaybe<Scalars['String']>;
    credit?: InputMaybe<BookingCreditInput>;
    group: BookingGroupInput;
    spacesRequired: Scalars['Int'];
    tracking?: InputMaybe<TrackingInput>;
    user: BookingUserInput;
};
export declare type CreateTMTBookingPayload = {
    channels: Scalars['Int'];
    content: Scalars['String'];
    countries: Scalars['String'];
    currencies: Scalars['String'];
    date: Scalars['String'];
    email: Scalars['String'];
    firstname: Scalars['String'];
    id: Scalars['Int'];
    pax: Scalars['Int'];
    reference: Scalars['String'];
    status: Scalars['String'];
    surname: Scalars['String'];
    total: Scalars['Int'];
    transaction_ids: Array<Scalars['Int']>;
};
export declare enum Currency {
    CAD = "CAD",
    EUR = "EUR",
    GBP = "GBP",
    NOK = "NOK",
    NZD = "NZD",
    SGD = "SGD",
    USD = "USD"
}
export declare type CurrencyDetails = {
    code?: Maybe<GlobalCurrencies>;
    symbol?: Maybe<Scalars['String']>;
};
export declare type CurrencyInput = {
    convertFrom: PriceInput;
    date: Scalars['AWSDate'];
};
export declare type DaysBreakdown = {
    days: Scalars['Int'];
    nights: Scalars['Int'];
};
export declare type DeleteLastTripItineraryItemInput = {
    tripID: Scalars['String'];
};
export declare type DiscontinuedTrip = {
    isDiscontinued: Scalars['Boolean'];
    recommendedTrips: Array<RecommendedTrip>;
};
export declare type DiscontinuedTripInput = {
    isDiscontinued: Scalars['Boolean'];
    recommendedTrips: Array<RecommendedTripInput>;
};
export declare type Discount = Node & {
    code: Scalars['ID'];
    createdAt: Scalars['AWSDateTime'];
    /** If null, the discount is available for any trip group. */
    group?: Maybe<Group>;
    id: Scalars['ID'];
    nominalAmount?: Maybe<Price>;
    /** If null, the discount can be used an unlimited amount of times. */
    quantityRemaining?: Maybe<Scalars['Int']>;
    updatedAt: Scalars['AWSDateTime'];
};
export declare type DownloadRevenueReportInput = {
    type: RevenueReportType;
};
export declare type DripTagGuestOnGroupsInput = {
    /** The start date to apply the tag to the guests */
    fromDate: Scalars['AWSDateTime'];
    requestID: Scalars['ID'];
    /** The tag to apply to the guests */
    tag: Scalars['String'];
    /** The end date to apply the tag to the guests */
    toDate: Scalars['AWSDateTime'];
    /** The trip to apply the tag to */
    tripId: Scalars['ID'];
};
export declare enum Gender {
    FEMALE = "FEMALE",
    MALE = "MALE",
    /**
     * Other Gender
     *
     * Please note that many countries do not allow any gender other than male/female on official forms, and as such you may
     * need to specify male/female for these use cases.
     */
    OTHER = "OTHER"
}
export declare type GeoLocation = {
    country?: Maybe<Country>;
    currency?: Maybe<CurrencyDetails>;
    ipAddress?: Maybe<Scalars['AWSIPAddress']>;
    phoneCode?: Maybe<Scalars['String']>;
    xccyRates?: Maybe<Array<Maybe<XCCYRate>>>;
};
export declare enum GlobalCurrencies {
    AED = "AED",
    AFN = "AFN",
    ALL = "ALL",
    AMD = "AMD",
    ANG = "ANG",
    AOA = "AOA",
    ARS = "ARS",
    AUD = "AUD",
    AWG = "AWG",
    AZN = "AZN",
    BAM = "BAM",
    BBD = "BBD",
    BDT = "BDT",
    BGN = "BGN",
    BHD = "BHD",
    BIF = "BIF",
    BMD = "BMD",
    BND = "BND",
    BOB = "BOB",
    BRL = "BRL",
    BSD = "BSD",
    BTN = "BTN",
    BWP = "BWP",
    BYR = "BYR",
    BZD = "BZD",
    CAD = "CAD",
    CDF = "CDF",
    CHF = "CHF",
    CLP = "CLP",
    CNY = "CNY",
    COP = "COP",
    CRC = "CRC",
    CUP = "CUP",
    CVE = "CVE",
    CZK = "CZK",
    DJF = "DJF",
    DKK = "DKK",
    DOP = "DOP",
    DZD = "DZD",
    EGP = "EGP",
    ERN = "ERN",
    ETB = "ETB",
    EUR = "EUR",
    FJD = "FJD",
    FKP = "FKP",
    GBP = "GBP",
    GEL = "GEL",
    GHS = "GHS",
    GIP = "GIP",
    GMD = "GMD",
    GNF = "GNF",
    GTQ = "GTQ",
    GYD = "GYD",
    HKD = "HKD",
    HNL = "HNL",
    HRK = "HRK",
    HTG = "HTG",
    HUF = "HUF",
    IDR = "IDR",
    ILS = "ILS",
    INR = "INR",
    IQD = "IQD",
    IRR = "IRR",
    ISK = "ISK",
    JMD = "JMD",
    JOD = "JOD",
    JPY = "JPY",
    KES = "KES",
    KGS = "KGS",
    KHR = "KHR",
    KMF = "KMF",
    KPW = "KPW",
    KRW = "KRW",
    KWD = "KWD",
    KYD = "KYD",
    KZT = "KZT",
    LAK = "LAK",
    LBP = "LBP",
    LKR = "LKR",
    LRD = "LRD",
    LSL = "LSL",
    LTL = "LTL",
    LYD = "LYD",
    MAD = "MAD",
    MDL = "MDL",
    MGA = "MGA",
    MKD = "MKD",
    MMK = "MMK",
    MNT = "MNT",
    MOP = "MOP",
    MRO = "MRO",
    MUR = "MUR",
    MVR = "MVR",
    MWK = "MWK",
    MXN = "MXN",
    MYR = "MYR",
    MZN = "MZN",
    NAD = "NAD",
    NGN = "NGN",
    NIO = "NIO",
    NOK = "NOK",
    NPR = "NPR",
    NZD = "NZD",
    OMR = "OMR",
    PAB = "PAB",
    PEN = "PEN",
    PGK = "PGK",
    PHP = "PHP",
    PKR = "PKR",
    PLN = "PLN",
    PYG = "PYG",
    QAR = "QAR",
    RON = "RON",
    RSD = "RSD",
    RUB = "RUB",
    RWF = "RWF",
    SAR = "SAR",
    SBD = "SBD",
    SCR = "SCR",
    SDG = "SDG",
    SEK = "SEK",
    SGD = "SGD",
    SHP = "SHP",
    SLL = "SLL",
    SOS = "SOS",
    SRD = "SRD",
    SSP = "SSP",
    STD = "STD",
    SYP = "SYP",
    SZL = "SZL",
    THB = "THB",
    TJS = "TJS",
    TMT = "TMT",
    TND = "TND",
    TOP = "TOP",
    TRY = "TRY",
    TTD = "TTD",
    TWD = "TWD",
    TZS = "TZS",
    UAH = "UAH",
    UGX = "UGX",
    USD = "USD",
    UYU = "UYU",
    UZS = "UZS",
    VEF = "VEF",
    VND = "VND",
    VUV = "VUV",
    WST = "WST",
    XAF = "XAF",
    XCD = "XCD",
    XOF = "XOF",
    XPF = "XPF",
    YER = "YER",
    ZAR = "ZAR",
    ZMK = "ZMK",
    ZWL = "ZWL"
}
export declare type Group = Node & {
    bookings: BookingConnection;
    commissionPercentage: Scalars['String'];
    coupons?: Maybe<CouponConnection>;
    end: LocalDateTime;
    guestDeposit: Price;
    guestPrice: Price;
    guestPriceBeforeDiscount?: Maybe<Price>;
    /** Public details of any guests (including their public profiles) */
    guests: GuestPublicConnection;
    hostPrice: Price;
    /**
     * To avoid modifying t he booking service, we will have a price before discount
     * field that will be used to calculate the discount rate for display purposes
     * only and will not be used for any calculations
     */
    hostPriceBeforeDiscount?: Maybe<Price>;
    id: Scalars['ID'];
    maxCredit: Price;
    /** Media for a Trip Group */
    media?: Maybe<MediaConnection>;
    private: Scalars['Boolean'];
    remainingSpaces: Scalars['Int'];
    spacesBooked?: Maybe<Scalars['Int']>;
    start: LocalDateTime;
    trip: Trip;
    /**
     * Groups waiting list
     *
     * View users on a groups waiting list
     */
    waitList: WaitListConnection;
    /** Number of people on the waiting list */
    waitListCount?: Maybe<Scalars['Int']>;
};
export declare type GroupcouponsArgs = {
    limit?: InputMaybe<Scalars['Int']>;
    nextToken?: InputMaybe<Scalars['String']>;
};
export declare type GroupmediaArgs = {
    limit?: InputMaybe<Scalars['Int']>;
    nextToken?: InputMaybe<Scalars['String']>;
};
export declare type GroupwaitListArgs = {
    limit?: InputMaybe<Scalars['Int']>;
    nextToken?: InputMaybe<Scalars['String']>;
};
export declare type GroupConnection = Nodes & {
    items: Array<Group>;
    nextToken?: Maybe<Scalars['String']>;
};
/**
 * Guest
 *
 * A guest is the person who is actually travelling for a given booking space. This may be the booking owner, but it also
 * may be someone they bought the space for.
 */
export declare type Guest = Node & {
    /**
     * Access code
     *
     * This is a 4-digit code that can be shared to let someone else fill in the guest form. Made public so that a user can
     * get a link to share directly rather than letting the system email the guest.
     */
    accessCode: Scalars['String'];
    bio?: Maybe<Scalars['String']>;
    birthDate?: Maybe<Scalars['AWSDate']>;
    booking: Booking;
    /** Booking Owner User ID */
    bookingOwnerID: Scalars['String'];
    /**
     * Completed
     *
     * Marked as true if all the required information has been given for the guest & trip form.
     */
    completed: Scalars['Boolean'];
    created: Scalars['AWSDateTime'];
    email?: Maybe<Scalars['String']>;
    familyName?: Maybe<Scalars['String']>;
    givenName?: Maybe<Scalars['String']>;
    group: Group;
    hostNotes?: Maybe<Scalars['String']>;
    /**
     * Guest ID
     *
     * UUID of the format guest_UUID, primarily used for caching (as we update using the booking space ID instead of this).
     */
    id: Scalars['ID'];
    phone?: Maybe<Scalars['String']>;
    /** Guest Profile Picture */
    picture?: Maybe<Media>;
    review?: Maybe<Review>;
    spaceID: Scalars['String'];
    trip: Trip;
    tripForm?: Maybe<TripForm>;
    tripFormDueDate: Scalars['String'];
    tripFormRequiredInformation: TripFormRequiredInformation;
    updated: Scalars['AWSDateTime'];
    user?: Maybe<User>;
    userID?: Maybe<Scalars['String']>;
};
export declare type GuestConnection = {
    items: Array<Guest>;
};
export declare type GuestInput = {
    bio?: InputMaybe<Scalars['String']>;
    birthDate?: InputMaybe<Scalars['AWSDate']>;
    email: Scalars['AWSEmail'];
    familyName: Scalars['String'];
    givenName: Scalars['String'];
    /**
     * Is Booking Owner
     *
     * If the guest is the booking owner, it will be linked to their account (using the userID field). Otherwise the guest
     * will get an email to let them claim the guest entity with a different account.
     */
    isBookingOwner: Scalars['Boolean'];
    phone: Scalars['AWSPhone'];
    picture?: InputMaybe<MediaReferenceInput>;
    spaceID: Scalars['String'];
    tripForm?: InputMaybe<TripFormInput>;
};
/**
 * Guest Public
 *
 * Used to show limited information publicly (e.g. the guest public photo)
 */
export declare type GuestPublic = Node & {
    bookingOwnerID: Scalars['String'];
    givenName?: Maybe<Scalars['String']>;
    id: Scalars['ID'];
    /** The profile picture of the guest */
    picture?: Maybe<Media>;
    user?: Maybe<UserPublicProfile>;
    userID?: Maybe<Scalars['String']>;
};
/**
 * Guest Public Connection
 *
 * Used to show limited information publicly (e.g. the guest public photo)
 */
export declare type GuestPublicConnection = {
    items: Array<GuestPublic>;
};
export declare type Host = Node & {
    about: Scalars['String'];
    active: Scalars['Boolean'];
    badges?: Maybe<Array<Media>>;
    /** Hosts' bookings, ordered by created date */
    bookings: BookingConnection;
    /** Official Registration Address */
    businessAddress?: Maybe<Address>;
    chatInbox: ChatConversationConnection;
    chatMessageCount: ChatUserMessageCount;
    /**
     * Company Registration Number
     *
     * New requirements for hosts
     *
     * (Optional for backwards compatibility with existing hosts, but required for new hosts.)
     */
    companyRegistrationNumber?: Maybe<Scalars['String']>;
    contact?: Maybe<HostContactDetails>;
    created: Scalars['AWSDateTime'];
    facebookPage?: Maybe<Scalars['AWSURL']>;
    hostFeaturedVideoURL?: Maybe<Scalars['AWSURL']>;
    hostFeaturedVideoURLThumbnail?: Maybe<Media>;
    id: Scalars['ID'];
    legalName?: Maybe<Scalars['String']>;
    /** Host Logo */
    logo?: Maybe<Media>;
    /** The list of media items uploaded by a host */
    media?: Maybe<MediaConnection>;
    name: Scalars['String'];
    notifications?: Maybe<ActivityStreamConnection>;
    paymentDetails?: Maybe<HostPaymentDetails>;
    reviews: ReviewConnection;
    settings?: Maybe<HostSettings>;
    /**
     * Host statements
     *
     * Start and end date filters are inclusive (i.e. >= and <= respectively)
     */
    statement: HostStatement;
    /** Team members of the host */
    team: HostTeamConnection;
    termsConditions?: Maybe<Scalars['String']>;
    trips: TripConnection;
    twitterPage?: Maybe<Scalars['AWSURL']>;
    updated: Scalars['AWSDateTime'];
    urlSlug: Scalars['String'];
    /** Users with permissions to manage host */
    userRoles: HostUsersRolesConnection;
    website?: Maybe<Scalars['AWSURL']>;
};
export declare type HostbookingsArgs = {
    limit?: InputMaybe<Scalars['Int']>;
    nextToken?: InputMaybe<Scalars['String']>;
};
export declare type HostchatInboxArgs = {
    limit?: InputMaybe<Scalars['Int']>;
    nextToken?: InputMaybe<Scalars['String']>;
    status?: InputMaybe<ChatConversationStatus>;
};
export declare type HostmediaArgs = {
    limit?: InputMaybe<Scalars['Int']>;
    nextToken?: InputMaybe<Scalars['String']>;
};
export declare type HostnotificationsArgs = {
    limit?: InputMaybe<Scalars['Int']>;
    nextToken?: InputMaybe<Scalars['String']>;
};
export declare type HostreviewsArgs = {
    limit?: InputMaybe<Scalars['Int']>;
    nextToken?: InputMaybe<Scalars['String']>;
};
export declare type HoststatementArgs = {
    endDate: Scalars['AWSDateTime'];
    startDate: Scalars['AWSDateTime'];
};
export declare type HostBusinessInfoInput = {
    /** Official Registration Address */
    businessAddress: AddressInput;
    /** Legal Business Name */
    businessName: Scalars['String'];
    /**
     * Company Registration Number
     *
     * (Optional for backwards compatibility with existing hosts, but required for new hosts.)
     */
    companyRegistrationNumber?: InputMaybe<Scalars['String']>;
};
export declare type HostContactDetails = {
    contactName?: Maybe<Scalars['String']>;
    email: Scalars['String'];
    phone: Scalars['String'];
};
export declare type HostContactDetailsInput = {
    contactName: Scalars['String'];
    email: Scalars['String'];
    phone: Scalars['String'];
};
export declare type HostPaymentDetails = {
    bankDetails?: Maybe<