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

Node SDK for the Skyhook graphql API

import { AccountingAccountName } from './API';
import { AccountingJournalType } from './API';
import { ActivityStreamActorType } from './API';
import { ActivityStreamIconType } from './API';
import { BookingCommissionTaxRate } from './API';
import { BookingEntityType } from './API';
import { BookingSpaceCancellationType } from './API';
import { BookingSpaceInvoiceLineType } from './API';
import { BookingSpaceInvoiceSummaryType } from './API';
import { BookingsQueryFilterDateType } from './API';
import { ChatConversationStatus } from './API';
import { ComparisonOperator } from './API';
import { CountryCodes } from './API';
import { CouponDeductionType } from './API';
import { CouponType } from './API';
import { Currency } from './API';
import { Gender } from './API';
import { GlobalCurrencies } from './API';
import { HostRecordTypes } from './API';
import { HostRoleType } from './API';
import { LandingPageFilterBy } from './API';
import { MediaType } from './API';
import { Nationality } from './API';
import { NotificationIsRead } from './API';
import { RevenueReportType } from './API';
import { ReviewSource } from './API';
import { ReviewStatisticsType } from './API';
import { SkyhookClubTiers } from './API';
import { Status } from './API';
import { SupportMessageTags } from './API';
import { TransactionProcessor } from './API';
import { TransactionType } from './API';
import { TransportMode } from './API';
import { TripActivityType } from './API';
import { TripAutomatedMessageNumber } from './API';
import { TripFAQsCategories } from './API';
import { WayPointType } from './API';
export declare type WithKeys<QueryType> = QueryType & {
    /** Object Type in ALL CAPS */
    _type: string;
    /** Partition Key */
    pk: string;
    /** Sort Key */
    sk: string;
    gsi1PK?: string;
    gsi1SK?: string;
    gsi2PK?: string;
    gsi2SK?: string;
    gsi3PK?: string;
    gsi3SK?: string;
    gsi4PK?: string;
    gsi4SK?: string;
    gsi5PK?: string;
    gsi5SK?: string;
};
declare type Maybe<T> = T | null;
/** All built-in and custom scalars, mapped to their actual values */
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 { AccountingAccountName };
export { AccountingJournalType };
/**
 * 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.
 */
declare type ActivityObject = {
    __typename?: '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
 */
declare type ActivityStream = {
    __typename?: '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.
 */
declare type ActivityStreamActor = {
    __typename?: '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 { ActivityStreamActorType };
declare type ActivityStreamConnection = {
    __typename?: '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
 */
declare type ActivityStreamIcon = {
    __typename?: 'ActivityStreamIcon';
    height?: Maybe<Scalars['Int']>;
    name?: Maybe<Scalars['String']>;
    type?: Maybe<ActivityStreamIconType>;
    url: Scalars['AWSURL'];
    width?: Maybe<Scalars['Int']>;
};
export { ActivityStreamIconType };
/**
 * ActivityStreamTarget
 *
 * The direct object upon which an activity was performed on i.e. space or booking.
 */
declare type ActivityStreamTarget = {
    __typename?: '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'];
};
/** Address uses the OASIS [XAL](https://www.oasis-open.org/committees/ciq/download.shtml) standard */
declare type Address = {
    __typename?: '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']>;
};
declare type AutomatedMessage = {
    __typename?: 'AutomatedMessage';
    created: Scalars['AWSDateTime'];
    /** The message to send to the guest after booking */
    message: Scalars['String'];
    updated: Scalars['AWSDateTime'];
};
declare type BankDetails = {
    __typename?: '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']>;
};
declare type Booking = Node & {
    __typename?: 'Booking';
    /**
     * 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;
};
declare type BookingCommissionDetails = {
    __typename?: '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 { BookingCommissionTaxRate };
declare type BookingConnection = Nodes & {
    __typename?: 'BookingConnection';
    items: Array<Booking>;
    nextToken?: Maybe<Scalars['String']>;
};
export { BookingEntityType };
/**
 * 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.
 */
declare type BookingInvoiceSummary = {
    __typename?: '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;
};
declare type BookingSpace = {
    __typename?: '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;
};
declare type BookingSpaceCancellationOption = {
    __typename?: 'BookingSpaceCancellationOption';
    guestCredit: Price;
    /** Guest permission to use this cancellation option (true = has permission) */
    guestPermission: Scalars['Boolean'];
    guestRefund: Price;
    hostRefund: Price;
    type: BookingSpaceCancellationType;
};
export { BookingSpaceCancellationType };
declare type BookingSpaceInvoiceLine = {
    __typename?: '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 { BookingSpaceInvoiceLineType };
export { BookingSpaceInvoiceSummaryType };
export { BookingsQueryFilterDateType };
declare type ChatConversation = Node & {
    __typename?: 'ChatConversation';
    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']>;
};
declare type ChatConversationConnection = Nodes & {
    __typename?: 'ChatConversationConnection';
    items: Array<ChatConversation>;
    nextToken?: Maybe<Scalars['String']>;
};
export { ChatConversationStatus };
declare type ChatMessage = Node & {
    __typename?: 'ChatMessage';
    /**
     * 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>;
};
declare type ChatMessageConnection = Nodes & {
    __typename?: 'ChatMessageConnection';
    items: Array<ChatMessage>;
    nextToken?: Maybe<Scalars['String']>;
};
declare type ChatParticipant = {
    __typename?: '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>;
};
declare type ChatParticipantConnection = Nodes & {
    __typename?: 'ChatParticipantConnection';
    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).
 */
declare type ChatUserMessageCount = {
    __typename?: 'ChatUserMessageCount';
    id: Scalars['ID'];
    unreadMessages: Scalars['Int'];
    /** This is the chat user ID (i.e. hostID or userID) */
    userID: Scalars['ID'];
};
declare type CommissionOverrides = Node & {
    __typename?: 'CommissionOverrides';
    id: Scalars['ID'];
    percentage: Scalars['String'];
    validFrom: Scalars['AWSDateTime'];
    validTo: Scalars['AWSDateTime'];
};
declare type CommissionOverridesTripsConnection = {
    __typename?: 'CommissionOverridesTripsConnection';
    defaultCommission: Scalars['String'];
    items: Array<CommissionOverrides>;
};
export { ComparisonOperator };
declare type Coordinates = {
    __typename?: 'Coordinates';
    lat: Scalars['Float'];
    lng: Scalars['Float'];
};
export { CountryCodes };
declare type Coupon = Node & {
    __typename?: 'Coupon';
    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;
};
declare type CouponConnection = {
    __typename?: 'CouponConnection';
    items: Array<Coupon>;
    nextToken?: Maybe<Scalars['String']>;
};
export { CouponDeductionType };
export { CouponType };
declare type CouponValue = {
    __typename?: 'CouponValue';
    fixed?: Maybe<Price>;
    percentage?: Maybe<Scalars['Float']>;
    type: CouponType;
};
export { Currency };
declare type DaysBreakdown = {
    __typename?: 'DaysBreakdown';
    days: Scalars['Int'];
    nights: Scalars['Int'];
};
declare type DiscontinuedTrip = {
    __typename?: 'DiscontinuedTrip';
    isDiscontinued: Scalars['Boolean'];
    recommendedTrips: Array<RecommendedTrip>;
};
export { Gender };
export { GlobalCurrencies };
declare type Group = Node & {
    __typename?: 'Group';
    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']>;
};
declare type GroupConnection = Nodes & {
    __typename?: 'GroupConnection';
    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.
 */
declare type Guest = Node & {
    __typename?: 'Guest';
    /**
     * 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']>;
};
declare type GuestConnection = {
    __typename?: 'GuestConnection';
    items: Array<Guest>;
};
/**
 * Guest Public
 *
 * Used to show limited information publicly (e.g. the guest public photo)
 */
declare type GuestPublic = Node & {
    __typename?: 'GuestPublic';
    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)
 */
declare type GuestPublicConnection = {
    __typename?: 'GuestPublicConnection';
    items: Array<GuestPublic>;
};
declare type Host = Node & {
    __typename?: 'Host';
    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']>;
};
declare type HostContactDetails = {
    __typename?: 'HostContactDetails';
    contactName?: Maybe<Scalars['String']>;
    email: Scalars['String'];
    phone: Scalars['String'];
};
declare type HostPaymentDetails = {
    __typename?: 'HostPaymentDetails';
    bankDetails?: Maybe<BankDetails>;
    currency: Currency;
    tmtID?: Maybe<Scalars['Int']>;
    tmtIDLegacy?: Maybe<Scalars['String']>;
};
export { HostRecordTypes };
declare type HostRole = {
    __typename?: 'HostRole';
    host: Host;
    role: HostRoleType;
    updated: Scalars['AWSDateTime'];
    user: User;
};
export { HostRoleType };
declare type HostSettings = {
    __typename?: 'HostSettings';
    /** Whether on the trip page the host profile should be shown or not. */
    showHostProfileOnTripPage: Scalars['Boolean'];
};
/** Host statements */
declare type HostStatement = {
    __typename?: 'HostStatement';
    lines: Array<HostStatementLine>;
};
/**
 * Host statement line
 *
 * One line corresponds to each transaction.
 */
declare type HostStatementLine = {
    __typename?: 'HostStatementLine';
    bookingID: Scalars['ID'];
    commissionTaxRate: BookingCommissionTaxRate;
    groupEndDate: Scalars['AWSDateTime'];
    groupID: Scalars['String'];
    groupStartDate: Scalars['AWSDateTime'];
    guestAmount: Price;
    hostAmount: Price;
    processor: TransactionProcessor;
    statementDate: Scalars['AWSDateTime'];
    tripID: Scalars['String'];
    type: TransactionType;
    userID: Scalars['String'];
};
declare type HostTeamConnection = {
    __typename?: 'HostTeamConnection';
    items: Array<UserPublicProfile>;
};
declare type HostUsersRolesConnection = {
    __typename?: 'HostUsersRolesConnection';
    items?: Maybe<Array<HostRole>>;
};
declare type LandingPageFAQ = {
    __typename?: 'LandingPageFAQ';
    answer: Scalars['String'];
    links?: Maybe<Array<TripFAQLink>>;
    question: Scalars['String'];
    videos?: Maybe<Array<TripFAQVideo>>;
};
export { LandingPageFilterBy };
/**
 * Local DateTime generic
 *
 * For use where the local time is important (e.g. a group start date).
 */
declare type LocalDateTime = {
    __typename?: 'LocalDateTime';
    /** UTC time of the format YYYY-MM-DDThh:mm:ss.sssZ */
    utc: Scalars['AWSDateTime'];
    /**
     * Timezone
     *
     * Must be a canonical timezone from the IANA dataset.
     * https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
     */
    zone: Scalars['String'];
};
/**
 * Media Item
 *
 * Can be an image or video. See
 */
declare type Media = Node & {
    __typename?: 'Media';
    created: Scalars['AWSDateTime'];
    file?: Maybe<S3Object>;
    id: Scalars['ID'];
    type: MediaType;
    updated: Scalars['AWSDateTime'];
};
/** Media Connection */
declare type MediaConnection = {
    __typename?: 'MediaConnection';
    items: Array<Media>;
    nextToken?: Maybe<Scalars['String']>;
};
export { MediaType };
declare type MinimumPriceWithDiscount = {
    __typename?: 'MinimumPriceWithDiscount';
    /** The zero-decimal amount (i.e. the amount in cents for USD/EUR, or pence for GBP). */
    amountZD: Scalars['Int'];
    currency: Currency;
    discountRate?: Maybe<Scalars['Float']>;
    priceBeforeDiscount?: Maybe<Price>;
};
export { Nationality };
/**
 * Node Interface
 *
 * Using the standard node interface for types allows client-side caching to work (e.g. Apollo in-memory cache), as most
 * caching libs use the id field as the hash key for their local store of query data.
 */
declare type Node = {
    id: Scalars['ID'];
};
/**
 * Nodes Interface
 *
 * To be expanded in the future - creates a standard interface for getting many items (typically from a Dynamo DB query).
 */
declare type Nodes = {
    nextToken?: Maybe<Scalars['String']>;
};
export { NotificationIsRead };
declare type Price = {
    __typename?: 'Price';
    /** The zero-decimal amount (i.e. the amount in cents for USD/EUR, or pence for GBP). */
    amountZD: Scalars['Int'];
    currency: Currency;
};
/** Price */
declare type PriceWithOverpayment = {
    __typename?: 'PriceWithOverpayment';
    amountZD: Scalars['Int'];
    currency: Currency;
    /**
     * Overpayment
     *
     * For transaction invoice lines only. There may have been an overpayment if e.g. a duplicate transaction was taken.
     *
     * For payments (-ve transaction invoice lines) this will show as -ve for an overpayment.
     *
     * For refunds (+ve transaction lines) this will show as +ve for an overpayment.
     */
    overpaymentZD?: Maybe<Scalars['Int']>;
};
declare type RecommendedTrip = {
    __typename?: 'RecommendedTrip';
    title: Scalars['String'];
    url: Scalars['AWSURL'];
};
/**
 * Reference
 *
 * Gives the ID of an object, but not the full underlying item in this query
 */
declare type Ref = {
    __typename?: 'Ref';
    id: Scalars['ID'];
};
export { RevenueReportType };
declare type Review = Node & {
    __typename?: 'Review';
    body: Scalars['String'];
    /**
     * Five Star Rating
     *
     * Returns a value between 1 and 5 (i.e. excluding 0 so that it is not possible to have 0 stars), calculated from the
     * rating field (which is a float between 0 and 1).
     */
    fiveStarRating: Scalars['Float'];
    /**
     * ID
     *
     * This is the same as the booking space id.
     */
    id: Scalars['ID'];
    /**
     * Media for a Review
     *
     * Includes all the user's uploaded images, for the group.
     */
    media?: Maybe<MediaConnection>;
    /**
     * Rating
     *
     * Should be between 0 and 1.
     */
    rating: Scalars['Float'];
    reply?: Maybe<ReviewReply>;
    source?: Maybe<ReviewSource>;
    startDate: Scalars['AWSDateTime'];
    trip: Trip;
    updated: Scalars['AWSDateTime'];
    user: UserPublicProfile;
};
declare type ReviewConnection = {
    __typename?: 'ReviewConnection';
    items: Array<Review>;
    nextToken?: Maybe<Scalars['String']>;
};
declare type ReviewReply = {
    __typename?: 'ReviewReply';
    content: Scalars['String'];
    created: Scalars['AWSDateTime'];
};
export { ReviewSource };
declare type ReviewStatistics = {
    __typename?: 'ReviewStatistics';
    fiveStarRatingAverage?: Maybe<Scalars['Float']>;
    ratingAverage?: Maybe<Scalars['Float']>;
    reviewCount: Scalars['Int'];
    starsReviewBreakdown: StarsReviewBreakdown;
};
export { ReviewStatisticsType };
declare type ReviewsSummary = {
    __typename?: 'ReviewsSummary';
    /**
     * Five Star Rating Average
     *
     * Returns a value between 1 and 5 (i.e. excluding 0 so that it is not possible to have 0 stars), calculated from the
     * rating average field (which is a float between 0 and 1).
     */
    fiveStarRatingAverage?: Maybe<Scalars['Float']>;
    /**
     * Rating Average
     *
     * Between 0 and 1.
     */
    ratingAverage?: Maybe<Scalars['Float']>;
    reviewCount: Scalars['Int'];
};
/**
 * S3 Object
 *
 * Follows the standard [Amplify approach](https://docs.amplify.aws/cli/graphql-transformer/storage).
 */
declare type S3Object = {
    __typename?: 'S3Object';
    bucket: Scalars['String'];
    key: Scalars['String'];
    region: Scalars['String'];
};
declare type SEO = {
    __typename?: 'SEO';
    metaDescription?: Maybe<Scalars['String']>;
    metaTitle?: Maybe<Scalars['String']>;
};
export { SkyhookClubTiers };
declare type SkyhookFanClubCredits = Node & {
    __typename?: 'SkyhookFanClubCredits';
    amount: Price;
    booking: Booking;
    created: Scalars['AWSDateTime'];
    credit?: Maybe<UserCredit>;
    group: Group;
    id: Scalars['ID'];
    travelledOn: Scalars['AWSDateTime'];
    user: User;
};
declare type StarsReviewBreakdown = {
    __typename?: 'StarsReviewBreakdown';
    fiveStar: Scalars['Int'];
    fourStar: Scalars['Int'];
    oneStar: Scalars['Int'];
    threeStar: Scalars['Int'];
    twoStar: Scalars['Int'];
};
export { Status };
export { SupportMessageTags };
declare type TMTDetails = {
    __typename?: 'TMTDetails';
    affiliateChannelID?: Maybe<Scalars['Int']>;
    /** TMT Booking ID */
    bookingID: Scalars['Int'];
    channelID: Scalars['Int'];
};
declare type Testimonial = {
    __typename?: 'Testimonial';
    order: Scalars['Int'];
    thumbnail: Media;
    youtubeVideoURL: Scalars['AWSURL'];
};
declare type Tracking = {
    __typename?: 'Tracking';
    facebookBrowserID?: Maybe<Scalars['String']>;
    facebookClickID?: Maybe<Scalars['String']>;
    ipAddress?: Maybe<Scalars['AWSIPAddress']>;
    userAgent?: Maybe<Scalars['String']>;
};
declare type Transaction = Node & {
    __typename?: 'Transaction';
    /** Amount is positive for a payment and negative for a refund (the opposite of a booking line) */
    amount: Price;
    /** Only shown for refunds - this is the ID of the original transaction that is being refunded here. */
    baseTransaction?: Maybe<Ref>;
    booking: Booking;
    card?: Maybe<TransactionCard>;
    created: Scalars['AWSDateTime'];
    /**
     * The exchange rate used to convert the transaction price to GBP at the time of
     * the transaction.
     */
    gbpExchangeRate: Scalars['String'];
    /** Host amount is positive for a payment and negative for a refund (the opposite of a booking line) */
    hostAmount?: Maybe<Price>;
    id: Scalars['ID'];
    processor: TransactionProcessor;
    remoteID: Scalars['ID'];
    /** The remote ID of the host payment (__legacy TMT payments only__) */
    remoteIDHost?: Maybe<Scalars['ID']>;
    success: Scalars['Boolean'];
    /** Trust My Travel details (V2 API) */
    tmt?: Maybe<TMTDetails>;
    type: TransactionType;
};
declare type TransactionCard = {
    __typename?: 'TransactionCard';
    /** Billing address including cardholder name */
    address?: Maybe<Address>;
    cardType?: Maybe<Scalars['String']>;
    lastFourDigits?: Maybe<Scalars['String']>;
};
export { TransactionProcessor };
export { TransactionType };
export { TransportMode };
declare type Trip = Node & {
    __typename?: 'Trip';
    active: Status;
    activities?: Maybe<Array<TripActivityType>>;
    /**
     * This will allow us to add a phantom group to the trip, so that trips can be
     * discovered by the user, when searched for, without having to add groups to
     * the trip. This is useful for trips that can be booked privately.
     */
    addAPhantomGroup?: Maybe<Scalars['Boolean']>;
    address: Address;
    allowPrivateGroups?: Maybe<Scalars['Boolean']>;
    automatedMessages?: Maybe<Array<TripAutomatedMessage>>;
    commissionOverrides: CommissionOverridesTripsConnection;
    coupons?: Maybe<CouponConnection>;
    daysBreakdown?: Maybe<DaysBreakdown>;
    description: Scalars['String'];
    difficultyLevel?: Maybe<Scalars['Int']>;
    endTimezone: Scalars['String'];
    excludes?: Maybe<Array<Scalars['String']>>;
    faqs: TripFAQConnection;
    /** 2 or 3 featured images for the trip */
    featuredImages?: Maybe<Array<Media>>;
    groups: GroupConnection;
    host: Host;
    id: Scalars['ID'];
    /** The image to be used as cover image for the trip */
    image: Media;
    includes?: Maybe<Array<Scalars['String']>>;
    isRecentTrip?: Maybe<Scalars['Boolean']>;
    itinerary: TripItineraryItemConnection;
    meals?: Maybe<TripMeals>;
    /** All media for a Trip */
    media?: Maybe<MediaConnection>;
    /**
     * Get all groups, from all trips within a date range, by defaults it grabs all
     * groups in the future
     */
    minimumPrice?: Maybe<MinimumPriceWithDiscount>;
    notice?: Maybe<Scalars['String']>;
    overlayText?: Maybe<Scalars['String']>;
    pageSettings?: Maybe<TripPageSettings>;
    phantomGroupPrice?: Maybe<Scalars['Int']>;
    /** The message sent to the guest after they make a booking successfully */
    postBookingAutomatedMessage?: Maybe<AutomatedMessage>;
    preventGuestCancellation?: Maybe<Scalars['Boolean']>;
    preventGuestCancellationMessage?: Maybe<Scalars['String']>;
    reviewStatistics?: Maybe<ReviewStatistics>;
    reviews: ReviewConnection;
    reviewsSummary: ReviewsSummary;
    /** @deprecated Use `urlSlug`. */
    slug: Scalars['String'];
    startTimezone: Scalars['String'];
    tags?: Maybe<Array<Scalars['String']>>;
    testimonials?: Maybe<Array<Testimonial>>;
    title: Scalars['String'];
    tripFormRequiredInformation: TripFormRequiredInformation;
    tripVideoURL?: Maybe<Scalars['AWSURL']>;
    tripVideoURLThumbnail?: Maybe<Media>;
    urlSlug: Scalars['String'];
    wayPoints: WayPointsConnection;
    /** User's wishlist for this trip */
    wishlist: WishlistConnection;
};
export { TripActivityType };
declare type TripAutomatedMessage = {
    __typename?: 'TripAutomatedMessage';
    /** The date and time that this message was created. */
    created: Scalars['AWSDateTime'];
    /** TripID plus the message number */
    id: Scalars['ID'];
    /** The trip that this message is associated with. */
    message: Scalars['String'];
    /** We currently have two automated messages. This is the number of the message. */
    messageNumber: TripAutomatedMessageNumber;
    /** The number of weeks from the start of the trip that this message should be sent. */
    weeksFromStart: Scalars['Int'];
};
export { TripAutomatedMessageNumber };
declare type TripConnection = {
    __typename?: 'TripConnection';
    items?: Maybe<Array<Maybe<Trip>>>;
    nextToken?: Maybe<Scalars['String']>;
};
declare type TripFAQ = Node & {
    __typename?: 'TripFAQ';
    answer: Scalars['String'];
    category?: Maybe<TripFAQsCategories>;
    id: Scalars['ID'];
    links?: Maybe<Array<TripFAQLink>>;
    question: Scalars['String'];
    readCount?: Maybe<Scalars['Int']>;
    videos?: Maybe<Array<TripFAQVideo>>;
    weight: Scalars['Int'];
};
declare type TripFAQConnection = {
    __typename?: 'TripFAQConnection';
    items: Array<TripFAQ>;
};
declare type TripFAQLink = {
    __typename?: 'TripFAQLink';
    title: Scalars['String'];
    url: Scalars['AWSURL'];
};
declare type TripFAQVideo = {
    __typename?: 'TripFAQVideo';
    url: Scalars['AWSURL'];
};
export { TripFAQsCategories };
declare type TripForm = {
    __typename?: 'TripForm';
    additionalInformation?: Maybe<Scalars['String']>;
    /**
     * Departure Point
     *
     * The location & time, for where the guest will depart from the trip.
     */
    departPoint?: Maybe<WayPoint>;
    dietaryRequirements?: Maybe<Scalars['String']>;
    emergencyContact?: Maybe<TripFormEmergencyContact>;
    medicalInformation?: Maybe<Scalars['String']>;
    /**
     * Meet Point
     *
     * The location & time, for where the guest will meet the host.
     */
    meetPoint?: Maybe<WayPoint>;
    passportInformation?: Maybe<TripFormPassportInformation>;
    travelInformation?: Maybe<TripFormTravelInformation>;
    travelInsurance?: Maybe<TripFormTravelInsurance>;
};
declare type TripFormEmergencyContact = {
    __typename?: 'TripFormEmergencyContact';
    name: Scalars['String'];
    phone: Scalars['String'];
    relationship?: Maybe<Scalars['String']>;
};
declare type TripFormPassportInformation = {
    __typename?: 'TripFormPassportInformation';
    dateOfBirth: Scalars['AWSDate'];
    expiryDate: Scalars['AWSDate'];
    familyName: Scalars['String'];
    gender: Gender;
    givenName: Scalars['String'];
    issueDate?: Maybe<Scalars['AWSDate']>;
    nationality?: Maybe<Nationality>;
    passportNumber: Scalars['String'];
};
/**
 * Trip Form required information
 *
 * Shows which sections of a trip form are required, as well as any additional information that is required.
 */
declare type TripFormRequiredInformation = Node & {
    __typename?: 'TripFormRequiredInformation';
    /**
     * Additional Information
     *
     * Any additional information that the host requires from the guest - e.g. a question such as "Would you like to be
     * picked up from location A or location B?"
     */
    additionalInformation?: Maybe<Scalars['String']>;
    /**
     * Days before travel that the information is due
     *
     * The guest/booking owner will be reminded to fill in this required information before this date.
     */
    daysBeforeTravelDue: Scalars['Int'];
    emergencyContact: Scalars['Boolean'];
    /**
     * Trip Form Required Information ID
     *
     * UUID of the format tfri_UUID, primarily used for caching (as we update using the tripID instead of this).
     */
    id: Scalars['ID'];
    passportInformation: Scalars['Boolean'];
    travelInformation: Scalars['Boolean'];
    travelInsurance: Scalars['Boolean'];
    tripID: Scalars['String'];
};
declare type TripFormTravelInformation = {
    __typename?: 'TripFormTravelInformation';
    arrivalFlightNumber?: Maybe<Scalars['String']>;
    /**
     * Arrival Time
     *
     * Local time (not UTC).
     */
    arrivalTime?: Maybe<Scalars['String']>;
    arrivalTransportMode?: Maybe<TransportMode>;
    departureFlightNumber?: Maybe<Scalars['String']>;
    /**
     * Departure Time
     *
     * Local time (not UTC).
     */
    departureTime?: Maybe<Scalars['String']>;
    departureTransportMode?: Maybe<TransportMode>;
};
declare type TripFormTravelInsurance = {
    __typename?: 'TripFormTravelInsurance';
    company: Scalars['String'];
    phone?: Maybe<Scalars['String']>;
    policyNumber: Scalars['String'];
};
declare type TripItineraryItem = Node & {
    __typename?: 'TripItineraryItem';
    day: Scalars['Int'];
    description: Scalars['String'];
    id: Scalars['ID'];
    media?: Maybe<MediaConnection>;
    title: Scalars['String'];
    wayPoints: WayPointsConnection;
};
declare type TripItineraryItemConnection = {
    __typename?: 'TripItineraryItemConnection';
    items: Array<TripItineraryItem>;
};
declare type TripMeals = {
    __typename?: 'TripMeals';
    /** The number of breakfasts included in the trip */
    breakfast?: Maybe<Scalars['Int']>;
    /** The number of dinners included in the trip */
    dinner?: Maybe<Scalars['Int']>;
    /** The number of lunches included in the trip */
    lunch?: Maybe<Scalars['Int']>;
};
declare type TripPagePromotionBanner = {
    __typename?: 'TripPagePromotionBanner';
    link: Scalars['String'];
    text: Scalars['String'];
};
declare type TripPageSettings = {
    __typename?: 'TripPageSettings';
    /**
     * Whether the trip is discontinued or not and if so, what which trips are
     * recommended instead
     */
    discontinued?: Maybe<DiscontinuedTrip>;
    promotionsBanner?: Maybe<TripPagePromotionBanner>;
    /** A list of recommended trips to display on the trip page */
    recommendedTrips?: Maybe<Array<RecommendedTrip>>;
    seo?: Maybe<SEO>;
};
/**
 * User
 *
 * Broadly follows the OpenID Connect specification (but with our own address format).
 */
declare type User = Node & {
    __typename?: 'User';
    address?: Maybe<Address>;
    bio?: Maybe<Scalars['String']>;
    birthDate?: Maybe<Scalars['AWSDate']>;
    bookings: BookingConnection;
    chatInbox: ChatConversationConnection;
    chatMessageCount: ChatUserMessageCount;
    cognitoSub?: Maybe<Scalars['String']>;
    created: Scalars['AWSDateTime'];
    credits?: Maybe<Array<Maybe<UserCreditsSummary>>>;
    email: Scalars['AWSEmail'];
    familyName: Scalars['String'];
    gender?: Maybe<Gender>;
    givenName: Scalars['String'];
    /**
     * Guest on Bookings
     *
     * The user may be a guest on bookings owned by themselves (i.e. they are travelling for a booking they paid for), or
     * bookings owned by another user (another user is paying for their booking). This query property will return all the guest
     * entities for a user, which can in turn be used to get all the bookings that the user is a guest for.
     */
    guestOnBookings: GuestConnection;
    hostRoles: UserHostRolesConnection;
    id: Scalars['ID'];
    /** All media uploaded by a user */
    media?: Maybe<MediaConnection>;
    notifications?: Maybe<ActivityStreamConnection>;
    phone?: Maybe<Scalars['String']>;
    /** Profile picture of the user */
    picture?: Maybe<Media>;
    skyhookClubTier: SkyhookClubTiers;
    /**
     * The total amount of credits for this user, for all currencies, after currency
     * conversion.
     *
     * For example, if a user has 10 credits in USD, 5 credits in EUR, and 3 credits
     * in GBP, this would return the total amount of credits in USD, after converting
     * the EUR and GBP credits to USD.
     *
     * PLEASE NOTE, this doesn't save the converted amount anywhere, it's just a
     * calculation based on the current exchange rates, to help determine if the user
     * has enough credits to place an order.
     *
     * After an order is placed, only used credits will be converted to relevant
     * currency and deducted from the user's account. The rest of the credits will
     * remain in their original currency, and will be converted only when used.
     */
    totalCredits: UserCreditsSummary;
    /**
     * Users waiting list
     *
     * View groups on a users waiting list
     */
    waitList: WaitListConnection;
    wishlist: WishlistConnection;
};
declare type UserCredit = Node & {
    __typename?: 'UserCredit';
    amountZD: Scalars['Int'];
    /**
     * The booking ID, if the credit was added as a result of a booking
     *
     * We are exposing this field in the schema, so we can link to booking page from
     * credit history page. Adding a booking field (with resolver) is not necessary for the time
     * being and can be added later if needed.
     */
    bookingID?: Maybe<Scalars['ID']>;
    /**
     * When credits are given to a user, they may be given after completing a trip as
     * part of the Skyhook Fan Club program. This field will be populated with the
     * details of the entry in the Skyhook Fan Club program.
     */
    clubCredit?: Maybe<SkyhookFanClubCredits>;
    /** The date the credit was added */
    completed: Scalars['AWSDateTime'];
    created: Scalars['AWSDateTime'];
    currency: GlobalCurrencies;
    /** The credit's unique identifier. */
    id: Scalars['ID'];
    /** Note about the credit, why it was added, etc. */
    note?: Maybe<Scalars['String']>;
    /** The running total, up to this point. Calculated on the fly */
    runningTotal: Scalars['Int'];
    updated: Scalars['AWSDateTime'];
};
declare type UserCreditConnection = {
    __typename?: 'UserCreditConnection';
    items?: Maybe<Array<UserCredit>>;
    nextToken?: Maybe<Scalars['String']>;
};
/**
 * A summary of a user's credits for a specific currency.
 *
 * For example, a user may have 10 credits in USD, 5 credits in EUR, and 3 credits
 * in GBP.
 *
 * This type would return a list of 3 credits, one for each currency, which will be
 * a sum of all existing items for each currency.
 */
declare type UserCreditsSummary = {
    __typename?: 'UserCreditsSummary';
    /** The total amount of credits for this currency. */
    amountZD: Scalars['Int'];
    currency: GlobalCurrencies;
    /**
     * A list of transactions for credits for this currency, as they were added and
     * consumed.
     */
    history?: Maybe<UserCreditConnection>;
};
declare type UserHostRolesConnection = {
    __typename?: 'UserHostRolesConnection';
    items?: Maybe<Array<HostRole>>;
};
/**
 * User Public profile
 *
 * Includes some key fields for a user that can be viewed by anyone.
 *
 * Note that with caching (e.g. Apollo InMemory cache) this will typically be cached separately from the User type, which
 * means that if you are updating any values for a User you may also want to update the cache for this UserPublicProfile.
 * However in most cases it is unlikely to cause issues.
 */
declare type UserPublicProfile = {
    __typename?: 'UserPublicProfile';
    address?: Maybe<Address>;
    bio?: Maybe<Scalars['String']>;
    givenName: Scalars['String'];
    id: Scalars['ID'];
    /** The profile picture of the user */
    picture?: Maybe<Media>;
};
declare type WaitList = Node &