export declare namespace Types {
    type Locale = 'de-DE' | 'en-AU' | 'en-CA' | 'en-GB' | 'en-IN' | 'en-US' | 'es-ES' | 'es-MX' | 'fr-CA' | 'fr-FR' | 'it-IT' | 'ja-JP';
    type dateTime = string;
    interface Person {
        name: string;
    }
    type MediaType = 'BOOK' | 'EPISODE' | 'ALBUM' | 'SINGLE' | 'MOVIE' | 'GAME';
    type DistributionMethod = 'STREAM' | 'AIR' | 'RELEASE' | 'PREMIERE' | 'DROP';
    interface Thing {
        name: 'localizedattribute:providerName';
    }
    interface Availability {
        startTime: Types.dateTime;
        provider?: Thing;
        method: DistributionMethod;
    }
    interface CreativeWork {
        name: string;
        contentType: MediaType;
    }
    type OfferType = 'MATCH' | 'REMATCH' | 'GAME';
    type InviteType = 'CHALLENGE' | 'INVITE';
    type RelationshipToInvitee = 'FRIEND' | 'CONTACT';
    interface GameInvite {
        inviter: Person;
        relationshipToInvitee: RelationshipToInvitee;
        inviteType: InviteType;
    }
    interface Game {
        offer: OfferType;
        name: string;
    }
    type ConfirmationStatus = 'CONFIRMED' | 'CANCELED' | 'RESCHEDULED' | 'REQUESTED' | 'CREATED' | 'UPDATED';
    type OccasionType = 'RESERVATION_REQUEST' | 'RESERVATION' | 'APPOINTMENT_REQUEST' | 'APPOINTMENT';
    interface ConfirmationState {
        confirmationStatus: ConfirmationStatus;
    }
    interface Ogranization {
        name: string;
    }
    interface Skill {
        name: string;
    }
    interface Occasion {
        occasionType: OccasionType;
        subject: string;
        provider: Ogranization;
        bookingTime: Types.dateTime;
        broker?: Skill;
    }
    interface ParcelDelivery {
        expectedArrival: Types.dateTime;
    }
    interface OrderState {
        status: OrderStatus;
        enterTimestamp?: Types.dateTime;
        deliveryDetails?: ParcelDelivery;
    }
    interface Order {
        seller: {
            name: string;
        };
    }
    type OrderStatus = 'PREORDER_RECEIVED' | 'ORDER_RECEIVED' | 'ORDER_PREPARING' | 'ORDER_SHIPPED' | 'ORDER_OUT_FOR_DELIVERY' | 'ORDER_OUT_FOR_DELIVERY' | 'ORDER_DELIVERED';
    type GarbageType = 'BOTTLES' | 'BULKY' | 'BURNABLE' | 'CANS' | 'CLOTHING' | 'COMPOSTABLE' | 'CRUSHABLE' | 'GARDEN_WASTE' | 'GLASS' | 'HAZARDOUS' | 'HOME_APPLIANCES' | 'KITCHEN_WASTE' | 'LANDFILL' | 'PET_BOTTLES' | 'RECYCLABLE_PLASTICS' | 'WASTE_PAPER';
    type DayOfWeek = 'MONDAY' | 'TUESDAY' | 'WEDNESDAY' | 'THURSDAY' | 'FRIDAY' | 'SATURDAY' | 'SUNDAY';
    interface TrashCollectionAlert {
        garbageTypes: GarbageType[];
        collectionDayOfWeek: DayOfWeek;
    }
    type WeatherAlertType = 'TORNADO' | 'HURRICANE' | 'SNOW_STORM' | 'THUNDER_STORM';
    interface WeatherAlert {
        source?: string;
        alertType: WeatherAlertType;
    }
    interface Goal {
        scoreEarned: number;
        teamName: string;
    }
    interface SportsEvent {
        eventLeague: Soccer;
        homeTeamStatistic: GameStatistic;
        awayTeamStatistic: GameStatistic;
    }
    interface SportsTeam {
        name: string;
    }
    interface GameStatistic {
        team: SportsTeam;
        score: number;
    }
    interface Soccer {
        name: string;
    }
    interface MessageState {
        status: MessageStatus;
        freshness?: MessageFreshness;
    }
    type MessageStatus = 'UNREAD' | 'FLAGGED';
    type MessageFreshness = 'NEW' | 'OVERDUE';
    type MessageUrgent = 'URGENT';
    interface MessageGroup {
        creator: Types.Person;
        count: number;
        urgency?: MessageUrgent;
    }
    interface LocalizedAttribute {
        locale: Locale;
        [name: string]: string;
    }
    type LocalizedAttributes = LocalizedAttribute[];
}
export declare namespace event {
    interface Props<E = EventName, P = Payload> {
        name: E;
        payload: P;
    }
    type EventName = WeatherAlert.EventName | SportsEvent.EventName | MessageAlert.EventName | OrderStatus.EventName | Occasion.EventName | MediaContent.EventName | SocialGameInvite.EventName | TrashCollectionAlert.EventName;
    type Payload = TrashCollectionAlert.Payload | WeatherAlert.Payload | SportsEvent.Payload | MessageAlert.Payload | OrderStatus.Payload | Occasion.Payload | MediaContent.Payload | SocialGameInvite.Payload;
    namespace TrashCollectionAlert {
        type EventName = Activated.EventName;
        type Payload = Activated.Payload;
        namespace Activated {
            type EventName = 'AMAZON.TrashCollectionAlert.Activated';
            interface Payload {
                alert: Types.TrashCollectionAlert;
            }
        }
    }
    namespace WeatherAlert {
        type EventName = Activated.EventName;
        type Payload = Activated.Payload;
        namespace Activated {
            type EventName = 'AMAZON.WeatherAlert.Activated';
            interface Payload {
                weatherAlert: Types.WeatherAlert;
            }
        }
    }
    namespace SportsEvent {
        type EventName = Updated.EventName;
        type Payload = Updated.Payload;
        namespace Updated {
            type EventName = 'AMAZON.SportsEvent.Updated';
            interface Payload {
                update?: Types.Goal;
                sportsEvent: Types.SportsEvent;
            }
        }
    }
    namespace MessageAlert {
        type EventName = Activated.EventName;
        type Payload = Activated.Payload;
        namespace Activated {
            type EventName = 'AMAZON.MessageAlert.Activated';
            interface Payload {
                state: Types.MessageState;
                messageGroup: Types.MessageGroup;
            }
        }
    }
    namespace OrderStatus {
        type EventName = Updated.EventName;
        type Payload = Updated.Payload;
        namespace Updated {
            type EventName = 'AMAZON.OrderStatus.Updated';
            interface Payload {
                state: Types.OrderState;
                order: Types.Order;
            }
        }
    }
    namespace Occasion {
        type EventName = Updated.EventName;
        type Payload = Updated.Payload;
        namespace Updated {
            type EventName = 'AMAZON.Occasion.Updated';
            interface Payload {
                state: Types.ConfirmationState;
                occasion: Types.Occasion;
            }
        }
    }
    namespace MediaContent {
        type EventName = Available.EventName;
        type Payload = Available.Payload;
        namespace Available {
            type EventName = 'AMAZON.MediaContent.Available';
            interface Payload {
                availability: Types.Availability;
                content: Types.CreativeWork;
            }
        }
    }
    namespace SocialGameInvite {
        type EventName = Available.EventName;
        type Payload = Available.Payload;
        namespace Available {
            type EventName = 'AMAZON.SocialGameInvite.Available';
            interface Payload {
                invite: Types.GameInvite;
                game: Types.Game;
            }
        }
    }
}
export declare namespace client {
    interface Class {
        getAccessToken: Promise<client.AuthResponse>;
    }
    type ClientId = string;
    type ClientSecret = string;
    type APIURL = 'https://api.amazonalexa.com/v1/proactiveEvents/' | 'https://api.eu.amazonalexa.com/v1/proactiveEvents/' | 'https://api.fe.amazonalexa.com/v1/proactiveEvents/';
    type DevAPIURL = 'https://api.amazonalexa.com/v1/proactiveEvents/stages/development' | 'https://api.eu.amazonalexa.com/v1/proactiveEvents/stages/development' | 'https://api.fe.amazonalexa.com/v1/proactiveEvents/stages/development';
    type APIEndpoint = APIURL | DevAPIURL;
    type ApiRegion = 'FE' | 'US' | 'EU';
    interface ClientConfig {
        clientId: ClientId;
        clientSecret: ClientSecret;
        apiEndpont?: APIEndpoint;
        apiRegion?: ApiRegion;
        isProduction?: boolean;
    }
    interface AuthResponse {
        'access_token': string;
        'expires_in': number;
        'scope': 'alexa::proactive_events';
        'token_type': 'Bearer';
    }
    type AudienceType = 'Unicast' | 'Multicast';
    interface AudiencePayload {
        user: string;
    }
    interface RelevantAudience {
        type: AudienceType;
        payload?: AudiencePayload;
    }
    interface RequstBody {
        timestamp: string;
        expiryTime: string;
        event: {
            payload: event.Payload;
            name: event.EventName;
            relevantAudience: RelevantAudience;
            refereneId: string;
        };
    }
    interface Response {
        statusCode: number;
        message: string;
        request: RequstBody;
    }
}
export declare namespace interfaces {
    interface PayloadBuilder {
        getEventName(): event.EventName;
        getParameter(): event.Props;
    }
    namespace LocalizedAttributes {
        interface Factory {
            putLocalizedAttribute(locale: Types.Locale, key: string, text: string): Factory;
            getLocalizedAttributes(): Types.LocalizedAttributes;
        }
    }
    namespace TrashCollectionAlert {
        type PayloadBuilder = Activated.PayloadBuilder;
        namespace Activated {
            interface PayloadBuilder {
                putAlert(alert: Types.TrashCollectionAlert): PayloadBuilder;
                putGarbageTypes(garbageTypes: Types.GarbageType[]): PayloadBuilder;
                addGarbageType(garbageType: Types.GarbageType): PayloadBuilder;
                setCollectionDayOfWeek(collectionDayOfWeek: Types.DayOfWeek): PayloadBuilder;
                getEventName(): event.TrashCollectionAlert.Activated.EventName;
                getPayload(): event.TrashCollectionAlert.Payload;
                getParameter(): event.Props<event.TrashCollectionAlert.EventName, event.TrashCollectionAlert.Payload>;
            }
        }
    }
    namespace WeatherAlert {
        type PayloadBuilder = Activated.PayloadBuilder;
        namespace Activated {
            interface PayloadBuilder extends interfaces.PayloadBuilder {
                setAlertSource(source?: string): PayloadBuilder;
                setAlertType(type: Types.WeatherAlertType): PayloadBuilder;
                getEventName(): event.WeatherAlert.Activated.EventName;
                getParameter(): event.Props<event.WeatherAlert.Activated.EventName, event.WeatherAlert.Activated.Payload>;
                getPayload(): event.WeatherAlert.Activated.Payload;
            }
        }
    }
    namespace SportsEvent {
        type PayloadBuilder = Updated.PayloadBuilder;
        namespace Updated {
            interface PayloadBuilder extends interfaces.PayloadBuilder {
                updateGoalData(teamName: string, score: number): PayloadBuilder;
                setEventLeagueName(name: string): PayloadBuilder;
                setHomeTeamStatistic(teamName: string, score: number): PayloadBuilder;
                setAwayTeamStatistic(teamName: string, score: number): PayloadBuilder;
                getEventName(): event.SportsEvent.Updated.EventName;
                getParameter(): event.Props<event.SportsEvent.Updated.EventName, event.SportsEvent.Updated.Payload>;
                getPayload(): event.SportsEvent.Updated.Payload;
            }
        }
    }
    namespace MessageAlert {
        type PayloadBuilder = Activated.PayloadBuilder;
        namespace Activated {
            interface PayloadBuilder extends interfaces.PayloadBuilder {
                setMessageCreator(name: string): PayloadBuilder;
                setMessageCount(count: number): PayloadBuilder;
                setMessageUrgency(urgency?: Types.MessageUrgent): PayloadBuilder;
                setMessageFreshness(freshness: Types.MessageFreshness): PayloadBuilder;
                setMessageStatus(messageStatus: Types.MessageStatus): PayloadBuilder;
                getEventName(): event.MessageAlert.Activated.EventName;
                getParameter(): event.Props<event.MessageAlert.Activated.EventName, event.MessageAlert.Activated.Payload>;
                getPayload(): event.MessageAlert.Payload;
            }
        }
    }
    namespace OrderStatus {
        type PayloadBuilder = Updated.PayloadBuilder;
        namespace Updated {
            interface PayloadBuilder extends interfaces.PayloadBuilder {
                setOrderStatus(status: Types.OrderStatus): PayloadBuilder;
                setEnterTimestamp(date: Date): PayloadBuilder;
                setExpectedArrival(date: Date): PayloadBuilder;
                updateSellerName(name: string): PayloadBuilder;
                getEventName(): event.OrderStatus.EventName;
                getPayload(): event.OrderStatus.Updated.Payload;
                getParameter(): event.Props<event.OrderStatus.Updated.EventName, event.OrderStatus.Updated.Payload>;
            }
        }
    }
    namespace Occasion {
        type PayloadBuilder = Updated.PayloadBuilder;
        namespace Updated {
            interface PayloadBuilder extends interfaces.PayloadBuilder {
                updateConfirmationStatus(status: Types.ConfirmationStatus): PayloadBuilder;
                setOccasionType(type: Types.OccasionType): PayloadBuilder;
                setSubject(subject: string): PayloadBuilder;
                setProviderName(name: string): PayloadBuilder;
                setBookingTime(date: Date): PayloadBuilder;
                setBrokerName(name: string): PayloadBuilder;
                getEventName(): event.Occasion.Updated.EventName;
                getConfirmationState(): Types.ConfirmationState;
                getConfirmationStatus(): Types.ConfirmationStatus;
                getPayload(): event.Occasion.Payload;
                getParameter(): event.Props<event.Occasion.Updated.EventName, event.Occasion.Updated.Payload>;
            }
        }
    }
    namespace MediaContent {
        namespace Available {
            interface PayloadBuilder {
                setContentName(name?: string): PayloadBuilder;
                setMediaType(type: Types.MediaType): PayloadBuilder;
                getEventName(): event.MediaContent.EventName;
                setStartTime(date: Date): PayloadBuilder;
                setDistributionMethod(method: Types.DistributionMethod): PayloadBuilder;
                setProvider(providerName: string): PayloadBuilder;
                getPayload(): event.MediaContent.Payload;
                getParameter(): event.Props<event.MediaContent.EventName, event.MediaContent.Available.Payload>;
            }
        }
    }
    namespace SocialGameInvite {
        namespace Available {
            interface PayloadBuilder extends interfaces.PayloadBuilder {
                setInviterName(name: string): PayloadBuilder;
                setRelationshipToInvitee(relation: Types.RelationshipToInvitee): PayloadBuilder;
                setInviteType(type: Types.InviteType): PayloadBuilder;
                setGameName(name: string): PayloadBuilder;
                setGameOfferName(name: Types.OfferType): PayloadBuilder;
                getEventName(): event.SocialGameInvite.Available.EventName;
                getPayload(): event.SocialGameInvite.Available.Payload;
            }
        }
    }
}