ask-sdk-model

  • Version 1.86.0
  • Published
  • 654 kB
  • No dependencies
  • Apache-2.0 license

Install

npm i ask-sdk-model
yarn add ask-sdk-model
pnpm add ask-sdk-model

Overview

Model package for Alexa Skills Kit SDK

Index

Functions

Interfaces

Type Aliases

Namespaces

Functions

function createUserAgent

createUserAgent: (packageVersion: string, customUserAgent: string) => string;
  • function creating an AskSdk user agent.

    Parameter packageVersion

    Parameter customUserAgent

Interfaces

interface Application

interface Application {}
  • An object containing an application ID. This is used to verify that the request was intended for your service.

property 'applicationId'

applicationId: string;
  • A string representing the application identifier for your skill.

interface ConnectionCompleted

interface ConnectionCompleted {}
  • Represents the status and result needed to resume a skill's suspended session.

property 'result'

result?: any;
  • This is the result object to resume the skill's suspended session.

property 'status'

status?: Status;

    property 'token'

    token?: string;
    • This is an echo back string that skills send when during Connections.StartConnection directive. They will receive it when they get the SessionResumedRequest. It is never sent to the skill handling the request.

    property 'type'

    type: 'ConnectionCompleted';

      interface Context

      interface Context {}

      property 'Alexa.DataStore.PackageManager'

      'Alexa.DataStore.PackageManager'?: interfaces.alexa.datastore.packagemanager.PackageManagerState;
      • Provides the current state for the Alexa.DataStore.PackageManager interface.

      property 'Alexa.Presentation.APL'

      'Alexa.Presentation.APL'?: interfaces.alexa.presentation.apl.RenderedDocumentState;
      • Provides the current state for the Alexa.Presentation.APL interface.

      property 'Alexa.Presentation'

      'Alexa.Presentation'?: interfaces.alexa.presentation.PresentationState;
      • Provides the current state for the Alexa.Presentation interface.

      property 'AppLink'

      AppLink?: interfaces.applink.AppLinkState;
      • Provides the current state for app link capability.

      property 'AudioPlayer'

      AudioPlayer?: interfaces.audioplayer.AudioPlayerState;
      • Provides the current state for the AudioPlayer interface.

      property 'Automotive'

      Automotive?: interfaces.automotive.AutomotiveState;
      • Provides the automotive specific information of the device.

      property 'Display'

      Display?: interfaces.display.DisplayState;
      • Provides the current state for the Display interface.

      property 'Experimentation'

      Experimentation?: interfaces.alexa.experimentation.ExperimentationState;
      • Provides the current experimentation state

      property 'Extensions'

      Extensions?: interfaces.alexa.extension.ExtensionsState;
      • Provides the current state for Extensions interface

      property 'Geolocation'

      Geolocation?: interfaces.geolocation.GeolocationState;
      • Provides the last gathered geolocation information of the device.

      property 'System'

      System: interfaces.system.SystemState;
      • Provides information about the current state of the Alexa service and the device interacting with your skill.

      property 'Viewport'

      Viewport?: interfaces.viewport.ViewportState;
      • Provides the characteristics of a device's viewport.

      property 'Viewports'

      Viewports?: Array<interfaces.viewport.TypedViewportState>;
      • This object contains a list of viewports characteristics related to the device's viewports.

      interface Device

      interface Device {}
      • An object providing information about the device used to send the request. The device object contains both deviceId and supportedInterfaces properties. The deviceId property uniquely identifies the device. The supportedInterfaces property lists each interface that the device supports. For example, if supportedInterfaces includes AudioPlayer {}, then you know that the device supports streaming audio using the AudioPlayer interface.

      property 'deviceId'

      deviceId: string;
      • The deviceId property uniquely identifies the device. This identifier is scoped to a skill. Normally, disabling and re-enabling a skill generates a new identifier.

      property 'persistentEndpointId'

      persistentEndpointId?: string;
      • A persistent identifier for the Endpoint ID where the skill request is issued from. An endpoint represents an Alexa-connected Endpoint (like an Echo device, or an application) with which an Alexa customer can interact rather than a physical device, so it could represent applications on your fire TV or your Alexa phone app. The persistentEndpointId is a string that represents a unique identifier for the endpoint in the context of a request. It is in the Amazon Common Identifier format "amzn1.alexa.endpoint.did.{id}". This identifier space is scoped to a vendor, therefore it will stay the same regardless of skill enablement.

      property 'supportedInterfaces'

      supportedInterfaces: SupportedInterfaces;
      • Lists each interface that the device supports. For example, if supportedInterfaces includes AudioPlayer {}, then you know that the device supports streaming audio using the AudioPlayer interface

      interface Intent

      interface Intent {}
      • An object that represents what the user wants.

      property 'confirmationStatus'

      confirmationStatus: IntentConfirmationStatus;

        property 'name'

        name: string;
        • A string representing the name of the intent.

        property 'slots'

        slots?: {
        [key: string]: Slot;
        };
        • A map of key-value pairs that further describes what the user meant based on a predefined intent schema. The map can be empty.

        interface IntentRequest

        interface IntentRequest {}
        • An IntentRequest is an object that represents a request made to a skill based on what the user wants to do.

        property 'dialogState'

        dialogState: DialogState;
        • Enumeration indicating the status of the multi-turn dialog. This property is included if the skill meets the requirements to use the Dialog directives. Note that COMPLETED is only possible when you use the Dialog.Delegate directive. If you use intent confirmation, dialogState is considered COMPLETED if the user denies the entire intent (for instance, by answering “no” when asked the confirmation prompt). Be sure to also check the confirmationStatus property on the Intent object before fulfilling the user’s request.

        property 'intent'

        intent: Intent;
        • An object that represents what the user wants.

        property 'locale'

        locale?: string;
        • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

        property 'requestId'

        requestId: string;
        • Represents the unique identifier for the specific request.

        property 'timestamp'

        timestamp: string;
        • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

        property 'type'

        type: 'IntentRequest';

          interface LaunchRequest

          interface LaunchRequest {}
          • Represents that a user made a request to an Alexa skill, but did not provide a specific intent.

          property 'locale'

          locale?: string;
          • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

          property 'requestId'

          requestId: string;
          • Represents the unique identifier for the specific request.

          property 'task'

          task?: Task;

            property 'timestamp'

            timestamp: string;
            • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

            property 'type'

            type: 'LaunchRequest';

              interface ListSlotValue

              interface ListSlotValue {}
              • Slot value containing a list of other slot value objects.

              property 'type'

              type: 'List';

                property 'values'

                values: Array<SlotValue>;
                • An array containing the values captured for this slot.

                interface Permissions

                interface Permissions {}
                • Contains a consentToken allowing the skill access to information that the customer has consented to provide, such as address information. Note that the consentToken is deprecated. Use the apiAccessToken available in the context object to determine the user’s permissions.

                property 'consentToken'

                consentToken?: string;
                • A token listing all the permissions granted for this user.

                property 'scopes'

                scopes?: {
                [key: string]: Scope;
                };
                • A map where the key is a LoginWithAmazon(LWA) scope and value is a list of key:value pairs which describe the state of user actions on the LWA scope. For e.g. "scopes" :{ "alexa::devices:all:geolocation:read":{"status":"GRANTED"}} This value of "alexa::devices:all:geolocation:read" will determine if the Geolocation data access is granted by the user, or else it will show a card of type AskForPermissionsConsent to the user to get this permission.

                interface Person

                interface Person {}
                • An object that describes the user (person) who is interacting with Alexa.

                property 'accessToken'

                accessToken?: string;
                • A token identifying the user in another system. This is only provided if the recognized user has successfully linked their skill account with their Alexa profile. The accessToken field will not appear if null.

                property 'personId'

                personId?: string;
                • A string that represents a unique identifier for the person who is interacting with Alexa. The length of this identifier can vary, but is never more than 255 characters. It is generated when a recognized user makes a request to your skill.

                interface RequestEnvelope

                interface RequestEnvelope {}
                • Request wrapper for all requests sent to your Skill.

                property 'context'

                context: Context;
                • The context object provides your skill with information about the current state of the Alexa service and device at the time the request is sent to your service. This is included on all requests. For requests sent in the context of a session (LaunchRequest and IntentRequest), the context object duplicates the user and application information that is also available in the session.

                property 'request'

                request: Request;
                • A request object that provides the details of the user’s request.

                property 'session'

                session?: Session;
                • The session object provides additional context associated with the request.

                property 'version'

                version: string;
                • The version specifier for the request.

                interface Response

                interface Response {}

                property 'apiResponse'

                apiResponse?: any;
                • API response object containing API response value(s)

                property 'canFulfillIntent'

                canFulfillIntent?: canfulfill.CanFulfillIntent;

                  property 'card'

                  card?: ui.Card;

                    property 'directives'

                    directives?: Array<Directive>;

                      property 'experimentation'

                      experimentation?: interfaces.alexa.experimentation.ExperimentTriggerResponse;
                      • Experiment trigger response from skill

                      property 'outputSpeech'

                      outputSpeech?: ui.OutputSpeech;

                        property 'reprompt'

                        reprompt?: ui.Reprompt;

                          property 'shouldEndSession'

                          shouldEndSession?: boolean;

                            interface ResponseEnvelope

                            interface ResponseEnvelope {}

                            property 'response'

                            response: Response;

                              property 'sessionAttributes'

                              sessionAttributes?: {
                              [key: string]: any;
                              };

                                property 'userAgent'

                                userAgent?: string;

                                  property 'version'

                                  version: string;

                                    interface Scope

                                    interface Scope {}
                                    • This is the value of LoginWithAmazon(LWA) consent scope. This object is used as in the key-value pairs that are provided in user.permissions.scopes object

                                    property 'status'

                                    status?: PermissionStatus;

                                      interface Session

                                      interface Session {}
                                      • Represents a single execution of the alexa service

                                      property 'application'

                                      application: Application;

                                        property 'attributes'

                                        attributes?: {
                                        [key: string]: any;
                                        };
                                        • A map of key-value pairs. The attributes map is empty for requests where a new session has started with the property new set to true. When returning your response, you can include data you need to persist during the session in the sessionAttributes property. The attributes you provide are then passed back to your skill on the next request.

                                        property 'new'

                                        new: boolean;
                                        • A boolean value indicating whether this is a new session. Returns true for a new session or false for an existing session.

                                        property 'sessionId'

                                        sessionId: string;
                                        • A string that represents a unique identifier per a user’s active session.

                                        property 'user'

                                        user: User;
                                        • An object that describes the user making the request.

                                        interface SessionEndedError

                                        interface SessionEndedError {}
                                        • An error object providing more information about the error that occurred.

                                        property 'message'

                                        message: string;
                                        • A string providing more information about the error.

                                        property 'type'

                                        type: SessionEndedErrorType;
                                        • A string indicating the type of error that occurred.

                                        interface SessionEndedRequest

                                        interface SessionEndedRequest {}
                                        • A SessionEndedRequest is an object that represents a request made to an Alexa skill to notify that a session was ended. Your service receives a SessionEndedRequest when a currently open session is closed for one of the following reasons: The user says “exit”the user does not respond or says something that does not match an intent defined in your voice interface while the device is listening for the user’s responsean error occurs

                                        property 'error'

                                        error?: SessionEndedError;
                                        • An error object providing more information about the error that occurred.

                                        property 'locale'

                                        locale?: string;
                                        • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                        property 'reason'

                                        reason: SessionEndedReason;
                                        • Describes why the session ended.

                                        property 'requestId'

                                        requestId: string;
                                        • Represents the unique identifier for the specific request.

                                        property 'timestamp'

                                        timestamp: string;
                                        • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                        property 'type'

                                        type: 'SessionEndedRequest';

                                          interface SessionResumedRequest

                                          interface SessionResumedRequest {}
                                          • The request to resume a skill's session and tells the skill why it is resumed.

                                          property 'cause'

                                          cause?: Cause;

                                            property 'locale'

                                            locale?: string;
                                            • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                            property 'requestId'

                                            requestId: string;
                                            • Represents the unique identifier for the specific request.

                                            property 'timestamp'

                                            timestamp: string;
                                            • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                            property 'type'

                                            type: 'SessionResumedRequest';

                                              interface SimpleSlotValue

                                              interface SimpleSlotValue {}
                                              • Slot value containing a single string value and resolutions.

                                              property 'resolutions'

                                              resolutions?: slu.entityresolution.Resolutions;
                                              • Contains the results of entity resolution. These are organized by authority. An authority represents the source for the data provided for the slot. For a custom slot type, the authority is the slot type you defined.

                                              property 'type'

                                              type: 'Simple';

                                                property 'value'

                                                value?: string;
                                                • A string that represents the value the user spoke for the slot. This is the actual value the user spoke, not necessarily the canonical value or one of the synonyms defined for the entity. Note that AMAZON.LITERAL slot values sent to your service are always in all lower case.

                                                interface Slot

                                                interface Slot {}

                                                property 'confirmationStatus'

                                                confirmationStatus: SlotConfirmationStatus;
                                                • Indication of whether an intent or slot has been explicitly confirmed or denied by the user, or neither.

                                                property 'name'

                                                name: string;
                                                • A string that represents the name of the slot.

                                                property 'resolutions'

                                                resolutions?: slu.entityresolution.Resolutions;
                                                • Contains the resultsof entity resolution. These are organized by authority. An authority represents the source for the data provided for the slot. For a custom slot type, the authority is the slot type you defined.

                                                property 'slotValue'

                                                slotValue?: SlotValue;
                                                • Object representing the value of the slot.

                                                property 'value'

                                                value?: string;
                                                • A string that represents the value the user spoke for the slot. This is the actual value the user spoke, not necessarily the canonical value or one of the synonyms defined for the entity. Note that AMAZON.LITERAL slot values sent to your service are always in all lower case.

                                                interface Status

                                                interface Status {}
                                                • Status indicates a high level understanding of the result of an execution.

                                                property 'code'

                                                code: string;
                                                • This is a code signifying the status of the execution initiated by the skill. Protocol adheres to HTTP status codes.

                                                property 'message'

                                                message: string;
                                                • This is a message that goes along with response code that can provide more information about what occurred.

                                                interface SupportedInterfaces

                                                interface SupportedInterfaces {}
                                                • An object listing each interface that the device supports. For example, if supportedInterfaces includes AudioPlayer {}, then you know that the device supports streaming audio using the AudioPlayer interface.

                                                property 'Alexa.Advertisement'

                                                'Alexa.Advertisement'?: interfaces.alexa.advertisement.AlexaAdvertisementInterface;

                                                  property 'Alexa.Presentation.APL'

                                                  'Alexa.Presentation.APL'?: interfaces.alexa.presentation.apl.AlexaPresentationAplInterface;

                                                    property 'Alexa.Presentation.APLT'

                                                    'Alexa.Presentation.APLT'?: interfaces.alexa.presentation.aplt.AlexaPresentationApltInterface;

                                                      property 'Alexa.Presentation.HTML'

                                                      'Alexa.Presentation.HTML'?: interfaces.alexa.presentation.html.AlexaPresentationHtmlInterface;

                                                        property 'AppLink'

                                                        AppLink?: interfaces.applink.AppLinkInterface;

                                                          property 'AudioPlayer'

                                                          AudioPlayer?: interfaces.audioplayer.AudioPlayerInterface;

                                                            property 'Display'

                                                            Display?: interfaces.display.DisplayInterface;

                                                              property 'Geolocation'

                                                              Geolocation?: interfaces.geolocation.GeolocationInterface;

                                                                property 'Navigation'

                                                                Navigation?: interfaces.navigation.NavigationInterface;

                                                                  property 'VideoApp'

                                                                  VideoApp?: interfaces.videoapp.VideoAppInterface;

                                                                    interface Task

                                                                    interface Task {}
                                                                    • This object encapsulates a specific functionality.

                                                                    property 'input'

                                                                    input?: any;
                                                                    • Represents the input to handle the task.

                                                                    property 'name'

                                                                    name: string;
                                                                    • Represents the name of the task.

                                                                    property 'version'

                                                                    version: string;
                                                                    • Represents the version of the task.

                                                                    interface User

                                                                    interface User {}
                                                                    • An object that describes the Amazon account for which the skill is enabled.

                                                                    property 'accessToken'

                                                                    accessToken?: string;
                                                                    • A token identifying the user in another system. This is only provided if the user has successfully linked their skill account with their Amazon account.

                                                                    property 'permissions'

                                                                    permissions?: Permissions;

                                                                      property 'userId'

                                                                      userId: string;
                                                                      • A string that represents a unique identifier for the user who made the request. The length of this identifier can vary, but is never more than 255 characters. The userId is automatically generated when a user enables the skill in the Alexa app. Note: Disabling and re-enabling a skill generates a new identifier.

                                                                      Type Aliases

                                                                      type Cause

                                                                      type Cause = ConnectionCompleted;
                                                                      • Describes the type of the Cause.

                                                                      type DialogState

                                                                      type DialogState = 'STARTED' | 'IN_PROGRESS' | 'COMPLETED';
                                                                      • Enumeration indicating the status of the multi-turn dialog. This property is included if the skill meets the requirements to use the Dialog directives. Note that COMPLETED is only possible when you use the Dialog.Delegate directive. If you use intent confirmation, dialogState is considered COMPLETED if the user denies the entire intent (for instance, by answering “no” when asked the confirmation prompt). Be sure to also check the confirmationStatus property on the Intent object before fulfilling the user’s request.

                                                                      type Directive

                                                                      type Directive =
                                                                      | interfaces.customInterfaceController.StopEventHandlerDirective
                                                                      | interfaces.navigation.assistance.AnnounceRoadRegulation
                                                                      | interfaces.connections.SendRequestDirective
                                                                      | dialog.DynamicEntitiesDirective
                                                                      | interfaces.customInterfaceController.StartEventHandlerDirective
                                                                      | interfaces.gadgetController.SetLightDirective
                                                                      | interfaces.alexa.presentation.apl.SendIndexListDataDirective
                                                                      | dialog.DelegateDirective
                                                                      | dialog.ConfirmIntentDirective
                                                                      | interfaces.alexa.advertisement.InjectAds
                                                                      | interfaces.customInterfaceController.SendDirectiveDirective
                                                                      | interfaces.alexa.presentation.html.HandleMessageDirective
                                                                      | interfaces.alexa.presentation.apla.RenderDocumentDirective
                                                                      | dialog.ElicitSlotDirective
                                                                      | interfaces.alexa.presentation.html.StartDirective
                                                                      | interfaces.alexa.smartvision.snapshotprovider.GetSnapshotDirective
                                                                      | interfaces.audioplayer.StopDirective
                                                                      | dialog.ConfirmSlotDirective
                                                                      | interfaces.audioplayer.PlayDirective
                                                                      | interfaces.alexa.presentation.apl.ExecuteCommandsDirective
                                                                      | interfaces.display.RenderTemplateDirective
                                                                      | interfaces.conversations.ResetContextDirective
                                                                      | dialog.DelegateRequestDirective
                                                                      | interfaces.display.HintDirective
                                                                      | interfaces.connections.V1.StartConnectionDirective
                                                                      | interfaces.alexa.presentation.aplt.RenderDocumentDirective
                                                                      | interfaces.gameEngine.StartInputHandlerDirective
                                                                      | interfaces.videoapp.LaunchDirective
                                                                      | interfaces.alexa.presentation.aplt.ExecuteCommandsDirective
                                                                      | interfaces.gameEngine.StopInputHandlerDirective
                                                                      | interfaces.tasks.CompleteTaskDirective
                                                                      | interfaces.alexa.presentation.apl.RenderDocumentDirective
                                                                      | interfaces.connections.SendResponseDirective
                                                                      | interfaces.alexa.presentation.apl.SendTokenListDataDirective
                                                                      | interfaces.audioplayer.ClearQueueDirective
                                                                      | interfaces.alexa.presentation.apl.UpdateIndexListDataDirective;

                                                                      type IntentConfirmationStatus

                                                                      type IntentConfirmationStatus = 'NONE' | 'DENIED' | 'CONFIRMED';
                                                                      • Indication of whether an intent or slot has been explicitly confirmed or denied by the user, or neither.

                                                                      type PermissionStatus

                                                                      type PermissionStatus = 'GRANTED' | 'DENIED';
                                                                      • This denotes the status of the permission scope.

                                                                      type Request

                                                                      type Request =
                                                                      | interfaces.alexa.advertisement.AdNotRendered
                                                                      | interfaces.alexa.datastore.packagemanager.InstallationError
                                                                      | events.skillevents.SkillEnabledRequest
                                                                      | services.listManagement.ListUpdatedEventRequest
                                                                      | interfaces.alexa.presentation.apl.UserEvent
                                                                      | events.skillevents.SkillDisabledRequest
                                                                      | services.listManagement.ListItemsCreatedEventRequest
                                                                      | SessionResumedRequest
                                                                      | SessionEndedRequest
                                                                      | interfaces.alexa.presentation.apl.LoadIndexListDataEvent
                                                                      | interfaces.alexa.presentation.apl.LoadTokenListDataEvent
                                                                      | interfaces.audioplayer.PlaybackFailedRequest
                                                                      | canfulfill.CanFulfillIntentRequest
                                                                      | interfaces.customInterfaceController.ExpiredRequest
                                                                      | interfaces.alexa.presentation.html.MessageRequest
                                                                      | interfaces.alexa.datastore.DataStoreError
                                                                      | LaunchRequest
                                                                      | authorization.AuthorizationGrantRequest
                                                                      | services.reminderManagement.ReminderCreatedEventRequest
                                                                      | interfaces.alexa.presentation.aplt.UserEvent
                                                                      | interfaces.alexa.advertisement.ReadyToEnqueueAudio
                                                                      | services.listManagement.ListItemsUpdatedEventRequest
                                                                      | services.listManagement.ListCreatedEventRequest
                                                                      | interfaces.audioplayer.PlaybackStartedRequest
                                                                      | interfaces.audioplayer.PlaybackNearlyFinishedRequest
                                                                      | interfaces.customInterfaceController.EventsReceivedRequest
                                                                      | services.reminderManagement.ReminderStatusChangedEventRequest
                                                                      | services.listManagement.ListItemsDeletedEventRequest
                                                                      | services.reminderManagement.ReminderDeletedEventRequest
                                                                      | interfaces.connections.ConnectionsResponse
                                                                      | services.listManagement.ListDeletedEventRequest
                                                                      | interfaces.gameEngine.InputHandlerEventRequest
                                                                      | interfaces.playbackcontroller.PauseCommandIssuedRequest
                                                                      | interfaces.playbackcontroller.PlayCommandIssuedRequest
                                                                      | interfaces.audioplayer.PlaybackFinishedRequest
                                                                      | events.skillevents.ProactiveSubscriptionChangedRequest
                                                                      | interfaces.display.ElementSelectedRequest
                                                                      | events.skillevents.PermissionChangedRequest
                                                                      | services.reminderManagement.ReminderUpdatedEventRequest
                                                                      | interfaces.alexa.advertisement.AdCompleted
                                                                      | interfaces.alexa.datastore.packagemanager.UpdateRequest
                                                                      | interfaces.alexa.presentation.apl.RuntimeErrorEvent
                                                                      | interfaces.alexa.presentation.html.RuntimeErrorRequest
                                                                      | dialog.InputRequest
                                                                      | IntentRequest
                                                                      | interfaces.alexa.datastore.packagemanager.UsagesRemoved
                                                                      | events.skillevents.NotificationSubscriptionChangedRequest
                                                                      | interfaces.conversations.APIInvocationRequest
                                                                      | services.reminderManagement.ReminderStartedEventRequest
                                                                      | interfaces.audioplayer.PlaybackStoppedRequest
                                                                      | interfaces.playbackcontroller.PreviousCommandIssuedRequest
                                                                      | interfaces.alexa.datastore.packagemanager.UsagesInstalled
                                                                      | events.skillevents.AccountLinkedRequest
                                                                      | interfaces.messaging.MessageReceivedRequest
                                                                      | interfaces.connections.ConnectionsRequest
                                                                      | interfaces.system.ExceptionEncounteredRequest
                                                                      | events.skillevents.PermissionAcceptedRequest
                                                                      | interfaces.playbackcontroller.NextCommandIssuedRequest
                                                                      | interfaces.alexa.presentation.apla.RuntimeErrorEvent;
                                                                      • A request object that provides the details of the user’s request. The request body contains the parameters necessary for the service to perform its logic and generate a response.

                                                                      type SessionEndedErrorType

                                                                      type SessionEndedErrorType =
                                                                      | 'INVALID_RESPONSE'
                                                                      | 'DEVICE_COMMUNICATION_ERROR'
                                                                      | 'INTERNAL_SERVICE_ERROR'
                                                                      | 'ENDPOINT_TIMEOUT';
                                                                      • A string indicating the type of error that occurred.

                                                                      type SessionEndedReason

                                                                      type SessionEndedReason = 'USER_INITIATED' | 'ERROR' | 'EXCEEDED_MAX_REPROMPTS';
                                                                      • The reason why session ended when not initiated from the Skill itself.

                                                                      type SlotConfirmationStatus

                                                                      type SlotConfirmationStatus = 'NONE' | 'DENIED' | 'CONFIRMED';
                                                                      • An enumeration indicating whether the user has explicitly confirmed or denied the value of this slot.

                                                                      type SlotValue

                                                                      type SlotValue = ListSlotValue | SimpleSlotValue;
                                                                      • Object representing the value captured in the slot.

                                                                      Namespaces

                                                                      namespace authorization

                                                                      namespace authorization {}

                                                                        interface AuthorizationGrantBody

                                                                        interface AuthorizationGrantBody {}
                                                                        • Authorization grant body.

                                                                        property 'grant'

                                                                        grant: authorization.Grant;

                                                                          interface AuthorizationGrantRequest

                                                                          interface AuthorizationGrantRequest {}
                                                                          • Represents an authorization code delivered to a skill that has out-of-session permissions without requiring account linking.

                                                                          property 'body'

                                                                          body: authorization.AuthorizationGrantBody;

                                                                            property 'locale'

                                                                            locale?: string;
                                                                            • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                            property 'requestId'

                                                                            requestId: string;
                                                                            • Represents the unique identifier for the specific request.

                                                                            property 'timestamp'

                                                                            timestamp: string;
                                                                            • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                            property 'type'

                                                                            type: 'Alexa.Authorization.Grant';

                                                                              interface Grant

                                                                              interface Grant {}
                                                                              • Information that identifies a user in Amazon Alexa systems.

                                                                              property 'code'

                                                                              code: string;
                                                                              • The authorization code for the user.

                                                                              property 'type'

                                                                              type: authorization.GrantType;
                                                                              • Type of the grant.

                                                                              type GrantType

                                                                              type GrantType = 'OAuth2.AuthorizationCode';
                                                                              • One of the grant types supported.

                                                                              namespace canfulfill

                                                                              namespace canfulfill {}

                                                                                interface CanFulfillIntent

                                                                                interface CanFulfillIntent {}
                                                                                • CanFulfillIntent represents the response to canFulfillIntentRequest includes the details about whether the skill can understand and fulfill the intent request with detected slots.

                                                                                property 'canFulfill'

                                                                                canFulfill: canfulfill.CanFulfillIntentValues;

                                                                                  property 'slots'

                                                                                  slots?: {
                                                                                  [key: string]: canfulfill.CanFulfillSlot;
                                                                                  };
                                                                                  • A map that represents skill's detailed response to each detected slot within the intent such as if skill can understand and fulfill the detected slot. This supplements the overall canFulfillIntent response and help Alexa make better ranking and arbitration decisions. The key is the name of the slot. The value is an object of type CanFulfillSlot.

                                                                                  interface CanFulfillIntentRequest

                                                                                  interface CanFulfillIntentRequest {}
                                                                                  • An object that represents a request made to skill to query whether the skill can understand and fulfill the intent request with detected slots, before actually asking the skill to take action. Skill should be aware this is not to actually take action, skill should handle this request without causing side-effect, skill should not modify some state outside its scope or has an observable interaction with its calling functions or the outside world besides returning a value, such as playing sound,turning on/off lights, committing a transaction or a charge.

                                                                                  property 'dialogState'

                                                                                  dialogState?: DialogState;

                                                                                    property 'intent'

                                                                                    intent: Intent;

                                                                                      property 'locale'

                                                                                      locale?: string;
                                                                                      • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                      property 'requestId'

                                                                                      requestId: string;
                                                                                      • Represents the unique identifier for the specific request.

                                                                                      property 'timestamp'

                                                                                      timestamp: string;
                                                                                      • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                      property 'type'

                                                                                      type: 'CanFulfillIntentRequest';

                                                                                        interface CanFulfillSlot

                                                                                        interface CanFulfillSlot {}
                                                                                        • This represents skill's capability to understand and fulfill each detected slot.

                                                                                        property 'canFulfill'

                                                                                        canFulfill?: canfulfill.CanFulfillSlotValues;

                                                                                          property 'canUnderstand'

                                                                                          canUnderstand: canfulfill.CanUnderstandSlotValues;

                                                                                            type CanFulfillIntentValues

                                                                                            type CanFulfillIntentValues = 'YES' | 'NO' | 'MAYBE';
                                                                                            • Overall if skill can understand and fulfill the intent with detected slots. Respond YES when skill understands all slots, can fulfill all slots, and can fulfill the request in its entirety. Respond NO when skill either cannot understand the intent, cannot understand all the slots, or cannot fulfill all the slots. Respond MAYBE when skill can understand the intent, can partially or fully understand the slots, and can partially or fully fulfill the slots. The only cases where should respond MAYBE is when skill partially understand the request and can potentially complete the request if skill get more data, either through callbacks or through a multi-turn conversation with the user.

                                                                                            type CanFulfillSlotValues

                                                                                            type CanFulfillSlotValues = 'YES' | 'NO';
                                                                                            • This field indicates whether skill can fulfill relevant action for the slot, that has been partially or fully understood. The definition of fulfilling the slot is dependent on skill and skill is required to have logic in place to determine whether a slot value can be fulfilled in the context of skill or not. Return YES if Skill can certainly fulfill the relevant action for this slot value. Return NO if skill cannot fulfill the relevant action for this slot value. For specific recommendations to set the value refer to the developer docs for more details.

                                                                                            type CanUnderstandSlotValues

                                                                                            type CanUnderstandSlotValues = 'YES' | 'NO' | 'MAYBE';
                                                                                            • This field indicates whether skill has understood the slot value. In most typical cases, skills will do some form of entity resolution by looking up a catalog or list to determine whether they recognize the slot or not. Return YES if skill have a perfect match or high confidence match (for eg. synonyms) with catalog or list maintained by skill. Return NO if skill cannot understand or recognize the slot value. Return MAYBE if skill have partial confidence or partial match. This will be true when the slot value doesn’t exist as is, in the catalog, but a variation or a fuzzy match may exist. For specific recommendations to set the value refer to the developer docs for more details.

                                                                                            namespace dialog

                                                                                            namespace dialog {}

                                                                                              interface ConfirmIntentDirective

                                                                                              interface ConfirmIntentDirective {}

                                                                                              property 'type'

                                                                                              type: 'Dialog.ConfirmIntent';

                                                                                                property 'updatedIntent'

                                                                                                updatedIntent?: Intent;

                                                                                                  interface ConfirmSlotDirective

                                                                                                  interface ConfirmSlotDirective {}

                                                                                                  property 'slotToConfirm'

                                                                                                  slotToConfirm: string;

                                                                                                    property 'type'

                                                                                                    type: 'Dialog.ConfirmSlot';

                                                                                                      property 'updatedIntent'

                                                                                                      updatedIntent?: Intent;

                                                                                                        interface DelegateDirective

                                                                                                        interface DelegateDirective {}

                                                                                                        property 'type'

                                                                                                        type: 'Dialog.Delegate';

                                                                                                          property 'updatedIntent'

                                                                                                          updatedIntent?: Intent;

                                                                                                            interface DelegateRequestDirective

                                                                                                            interface DelegateRequestDirective {}

                                                                                                            property 'period'

                                                                                                            period: dialog.DelegationPeriod;

                                                                                                              property 'target'

                                                                                                              target: string;
                                                                                                              • The delegation target.

                                                                                                              property 'type'

                                                                                                              type: 'Dialog.DelegateRequest';

                                                                                                                property 'updatedRequest'

                                                                                                                updatedRequest?: dialog.UpdatedRequest;

                                                                                                                  interface DelegationPeriod

                                                                                                                  interface DelegationPeriod {}
                                                                                                                  • The delegation period.

                                                                                                                  property 'until'

                                                                                                                  until?: dialog.DelegationPeriodUntil;

                                                                                                                    interface DynamicEntitiesDirective

                                                                                                                    interface DynamicEntitiesDirective {}

                                                                                                                    property 'type'

                                                                                                                    type: 'Dialog.UpdateDynamicEntities';

                                                                                                                      property 'types'

                                                                                                                      types?: Array<er.dynamic.EntityListItem>;

                                                                                                                        property 'updateBehavior'

                                                                                                                        updateBehavior: er.dynamic.UpdateBehavior;

                                                                                                                          interface ElicitSlotDirective

                                                                                                                          interface ElicitSlotDirective {}

                                                                                                                          property 'slotToElicit'

                                                                                                                          slotToElicit: string;

                                                                                                                            property 'type'

                                                                                                                            type: 'Dialog.ElicitSlot';

                                                                                                                              property 'updatedIntent'

                                                                                                                              updatedIntent?: Intent;

                                                                                                                                interface Input

                                                                                                                                interface Input {}
                                                                                                                                • Structured input data to send to a dialog manager. Currently, this is an Alexa Conversations input instance.

                                                                                                                                property 'name'

                                                                                                                                name: string;
                                                                                                                                • The Alexa Conversations input name as dictated in the Conversations model.

                                                                                                                                property 'slots'

                                                                                                                                slots?: {
                                                                                                                                [key: string]: Slot;
                                                                                                                                };
                                                                                                                                • A map of input slots by slot name.

                                                                                                                                interface InputRequest

                                                                                                                                interface InputRequest {}
                                                                                                                                • A request representing structured data used to provide dialog input to a dialog manager.

                                                                                                                                property 'input'

                                                                                                                                input: dialog.Input;

                                                                                                                                  property 'locale'

                                                                                                                                  locale?: string;
                                                                                                                                  • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                  property 'requestId'

                                                                                                                                  requestId: string;
                                                                                                                                  • Represents the unique identifier for the specific request.

                                                                                                                                  property 'timestamp'

                                                                                                                                  timestamp: string;
                                                                                                                                  • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                  property 'type'

                                                                                                                                  type: 'Dialog.InputRequest';

                                                                                                                                    interface UpdatedInputRequest

                                                                                                                                    interface UpdatedInputRequest {}

                                                                                                                                    property 'input'

                                                                                                                                    input: dialog.Input;

                                                                                                                                      property 'type'

                                                                                                                                      type: 'Dialog.InputRequest';

                                                                                                                                        interface UpdatedIntentRequest

                                                                                                                                        interface UpdatedIntentRequest {}

                                                                                                                                        property 'intent'

                                                                                                                                        intent: Intent;

                                                                                                                                          property 'type'

                                                                                                                                          type: 'IntentRequest';

                                                                                                                                            type DelegationPeriodUntil

                                                                                                                                            type DelegationPeriodUntil = 'EXPLICIT_RETURN' | 'NEXT_TURN';
                                                                                                                                            • The end of the specified delegation period. * EXPLICIT_RETURN - delegation lasts until the targeted dialog manager returns a delegate with a new target. * NEXT_TURN - delegation lasts until the next turn, which resumes with the current focused dialog manager.

                                                                                                                                            type UpdatedRequest

                                                                                                                                            type UpdatedRequest = dialog.UpdatedInputRequest | dialog.UpdatedIntentRequest;
                                                                                                                                            • The updated request to delegate. Null will delegate the current request.

                                                                                                                                            namespace dynamicEndpoints

                                                                                                                                            namespace dynamicEndpoints {}

                                                                                                                                              interface FailureResponse

                                                                                                                                              interface FailureResponse {}
                                                                                                                                              • Failure skill response for a Dynamic endpoint request.

                                                                                                                                              property 'errorCode'

                                                                                                                                              errorCode?: string;
                                                                                                                                              • The error code for the failure. Standard HTTP error codes will be used.

                                                                                                                                              property 'errorMessage'

                                                                                                                                              errorMessage?: string;
                                                                                                                                              • Description of the failure.

                                                                                                                                              property 'originalRequestId'

                                                                                                                                              originalRequestId: string;
                                                                                                                                              • The same request identifier as the Dynamic endpoint request for this response.

                                                                                                                                              property 'type'

                                                                                                                                              type: 'SkillResponseFailureMessage';

                                                                                                                                                property 'version'

                                                                                                                                                version: string;
                                                                                                                                                • The version of the response message schema used.

                                                                                                                                                interface Request

                                                                                                                                                interface Request {}
                                                                                                                                                • Request from a Dynamic endpoint connection.

                                                                                                                                                property 'requestId'

                                                                                                                                                requestId: string;
                                                                                                                                                • The requestId for the dynamic endpoint request.

                                                                                                                                                property 'requestPayload'

                                                                                                                                                requestPayload: string;
                                                                                                                                                • The request payload.

                                                                                                                                                property 'type'

                                                                                                                                                type: string;
                                                                                                                                                • Denotes type of request.

                                                                                                                                                property 'version'

                                                                                                                                                version: string;
                                                                                                                                                • The version of the request message schema used.

                                                                                                                                                interface SuccessResponse

                                                                                                                                                interface SuccessResponse {}
                                                                                                                                                • Success response for a Dynamic endpoint request.

                                                                                                                                                property 'originalRequestId'

                                                                                                                                                originalRequestId: string;
                                                                                                                                                • The same request identifier as the Dynamic endpoint request for this response.

                                                                                                                                                property 'responsePayload'

                                                                                                                                                responsePayload?: string;
                                                                                                                                                • The response payload.

                                                                                                                                                property 'type'

                                                                                                                                                type: 'SkillResponseSuccessMessage';

                                                                                                                                                  property 'version'

                                                                                                                                                  version: string;
                                                                                                                                                  • The version of the response message schema used.

                                                                                                                                                  type BaseResponse

                                                                                                                                                  type BaseResponse =
                                                                                                                                                  | dynamicEndpoints.FailureResponse
                                                                                                                                                  | dynamicEndpoints.SuccessResponse;
                                                                                                                                                  • Base response type.

                                                                                                                                                  namespace er

                                                                                                                                                  namespace er {}

                                                                                                                                                    namespace er.dynamic

                                                                                                                                                    namespace er.dynamic {}

                                                                                                                                                      interface Entity

                                                                                                                                                      interface Entity {}
                                                                                                                                                      • Represents an entity that the skill wants to store. An entity has an optional Id and the value and the synonyms for the entity

                                                                                                                                                      property 'id'

                                                                                                                                                      id?: string;
                                                                                                                                                      • An unique id associated with the entity

                                                                                                                                                      property 'name'

                                                                                                                                                      name: er.dynamic.EntityValueAndSynonyms;

                                                                                                                                                        interface EntityListItem

                                                                                                                                                        interface EntityListItem {}
                                                                                                                                                        • Represents an array of entities of a particular type.

                                                                                                                                                        property 'name'

                                                                                                                                                        name: string;
                                                                                                                                                        • The entity type. Must match the slot type as defined in the interaction model.

                                                                                                                                                        property 'values'

                                                                                                                                                        values: Array<er.dynamic.Entity>;
                                                                                                                                                        • A list of dynamic entities which are of the same type

                                                                                                                                                        interface EntityValueAndSynonyms

                                                                                                                                                        interface EntityValueAndSynonyms {}
                                                                                                                                                        • A container object with value and synomyms for the entity

                                                                                                                                                        property 'synonyms'

                                                                                                                                                        synonyms?: Array<string>;
                                                                                                                                                        • An array of synonyms for the entity

                                                                                                                                                        property 'value'

                                                                                                                                                        value: string;
                                                                                                                                                        • The entity value

                                                                                                                                                        type UpdateBehavior

                                                                                                                                                        type UpdateBehavior = 'REPLACE' | 'CLEAR';
                                                                                                                                                        • Replace the existing dynamic entities or clear them from the catalog

                                                                                                                                                        namespace events

                                                                                                                                                        namespace events {}

                                                                                                                                                          namespace events.skillevents

                                                                                                                                                          namespace events.skillevents {}

                                                                                                                                                            interface AccountLinkedBody

                                                                                                                                                            interface AccountLinkedBody {}

                                                                                                                                                            property 'accessToken'

                                                                                                                                                            accessToken?: string;

                                                                                                                                                              interface AccountLinkedRequest

                                                                                                                                                              interface AccountLinkedRequest {}
                                                                                                                                                              • This event indicates that a customer has linked an account in a third-party application with the Alexa app. This event is useful for an application that support out-of-session (non-voice) user interactions so that this application can be notified when the internal customer can be associated with the Alexa customer. This event is required for many applications that synchronize customer Alexa lists with application lists. During the account linking process, the Alexa app directs the user to the skill website where the customer logs in. When the customer logs in, the skill then provides an access token and a consent token to Alexa. The event includes the same access token and consent token.

                                                                                                                                                              property 'body'

                                                                                                                                                              body: events.skillevents.AccountLinkedBody;

                                                                                                                                                                property 'eventCreationTime'

                                                                                                                                                                eventCreationTime?: string;

                                                                                                                                                                  property 'eventPublishingTime'

                                                                                                                                                                  eventPublishingTime?: string;

                                                                                                                                                                    property 'locale'

                                                                                                                                                                    locale?: string;
                                                                                                                                                                    • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                    property 'requestId'

                                                                                                                                                                    requestId: string;
                                                                                                                                                                    • Represents the unique identifier for the specific request.

                                                                                                                                                                    property 'timestamp'

                                                                                                                                                                    timestamp: string;
                                                                                                                                                                    • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                    property 'type'

                                                                                                                                                                    type: 'AlexaSkillEvent.SkillAccountLinked';

                                                                                                                                                                      interface NotificationSubscriptionChangedBody

                                                                                                                                                                      interface NotificationSubscriptionChangedBody {}

                                                                                                                                                                      property 'subscriptions'

                                                                                                                                                                      subscriptions?: Array<events.skillevents.NotificationSubscriptionEvent>;
                                                                                                                                                                      • The list of to Topics that this user has subscribed/permitted to receive notification from your skill. If a customer unsubscribes for a Topic, this list will contain remaining Topics to which the customer is still subscribed to receive from your skill. If the list of subscriptions is empty, this customer has removed notification subscription for all Topics from your skill.

                                                                                                                                                                      interface NotificationSubscriptionChangedRequest

                                                                                                                                                                      interface NotificationSubscriptionChangedRequest {}
                                                                                                                                                                      • When a customer changes his topic subscriptions Alexa will send an event back to the skill endpoint notifying the skill owner with the most recent state of the customer's subscriptions. This is to notify skill owners of customers' interest in receiving events from one or more schemas. This event indicates a customer permission to receive notifications from your skill and contains information for that user. You need this information to know the userId in order to send notifications to individual users. Note that these events can arrive out of order, so ensure that your skill service uses the timestamp in the event to correctly record the latest topic subscription state for a customer.

                                                                                                                                                                      property 'body'

                                                                                                                                                                      body: events.skillevents.NotificationSubscriptionChangedBody;

                                                                                                                                                                        property 'locale'

                                                                                                                                                                        locale?: string;
                                                                                                                                                                        • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                        property 'requestId'

                                                                                                                                                                        requestId: string;
                                                                                                                                                                        • Represents the unique identifier for the specific request.

                                                                                                                                                                        property 'timestamp'

                                                                                                                                                                        timestamp: string;
                                                                                                                                                                        • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                        property 'type'

                                                                                                                                                                        type: 'AlexaSkillEvent.NotificationSubscriptionChanged';

                                                                                                                                                                          interface NotificationSubscriptionEvent

                                                                                                                                                                          interface NotificationSubscriptionEvent {}

                                                                                                                                                                          property 'topicId'

                                                                                                                                                                          topicId?: string;
                                                                                                                                                                          • The topicId will be one of the Topics specified in your Skill's manifest file.

                                                                                                                                                                          interface Permission

                                                                                                                                                                          interface Permission {}

                                                                                                                                                                          property 'scope'

                                                                                                                                                                          scope?: string;
                                                                                                                                                                          • The value representing the permission scope.

                                                                                                                                                                          interface PermissionAcceptedRequest

                                                                                                                                                                          interface PermissionAcceptedRequest {}

                                                                                                                                                                          property 'body'

                                                                                                                                                                          body?: events.skillevents.PermissionBody;

                                                                                                                                                                            property 'eventCreationTime'

                                                                                                                                                                            eventCreationTime?: string;

                                                                                                                                                                              property 'eventPublishingTime'

                                                                                                                                                                              eventPublishingTime?: string;

                                                                                                                                                                                property 'locale'

                                                                                                                                                                                locale?: string;
                                                                                                                                                                                • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                                property 'requestId'

                                                                                                                                                                                requestId: string;
                                                                                                                                                                                • Represents the unique identifier for the specific request.

                                                                                                                                                                                property 'timestamp'

                                                                                                                                                                                timestamp: string;
                                                                                                                                                                                • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                                property 'type'

                                                                                                                                                                                type: 'AlexaSkillEvent.SkillPermissionAccepted';

                                                                                                                                                                                  interface PermissionBody

                                                                                                                                                                                  interface PermissionBody {}

                                                                                                                                                                                  property 'acceptedPermissions'

                                                                                                                                                                                  acceptedPermissions?: Array<events.skillevents.Permission>;
                                                                                                                                                                                  • The current list of permissions consented to on the account level. It can be an empty list if there are no account level permissions consented to.

                                                                                                                                                                                  property 'acceptedPersonPermissions'

                                                                                                                                                                                  acceptedPersonPermissions?: Array<events.skillevents.Permission>;
                                                                                                                                                                                  • The current list of permissions consented to on the person level. This is only present if the request contains the ```person``` object. It can be an empty list if there are no person level permissions consented to.

                                                                                                                                                                                  interface PermissionChangedRequest

                                                                                                                                                                                  interface PermissionChangedRequest {}

                                                                                                                                                                                  property 'body'

                                                                                                                                                                                  body?: events.skillevents.PermissionBody;

                                                                                                                                                                                    property 'eventCreationTime'

                                                                                                                                                                                    eventCreationTime?: string;

                                                                                                                                                                                      property 'eventPublishingTime'

                                                                                                                                                                                      eventPublishingTime?: string;

                                                                                                                                                                                        property 'locale'

                                                                                                                                                                                        locale?: string;
                                                                                                                                                                                        • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                                        property 'requestId'

                                                                                                                                                                                        requestId: string;
                                                                                                                                                                                        • Represents the unique identifier for the specific request.

                                                                                                                                                                                        property 'timestamp'

                                                                                                                                                                                        timestamp: string;
                                                                                                                                                                                        • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                                        property 'type'

                                                                                                                                                                                        type: 'AlexaSkillEvent.SkillPermissionChanged';

                                                                                                                                                                                          interface ProactiveSubscriptionChangedBody

                                                                                                                                                                                          interface ProactiveSubscriptionChangedBody {}

                                                                                                                                                                                          property 'subscriptions'

                                                                                                                                                                                          subscriptions?: Array<events.skillevents.ProactiveSubscriptionEvent>;
                                                                                                                                                                                          • The list of events that this customer is currently subscribed to. If a customer unsubscribes from an event, this list will contain remaining event types to which the customer is still subscribed to receive from your skill. If the list of subscriptions is empty, this customer has unsubscribed from all event types from your skill.

                                                                                                                                                                                          interface ProactiveSubscriptionChangedRequest

                                                                                                                                                                                          interface ProactiveSubscriptionChangedRequest {}
                                                                                                                                                                                          • This event indicates a customer subscription to receive events from your skill and contains information for that user and person, if recognized. You need this information to know the userId and personId in order to send events to individual users. Note that these events can arrive out of order, so ensure that your skill service uses the timestamp in the event to correctly record the latest subscription state for a customer.

                                                                                                                                                                                          property 'body'

                                                                                                                                                                                          body: events.skillevents.ProactiveSubscriptionChangedBody;

                                                                                                                                                                                            property 'locale'

                                                                                                                                                                                            locale?: string;
                                                                                                                                                                                            • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                                            property 'requestId'

                                                                                                                                                                                            requestId: string;
                                                                                                                                                                                            • Represents the unique identifier for the specific request.

                                                                                                                                                                                            property 'timestamp'

                                                                                                                                                                                            timestamp: string;
                                                                                                                                                                                            • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                                            property 'type'

                                                                                                                                                                                            type: 'AlexaSkillEvent.ProactiveSubscriptionChanged';

                                                                                                                                                                                              interface ProactiveSubscriptionEvent

                                                                                                                                                                                              interface ProactiveSubscriptionEvent {}

                                                                                                                                                                                              property 'eventName'

                                                                                                                                                                                              eventName?: string;

                                                                                                                                                                                                interface SkillDisabledRequest

                                                                                                                                                                                                interface SkillDisabledRequest {}

                                                                                                                                                                                                property 'eventCreationTime'

                                                                                                                                                                                                eventCreationTime?: string;

                                                                                                                                                                                                  property 'eventPublishingTime'

                                                                                                                                                                                                  eventPublishingTime?: string;

                                                                                                                                                                                                    property 'locale'

                                                                                                                                                                                                    locale?: string;
                                                                                                                                                                                                    • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                                                    property 'requestId'

                                                                                                                                                                                                    requestId: string;
                                                                                                                                                                                                    • Represents the unique identifier for the specific request.

                                                                                                                                                                                                    property 'timestamp'

                                                                                                                                                                                                    timestamp: string;
                                                                                                                                                                                                    • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                                                    property 'type'

                                                                                                                                                                                                    type: 'AlexaSkillEvent.SkillDisabled';

                                                                                                                                                                                                      interface SkillEnabledRequest

                                                                                                                                                                                                      interface SkillEnabledRequest {}

                                                                                                                                                                                                      property 'eventCreationTime'

                                                                                                                                                                                                      eventCreationTime?: string;

                                                                                                                                                                                                        property 'eventPublishingTime'

                                                                                                                                                                                                        eventPublishingTime?: string;

                                                                                                                                                                                                          property 'locale'

                                                                                                                                                                                                          locale?: string;
                                                                                                                                                                                                          • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                                                          property 'requestId'

                                                                                                                                                                                                          requestId: string;
                                                                                                                                                                                                          • Represents the unique identifier for the specific request.

                                                                                                                                                                                                          property 'timestamp'

                                                                                                                                                                                                          timestamp: string;
                                                                                                                                                                                                          • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                                                          property 'type'

                                                                                                                                                                                                          type: 'AlexaSkillEvent.SkillEnabled';

                                                                                                                                                                                                            namespace interfaces

                                                                                                                                                                                                            namespace interfaces {}

                                                                                                                                                                                                              namespace interfaces.alexa

                                                                                                                                                                                                              namespace interfaces.alexa {}

                                                                                                                                                                                                                namespace interfaces.alexa.advertisement

                                                                                                                                                                                                                namespace interfaces.alexa.advertisement {}

                                                                                                                                                                                                                  interface AdCompleted

                                                                                                                                                                                                                  interface AdCompleted {}
                                                                                                                                                                                                                  • The skill receives this event when the ad playback is finished. More details: https://tiny.amazon.com/tbfio2ru/wamazbinviewAlexTeamASKTInSk

                                                                                                                                                                                                                  property 'locale'

                                                                                                                                                                                                                  locale?: string;
                                                                                                                                                                                                                  • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                                                                  property 'requestId'

                                                                                                                                                                                                                  requestId: string;
                                                                                                                                                                                                                  • Represents the unique identifier for the specific request.

                                                                                                                                                                                                                  property 'timestamp'

                                                                                                                                                                                                                  timestamp: string;
                                                                                                                                                                                                                  • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                                                                  property 'token'

                                                                                                                                                                                                                  token?: string;
                                                                                                                                                                                                                  • The current token representing the ad stream being played.

                                                                                                                                                                                                                  property 'type'

                                                                                                                                                                                                                  type: 'Alexa.Advertisement.AdCompleted';

                                                                                                                                                                                                                    interface AdNotRendered

                                                                                                                                                                                                                    interface AdNotRendered {}
                                                                                                                                                                                                                    • The skill receives this event when the ad cannot be displayed or played due to certain reasons. More details: https://tiny.amazon.com/16bnoj5db/wamazbinviewAlexTeamASKTInSk

                                                                                                                                                                                                                    property 'locale'

                                                                                                                                                                                                                    locale?: string;
                                                                                                                                                                                                                    • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                                                                    property 'reason'

                                                                                                                                                                                                                    reason?: interfaces.alexa.advertisement.Reason;
                                                                                                                                                                                                                    • The object encapsulates information regarding the reasons why the ad is not being rendered.

                                                                                                                                                                                                                    property 'requestId'

                                                                                                                                                                                                                    requestId: string;
                                                                                                                                                                                                                    • Represents the unique identifier for the specific request.

                                                                                                                                                                                                                    property 'timestamp'

                                                                                                                                                                                                                    timestamp: string;
                                                                                                                                                                                                                    • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                                                                    property 'type'

                                                                                                                                                                                                                    type: 'Alexa.Advertisement.AdNotRendered';

                                                                                                                                                                                                                      interface AlexaAdvertisementInterface

                                                                                                                                                                                                                      interface AlexaAdvertisementInterface {}
                                                                                                                                                                                                                      • The interface provides skills with the ability to seamlessly integrate advertisements during their interactions with users.

                                                                                                                                                                                                                      interface InjectAds

                                                                                                                                                                                                                      interface InjectAds {}

                                                                                                                                                                                                                      property 'expectedPreviousToken'

                                                                                                                                                                                                                      expectedPreviousToken?: string;
                                                                                                                                                                                                                      • The optional expected previous token represents the content currently being played, and it is utilized to enqueue the advertisement after the ongoing audio content. More details: https://tiny.amazon.com/l9h6ejjr/wamazbinviewAlexTeamASKTInSk

                                                                                                                                                                                                                      property 'type'

                                                                                                                                                                                                                      type: 'Alexa.Advertisement.InjectAds';

                                                                                                                                                                                                                        interface ReadyToEnqueueAudio

                                                                                                                                                                                                                        interface ReadyToEnqueueAudio {}
                                                                                                                                                                                                                        • This event is sent to the skill as a signal that it can enqueue the next audio content in the audio player. This allows the third-party skill to resume content playback after the advertisement.

                                                                                                                                                                                                                        property 'locale'

                                                                                                                                                                                                                        locale?: string;
                                                                                                                                                                                                                        • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                                                                        property 'previousToken'

                                                                                                                                                                                                                        previousToken?: string;
                                                                                                                                                                                                                        • The expectedPreviousToken passed in the InjectAds request, which can be utilized by a skill to maintain an ordered list and find the next content from the current content.

                                                                                                                                                                                                                        property 'requestId'

                                                                                                                                                                                                                        requestId: string;
                                                                                                                                                                                                                        • Represents the unique identifier for the specific request.

                                                                                                                                                                                                                        property 'timestamp'

                                                                                                                                                                                                                        timestamp: string;
                                                                                                                                                                                                                        • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                                                                        property 'token'

                                                                                                                                                                                                                        token?: string;
                                                                                                                                                                                                                        • The token currently representing the ad stream being played can be used as the expectedPreviousToken in the AudioPlayer.Play directive. This allows the skill to enqueue the next content seamlessly after the ad stream.

                                                                                                                                                                                                                        property 'type'

                                                                                                                                                                                                                        type: 'Alexa.Advertisement.ReadyToEnqueueAudio';

                                                                                                                                                                                                                          interface Reason

                                                                                                                                                                                                                          interface Reason {}
                                                                                                                                                                                                                          • The object encapsulates information regarding the reasons why the ad is not being rendered.

                                                                                                                                                                                                                          property 'message'

                                                                                                                                                                                                                          message?: string;
                                                                                                                                                                                                                          • The message provides an explanation of the specific details as to why the ad is not being rendered.

                                                                                                                                                                                                                          property 'type'

                                                                                                                                                                                                                          type?: interfaces.alexa.advertisement.ReasonCode;
                                                                                                                                                                                                                          • The enum represents various details explaining why the ad is not being rendered.

                                                                                                                                                                                                                          type ReasonCode

                                                                                                                                                                                                                          type ReasonCode =
                                                                                                                                                                                                                          | 'DEVICE_OCCUPIED'
                                                                                                                                                                                                                          | 'UNSUPPORTED_DEVICE'
                                                                                                                                                                                                                          | 'SKILL_DAILY_CAP_LIMIT_REACHED'
                                                                                                                                                                                                                          | 'DOMAIN_DAILY_CAP_LIMIT_REACHED'
                                                                                                                                                                                                                          | 'INTERNAL_SERVER_ERROR'
                                                                                                                                                                                                                          | 'AD_NOT_AVAILABLE';
                                                                                                                                                                                                                          • The enum represents various details explaining why the ad is not being rendered.

                                                                                                                                                                                                                          namespace interfaces.alexa.comms

                                                                                                                                                                                                                          namespace interfaces.alexa.comms {}

                                                                                                                                                                                                                            namespace interfaces.alexa.comms.messagingcontroller

                                                                                                                                                                                                                            namespace interfaces.alexa.comms.messagingcontroller {}

                                                                                                                                                                                                                              interface StatusMap

                                                                                                                                                                                                                              interface StatusMap {}
                                                                                                                                                                                                                              • A map whose key is the new status and value is the message ID list. The status of the messages whose IDs are in the list will be updated to the new status from the key.

                                                                                                                                                                                                                              property 'deleted'

                                                                                                                                                                                                                              deleted?: Array<string>;
                                                                                                                                                                                                                              • List of deleted messages

                                                                                                                                                                                                                              property 'read'

                                                                                                                                                                                                                              read?: Array<string>;
                                                                                                                                                                                                                              • List of read messages

                                                                                                                                                                                                                              namespace interfaces.alexa.datastore

                                                                                                                                                                                                                              namespace interfaces.alexa.datastore {}

                                                                                                                                                                                                                                interface DataStoreError

                                                                                                                                                                                                                                interface DataStoreError {}
                                                                                                                                                                                                                                • This event is sent by DSCS to forward ExecutionError from device or to inform about delivery error.

                                                                                                                                                                                                                                property 'error'

                                                                                                                                                                                                                                error: interfaces.alexa.datastore.CommandsError;

                                                                                                                                                                                                                                  property 'locale'

                                                                                                                                                                                                                                  locale?: string;
                                                                                                                                                                                                                                  • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                                                                                  property 'requestId'

                                                                                                                                                                                                                                  requestId: string;
                                                                                                                                                                                                                                  • Represents the unique identifier for the specific request.

                                                                                                                                                                                                                                  property 'timestamp'

                                                                                                                                                                                                                                  timestamp: string;
                                                                                                                                                                                                                                  • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                                                                                  property 'type'

                                                                                                                                                                                                                                  type: 'Alexa.DataStore.Error';

                                                                                                                                                                                                                                    interface DataStoreInternalError

                                                                                                                                                                                                                                    interface DataStoreInternalError {}
                                                                                                                                                                                                                                    • Describes an execution error for unknown error from device DataStore.

                                                                                                                                                                                                                                    property 'content'

                                                                                                                                                                                                                                    content: interfaces.alexa.datastore.ExecutionErrorContent;

                                                                                                                                                                                                                                      property 'type'

                                                                                                                                                                                                                                      type: 'DATASTORE_INTERNAL_ERROR';

                                                                                                                                                                                                                                        interface DevicePermanantlyUnavailableError

                                                                                                                                                                                                                                        interface DevicePermanantlyUnavailableError {}
                                                                                                                                                                                                                                        • Describes a dispatch error when device is no longer available. Skill must stop pushing data to this device in the future.

                                                                                                                                                                                                                                        property 'content'

                                                                                                                                                                                                                                        content: interfaces.alexa.datastore.DispatchErrorContent;

                                                                                                                                                                                                                                          property 'type'

                                                                                                                                                                                                                                          type: 'DEVICE_PERMANENTLY_UNAVAILABLE';

                                                                                                                                                                                                                                            interface DeviceUnavailableError

                                                                                                                                                                                                                                            interface DeviceUnavailableError {}
                                                                                                                                                                                                                                            • Describes a dispatch error when device is not available.

                                                                                                                                                                                                                                            property 'content'

                                                                                                                                                                                                                                            content: interfaces.alexa.datastore.DispatchErrorContent;

                                                                                                                                                                                                                                              property 'type'

                                                                                                                                                                                                                                              type: 'DEVICE_UNAVAILABLE';

                                                                                                                                                                                                                                                interface DispatchErrorContent

                                                                                                                                                                                                                                                interface DispatchErrorContent {}
                                                                                                                                                                                                                                                • Content of a commands dispatch error.

                                                                                                                                                                                                                                                property 'commands'

                                                                                                                                                                                                                                                commands: Array<services.datastore.v1.Command>;
                                                                                                                                                                                                                                                • Commands in the same order of request time so that skill can extend deliver expiry.

                                                                                                                                                                                                                                                property 'deviceId'

                                                                                                                                                                                                                                                deviceId: string;
                                                                                                                                                                                                                                                • Identifier of the device where execution error happens.

                                                                                                                                                                                                                                                interface Error

                                                                                                                                                                                                                                                interface Error {}
                                                                                                                                                                                                                                                • Type of error. Modules can also use this event to report global error like permission denied. Supported values [STORAGE_LIMIT_EXCEEDED, PERMISSION_DENIED, VALIDATION_ERROR, DATASTORE_INTERNAL_ERROR]

                                                                                                                                                                                                                                                property 'content'

                                                                                                                                                                                                                                                content?: any;
                                                                                                                                                                                                                                                • Opaque payload which will contain additional details about error.

                                                                                                                                                                                                                                                property 'type'

                                                                                                                                                                                                                                                type: string;
                                                                                                                                                                                                                                                • Type of error. Modules can also use this event to report global error like permission denied

                                                                                                                                                                                                                                                interface ExecutionErrorContent

                                                                                                                                                                                                                                                interface ExecutionErrorContent {}
                                                                                                                                                                                                                                                • Content of an execution error.

                                                                                                                                                                                                                                                property 'deviceId'

                                                                                                                                                                                                                                                deviceId: string;
                                                                                                                                                                                                                                                • Identifier of the device where execution error happens.

                                                                                                                                                                                                                                                property 'failedCommand'

                                                                                                                                                                                                                                                failedCommand: services.datastore.v1.Command;
                                                                                                                                                                                                                                                • the command that was not executed successfully because of the error.

                                                                                                                                                                                                                                                property 'message'

                                                                                                                                                                                                                                                message?: string;
                                                                                                                                                                                                                                                • Opaque message describing the error.

                                                                                                                                                                                                                                                interface StorageLimitExeceededError

                                                                                                                                                                                                                                                interface StorageLimitExeceededError {}
                                                                                                                                                                                                                                                • Describes an execution error for exceeding storage limit.

                                                                                                                                                                                                                                                property 'content'

                                                                                                                                                                                                                                                content: interfaces.alexa.datastore.ExecutionErrorContent;

                                                                                                                                                                                                                                                  property 'type'

                                                                                                                                                                                                                                                  type: 'STORAGE_LIMIT_EXCEEDED';

                                                                                                                                                                                                                                                    type CommandsError

                                                                                                                                                                                                                                                    type CommandsError =
                                                                                                                                                                                                                                                    | interfaces.alexa.datastore.DeviceUnavailableError
                                                                                                                                                                                                                                                    | interfaces.alexa.datastore.DevicePermanantlyUnavailableError
                                                                                                                                                                                                                                                    | interfaces.alexa.datastore.DataStoreInternalError
                                                                                                                                                                                                                                                    | interfaces.alexa.datastore.StorageLimitExeceededError;
                                                                                                                                                                                                                                                    • DataStore error object payload.

                                                                                                                                                                                                                                                    namespace interfaces.alexa.datastore.packagemanager

                                                                                                                                                                                                                                                    namespace interfaces.alexa.datastore.packagemanager {}

                                                                                                                                                                                                                                                      interface AlexaDataStorePackageManagerInterface

                                                                                                                                                                                                                                                      interface AlexaDataStorePackageManagerInterface {}
                                                                                                                                                                                                                                                      • Interface using which skills communicate with DataStore Package Manager on the device.

                                                                                                                                                                                                                                                      interface InstallationError

                                                                                                                                                                                                                                                      interface InstallationError {}
                                                                                                                                                                                                                                                      • This event is sent by device DataStore Package Manager to let the skill developer know that there was a problem installing/updating the package.

                                                                                                                                                                                                                                                      property 'error'

                                                                                                                                                                                                                                                      error: interfaces.alexa.datastore.packagemanager.PackageError;

                                                                                                                                                                                                                                                        property 'locale'

                                                                                                                                                                                                                                                        locale?: string;
                                                                                                                                                                                                                                                        • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                                                                                                        property 'packageId'

                                                                                                                                                                                                                                                        packageId: string;
                                                                                                                                                                                                                                                        • Unique package identifier for a client.

                                                                                                                                                                                                                                                        property 'requestId'

                                                                                                                                                                                                                                                        requestId: string;
                                                                                                                                                                                                                                                        • Represents the unique identifier for the specific request.

                                                                                                                                                                                                                                                        property 'timestamp'

                                                                                                                                                                                                                                                        timestamp: string;
                                                                                                                                                                                                                                                        • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                                                                                                        property 'type'

                                                                                                                                                                                                                                                        type: 'Alexa.DataStore.PackageManager.InstallationError';

                                                                                                                                                                                                                                                          property 'version'

                                                                                                                                                                                                                                                          version: string;
                                                                                                                                                                                                                                                          • Current version of the package trying to be installed/updated on the device.

                                                                                                                                                                                                                                                          interface Package

                                                                                                                                                                                                                                                          interface Package {}
                                                                                                                                                                                                                                                          • Information of the package that is being installed on the device.

                                                                                                                                                                                                                                                          property 'packageVersion'

                                                                                                                                                                                                                                                          packageVersion: string;
                                                                                                                                                                                                                                                          • Version of a package manifest schema. Currently supported schema version is 1.0.

                                                                                                                                                                                                                                                          interface PackageError

                                                                                                                                                                                                                                                          interface PackageError {}
                                                                                                                                                                                                                                                          • Additional information about the package installation/update error.

                                                                                                                                                                                                                                                          property 'content'

                                                                                                                                                                                                                                                          content?: any;
                                                                                                                                                                                                                                                          • Opaque payload which will contain additional details about error.

                                                                                                                                                                                                                                                          property 'type'

                                                                                                                                                                                                                                                          type: interfaces.alexa.datastore.packagemanager.ErrorType;

                                                                                                                                                                                                                                                            interface PackageInstallUsage

                                                                                                                                                                                                                                                            interface PackageInstallUsage {}
                                                                                                                                                                                                                                                            • Places where the package is going to be used on the device. This object is passed as part of the InstallRequest to the skill.

                                                                                                                                                                                                                                                            property 'instanceId'

                                                                                                                                                                                                                                                            instanceId?: string;
                                                                                                                                                                                                                                                            • Identifier of the instance of the package.

                                                                                                                                                                                                                                                            property 'location'

                                                                                                                                                                                                                                                            location: interfaces.alexa.datastore.packagemanager.Locations;

                                                                                                                                                                                                                                                              interface PackageManagerState

                                                                                                                                                                                                                                                              interface PackageManagerState {}
                                                                                                                                                                                                                                                              • Provides context about the list of packages installed on the device.

                                                                                                                                                                                                                                                              property 'installedPackages'

                                                                                                                                                                                                                                                              installedPackages?: Array<interfaces.alexa.datastore.packagemanager.PackageStateInformation>;
                                                                                                                                                                                                                                                              • Includes all installed packages on the device.

                                                                                                                                                                                                                                                              interface PackageRemoveUsage

                                                                                                                                                                                                                                                              interface PackageRemoveUsage {}
                                                                                                                                                                                                                                                              • Places where the package is going to be not used anymore on the device. This object is passed as part of the PackageRemovedRequest to the skill.

                                                                                                                                                                                                                                                              property 'instanceId'

                                                                                                                                                                                                                                                              instanceId?: string;
                                                                                                                                                                                                                                                              • Identifier of the instance of the package.

                                                                                                                                                                                                                                                              property 'location'

                                                                                                                                                                                                                                                              location: interfaces.alexa.datastore.packagemanager.Locations;

                                                                                                                                                                                                                                                                interface PackageStateInformation

                                                                                                                                                                                                                                                                interface PackageStateInformation {}
                                                                                                                                                                                                                                                                • State information of the DataStore package version installed on the device.

                                                                                                                                                                                                                                                                property 'packageId'

                                                                                                                                                                                                                                                                packageId: string;
                                                                                                                                                                                                                                                                • Unique package identifier for a client.

                                                                                                                                                                                                                                                                property 'version'

                                                                                                                                                                                                                                                                version: string;
                                                                                                                                                                                                                                                                • Unique version of a package.

                                                                                                                                                                                                                                                                interface UpdateRequest

                                                                                                                                                                                                                                                                interface UpdateRequest {}
                                                                                                                                                                                                                                                                • This event is request sent by device DataStore Package Manager asking the skill developer them to update the version of the package on device.

                                                                                                                                                                                                                                                                property 'fromVersion'

                                                                                                                                                                                                                                                                fromVersion: string;
                                                                                                                                                                                                                                                                • Current version of a package installed on the device.

                                                                                                                                                                                                                                                                property 'locale'

                                                                                                                                                                                                                                                                locale?: string;
                                                                                                                                                                                                                                                                • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                                                                                                                property 'packageId'

                                                                                                                                                                                                                                                                packageId: string;
                                                                                                                                                                                                                                                                • Unique package identifier for a client.

                                                                                                                                                                                                                                                                property 'requestId'

                                                                                                                                                                                                                                                                requestId: string;
                                                                                                                                                                                                                                                                • Represents the unique identifier for the specific request.

                                                                                                                                                                                                                                                                property 'timestamp'

                                                                                                                                                                                                                                                                timestamp: string;
                                                                                                                                                                                                                                                                • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                                                                                                                property 'toVersion'

                                                                                                                                                                                                                                                                toVersion: string;
                                                                                                                                                                                                                                                                • Latest version of a package being installed on the device.

                                                                                                                                                                                                                                                                property 'type'

                                                                                                                                                                                                                                                                type: 'Alexa.DataStore.PackageManager.UpdateRequest';

                                                                                                                                                                                                                                                                  interface UsagesInstalled

                                                                                                                                                                                                                                                                  interface UsagesInstalled {}
                                                                                                                                                                                                                                                                  • This event is sent by device DataStore Package Manager to the skill developer to let them know about the usages of the packages being installed on the device.

                                                                                                                                                                                                                                                                  property 'locale'

                                                                                                                                                                                                                                                                  locale?: string;
                                                                                                                                                                                                                                                                  • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                                                                                                                  property 'payload'

                                                                                                                                                                                                                                                                  payload: interfaces.alexa.datastore.packagemanager.UsagesInstallRequest;

                                                                                                                                                                                                                                                                    property 'requestId'

                                                                                                                                                                                                                                                                    requestId: string;
                                                                                                                                                                                                                                                                    • Represents the unique identifier for the specific request.

                                                                                                                                                                                                                                                                    property 'timestamp'

                                                                                                                                                                                                                                                                    timestamp: string;
                                                                                                                                                                                                                                                                    • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                                                                                                                    property 'type'

                                                                                                                                                                                                                                                                    type: 'Alexa.DataStore.PackageManager.UsagesInstalled';

                                                                                                                                                                                                                                                                      interface UsagesInstallRequest

                                                                                                                                                                                                                                                                      interface UsagesInstallRequest {}
                                                                                                                                                                                                                                                                      • Information about the package that is going to be installed on the device and also where its going to be used on the device.

                                                                                                                                                                                                                                                                      property 'packageId'

                                                                                                                                                                                                                                                                      packageId: string;
                                                                                                                                                                                                                                                                      • Unique package identifier for a client.

                                                                                                                                                                                                                                                                      property 'packageVersion'

                                                                                                                                                                                                                                                                      packageVersion: string;
                                                                                                                                                                                                                                                                      • Version of a package being installed on the device.

                                                                                                                                                                                                                                                                      property 'usages'

                                                                                                                                                                                                                                                                      usages: Array<interfaces.alexa.datastore.packagemanager.PackageInstallUsage>;
                                                                                                                                                                                                                                                                      • Areas where package is going to be used on the device.

                                                                                                                                                                                                                                                                      interface UsagesRemoved

                                                                                                                                                                                                                                                                      interface UsagesRemoved {}
                                                                                                                                                                                                                                                                      • This event is sent by device DataStore Package Manager to let the skill developer know about the usages of packages removed from the device.

                                                                                                                                                                                                                                                                      property 'locale'

                                                                                                                                                                                                                                                                      locale?: string;
                                                                                                                                                                                                                                                                      • A string indicating the user’s locale. For example: en-US. This value is only provided with certain request types.

                                                                                                                                                                                                                                                                      property 'payload'

                                                                                                                                                                                                                                                                      payload: interfaces.alexa.datastore.packagemanager.UsagesRemovedRequest;

                                                                                                                                                                                                                                                                        property 'requestId'

                                                                                                                                                                                                                                                                        requestId: string;
                                                                                                                                                                                                                                                                        • Represents the unique identifier for the specific request.

                                                                                                                                                                                                                                                                        property 'timestamp'

                                                                                                                                                                                                                                                                        timestamp: string;
                                                                                                                                                                                                                                                                        • Provides the date and time when Alexa sent the request as an ISO 8601 formatted string. Used to verify the request when hosting your skill as a web service.

                                                                                                                                                                                                                                                                        property 'type'

                                                                                                                                                                                                                                                                        type: 'Alexa.DataStore.PackageManager.UsagesRemoved';

                                                                                                                                                                                                                                                                          interface UsagesRemovedRequest

                                                                                                                                                                                                                                                                          interface UsagesRemovedRequest {}
                                                                                                                                                                                                                                                                          • Information about where the package has been removed and where its not being used anymore.

                                                                                                                                                                                                                                                                          property 'packageId'

                                                                                                                                                                                                                                                                          packageId: string;
                                                                                                                                                                                                                                                                          • Unique package identifier for a client.

                                                                                                                                                                                                                                                                          property 'packageVersion'

                                                                                                                                                                                                                                                                          packageVersion: string;
                                                                                                                                                                                                                                                                          • Version of a package being removed from the device.

                                                                                                                                                                                                                                                                          property 'usages'

                                                                                                                                                                                                                                                                          usages: Array<interfaces.alexa.datastore.packagemanager.PackageRemoveUsage>;
                                                                                                                                                                                                                                                                          • Areas where package is going to be not used on the device.

                                                                                                                                                                                                                                                                          type ErrorType

                                                                                                                                                                                                                                                                          type ErrorType = 'INTERNAL_ERROR';
                                                                                                                                                                                                                                                                          • Type of package error. Allowed values are [INTERNAL_ERROR]

                                                                                                                                                                                                                                                                          type Locations

                                                                                                                                                                                                                                                                          type Locations = 'FAVORITE';
                                                                                                                                                                                                                                                                          • Location where the package can be rendered on the device.

                                                                                                                                                                                                                                                                          namespace interfaces.alexa.experimentation

                                                                                                                                                                                                                                                                          namespace interfaces.alexa.experimentation {}

                                                                                                                                                                                                                                                                            interface ExperimentAssignment

                                                                                                                                                                                                                                                                            interface ExperimentAssignment {}
                                                                                                                                                                                                                                                                            • Represents the state of an active experiment's assignment

                                                                                                                                                                                                                                                                            property 'id'

                                                                                                                                                                                                                                                                            id?: string;

                                                                                                                                                                                                                                                                              property 'treatmentId'

                                                                                                                                                                                                                                                                              treatmentId?: interfaces.alexa.experimentation.TreatmentId;

                                                                                                                                                                                                                                                                                interface ExperimentationState

                                                                                                                                                                                                                                                                                interface ExperimentationState {}

                                                                                                                                                                                                                                                                                property 'activeExperiments'

                                                                                                                                                                                                                                                                                activeExperiments?: Array<interfaces.alexa.experimentation.ExperimentAssignment>;

                                                                                                                                                                                                                                                                                  interface ExperimentTriggerResponse

                                                                                                                                                                                                                                                                                  interface ExperimentTriggerResponse {}
                                                                                                                                                                                                                                                                                  • Experiment trigger response from skill

                                                                                                                                                                                                                                                                                  property 'triggeredExperiments'

                                                                                                                                                                                                                                                                                  triggeredExperiments?: Array<string>;
                                                                                                                                                                                                                                                                                  • Contains array of triggered experiment ids

                                                                                                                                                                                                                                                                                  type TreatmentId

                                                                                                                                                                                                                                                                                  type TreatmentId = 'C' | 'T1';
                                                                                                                                                                                                                                                                                  • Experiment treatment identifier

                                                                                                                                                                                                                                                                                  namespace interfaces.alexa.extension

                                                                                                                                                                                                                                                                                  namespace interfaces.alexa.extension {}

                                                                                                                                                                                                                                                                                    interface AvailableExtension

                                                                                                                                                                                                                                                                                    interface AvailableExtension {}
                                                                                                                                                                                                                                                                                    • This object describes an extension that skill can request at runtime.

                                                                                                                                                                                                                                                                                    interface ExtensionsState

                                                                                                                                                                                                                                                                                    interface ExtensionsState {}

                                                                                                                                                                                                                                                                                    property 'available'

                                                                                                                                                                                                                                                                                    available: {
                                                                                                                                                                                                                                                                                    [key: string]: interfaces.alexa.extension.AvailableExtension;
                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                    • A map from extension URI to extension object where the object space is reserved for providing authorization information or other such data in the future.

                                                                                                                                                                                                                                                                                    namespace interfaces.alexa.presentation

                                                                                                                                                                                                                                                                                    namespace interfaces.alexa.presentation {}

                                                                                                                                                                                                                                                                                      interface AplPresentationStateContext

                                                                                                                                                                                                                                                                                      interface AplPresentationStateContext {}

                                                                                                                                                                                                                                                                                      property 'context'

                                                                                                                                                                                                                                                                                      context?: interfaces.alexa.presentation.apl.RenderedDocumentState;

                                                                                                                                                                                                                                                                                        property 'type'

                                                                                                                                                                                                                                                                                        type: 'Alexa.Presentation.APL';

                                                                                                                                                                                                                                                                                          interface PresentationState

                                                                                                                                                                                                                                                                                          interface PresentationState {}
                                                                                                                                                                                                                                                                                          • Provides context about presentations at the time of the request.

                                                                                                                                                                                                                                                                                          property 'contexts'

                                                                                                                                                                                                                                                                                          contexts?: Array<interfaces.alexa.presentation.PresentationStateContext>;
                                                                                                                                                                                                                                                                                          • Includes all presentation contexts owned by the skill which were perceptible at the time of the request.

                                                                                                                                                                                                                                                                                          type PresentationStateContext

                                                                                                                                                                                                                                                                                          type PresentationStateContext =
                                                                                                                                                                                                                                                                                          interfaces.alexa.presentation.AplPresentationStateContext;

                                                                                                                                                                                                                                                                                          namespace interfaces.alexa.presentation.apl

                                                                                                                                                                                                                                                                                          namespace interfaces.alexa.presentation.apl {}

                                                                                                                                                                                                                                                                                            interface AlexaPresentationAplInterface

                                                                                                                                                                                                                                                                                            interface AlexaPresentationAplInterface {}

                                                                                                                                                                                                                                                                                            property 'runtime'

                                                                                                                                                                                                                                                                                            runtime?: interfaces.alexa.presentation.apl.Runtime;

                                                                                                                                                                                                                                                                                              interface AnimatedOpacityProperty

                                                                                                                                                                                                                                                                                              interface AnimatedOpacityProperty {}

                                                                                                                                                                                                                                                                                              property 'from'

                                                                                                                                                                                                                                                                                              from?: number | string;
                                                                                                                                                                                                                                                                                              • The starting value of the property.

                                                                                                                                                                                                                                                                                              property 'property'

                                                                                                                                                                                                                                                                                              property: 'opacity';

                                                                                                                                                                                                                                                                                                property 'to'

                                                                                                                                                                                                                                                                                                to: number | string;
                                                                                                                                                                                                                                                                                                • The ending value of the property.

                                                                                                                                                                                                                                                                                                interface AnimatedTransformProperty

                                                                                                                                                                                                                                                                                                interface AnimatedTransformProperty {}

                                                                                                                                                                                                                                                                                                property 'from'

                                                                                                                                                                                                                                                                                                from: Array<interfaces.alexa.presentation.apl.TransformProperty>;
                                                                                                                                                                                                                                                                                                • The starting value of the property.

                                                                                                                                                                                                                                                                                                property 'property'

                                                                                                                                                                                                                                                                                                property: 'transform';

                                                                                                                                                                                                                                                                                                  property 'to'

                                                                                                                                                                                                                                                                                                  to: Array<interfaces.alexa.presentation.apl.TransformProperty>;
                                                                                                                                                                                                                                                                                                  • The ending value of the property.

                                                                                                                                                                                                                                                                                                  interface AnimateItemCommand

                                                                                                                                                                                                                                                                                                  interface AnimateItemCommand {}
                                                                                                                                                                                                                                                                                                  • Runs a fixed-duration animation sequence on one or more properties of a single component.

                                                                                                                                                                                                                                                                                                  property 'componentId'

                                                                                                                                                                                                                                                                                                  componentId: string;
                                                                                                                                                                                                                                                                                                  • The ID of the animated component.

                                                                                                                                                                                                                                                                                                  property 'delay'

                                                                                                                                                                                                                                                                                                  delay?: number | string;
                                                                                                                                                                                                                                                                                                  • The delay in milliseconds before this command starts executing; must be non-negative. Defaults to 0.

                                                                                                                                                                                                                                                                                                  property 'description'

                                                                                                                                                                                                                                                                                                  description?: string;
                                                                                                                                                                                                                                                                                                  • A user-provided description of this command.

                                                                                                                                                                                                                                                                                                  property 'duration'

                                                                                                                                                                                                                                                                                                  duration: number | string;
                                                                                                                                                                                                                                                                                                  • The duration of the animation (in milliseconds).

                                                                                                                                                                                                                                                                                                  property 'easing'

                                                                                                                                                                                                                                                                                                  easing?: string;
                                                                                                                                                                                                                                                                                                  • The easing curve.

                                                                                                                                                                                                                                                                                                  property 'repeatCount'

                                                                                                                                                                                                                                                                                                  repeatCount?: number | string;
                                                                                                                                                                                                                                                                                                  • Number of times to repeat.

                                                                                                                                                                                                                                                                                                  property 'repeatMode'

                                                                                                                                                                                                                                                                                                  repeatMode?: interfaces.alexa.presentation.apl.AnimateItemRepeatMode;

                                                                                                                                                                                                                                                                                                    property 'screenLock'

                                                                                                                                                                                                                                                                                                    screenLock?: boolean;
                                                                                                                                                                                                                                                                                                    • If true, disable the Interaction Timer.

                                                                                                                                                                                                                                                                                                    property 'sequencer'

                                                                                                                                                                                                                                                                                                    sequencer?: string;
                                                                                                                                                                                                                                                                                                    • Specify the sequencer that should execute this command.

                                                                                                                                                                                                                                                                                                    property 'type'

                                                                                                                                                                                                                                                                                                    type: 'AnimateItem';

                                                                                                                                                                                                                                                                                                      property 'value'

                                                                                                                                                                                                                                                                                                      value: Array<interfaces.alexa.presentation.apl.AnimatedProperty>;
                                                                                                                                                                                                                                                                                                      • An array of animated properties.

                                                                                                                                                                                                                                                                                                      property 'when'

                                                                                                                                                                                                                                                                                                      when?: boolean;
                                                                                                                                                                                                                                                                                                      • If false, the execution of the command is skipped. Defaults to true.

                                                                                                                                                                                                                                                                                                      interface AutoPageCommand

                                                                                                                                                                                                                                                                                                      interface AutoPageCommand {}
                                                                                                                                                                                                                                                                                                      • Automatically progress through a series of pages displayed in a Pager component. The AutoPage command finishes after the last page has been displayed for the requested time period.

                                                                                                                                                                                                                                                                                                      property 'componentId'

                                                                                                                                                                                                                                                                                                      componentId: string;
                                                                                                                                                                                                                                                                                                      • The id of the Pager component.

                                                                                                                                                                                                                                                                                                      property 'count'

                                                                                                                                                                                                                                                                                                      count?: number | string;
                                                                                                                                                                                                                                                                                                      • Number of pages to display. Defaults to all of them.

                                                                                                                                                                                                                                                                                                      property 'delay'

                                                                                                                                                                                                                                                                                                      delay?: number | string;
                                                                                                                                                                                                                                                                                                      • The delay in milliseconds before this command starts executing; must be non-negative. Defaults to 0.

                                                                                                                                                                                                                                                                                                      property 'description'

                                                                                                                                                                                                                                                                                                      description?: string;
                                                                                                                                                                                                                                                                                                      • A user-provided description of this command.

                                                                                                                                                                                                                                                                                                      property 'duration'

                                                                                                                                                                                                                                                                                                      duration?: number | string;
                                                                                                                                                                                                                                                                                                      • Time to wait between pages (in milliseconds). Defaults to 0.

                                                                                                                                                                                                                                                                                                      property 'screenLock'

                                                                                                                                                                                                                                                                                                      screenLock?: boolean;
                                                                                                                                                                                                                                                                                                      • If true, disable the Interaction Timer.

                                                                                                                                                                                                                                                                                                      property 'sequencer'

                                                                                                                                                                                                                                                                                                      sequencer?: string;
                                                                                                                                                                                                                                                                                                      • Specify the sequencer that should execute this command.

                                                                                                                                                                                                                                                                                                      property 'type'

                                                                                                                                                                                                                                                                                                      type: 'AutoPage';

                                                                                                                                                                                                                                                                                                        property 'when'

                                                                                                                                                                                                                                                                                                        when?: boolean;
                                                                                                                                                                                                                                                                                                        • If false, the execution of the command is skipped. Defaults to true.

                                                                                                                                                                                                                                                                                                        interface ClearFocusCommand

                                                                                                                                                                                                                                                                                                        interface ClearFocusCommand {}
                                                                                                                                                                                                                                                                                                        • Removes focus from the component that is currently in focus.

                                                                                                                                                                                                                                                                                                        property 'delay'

                                                                                                                                                                                                                                                                                                        delay?: number | string;
                                                                                                                                                                                                                                                                                                        • The delay in milliseconds before this command starts executing; must be non-negative. Defaults to 0.

                                                                                                                                                                                                                                                                                                        property 'description'

                                                                                                                                                                                                                                                                                                        description?: string;
                                                                                                                                                                                                                                                                                                        • A user-provided description of this command.

                                                                                                                                                                                                                                                                                                        property 'screenLock'

                                                                                                                                                                                                                                                                                                        screenLock?: boolean;
                                                                                                                                                                                                                                                                                                        • If true, disable the Interaction Timer.

                                                                                                                                                                                                                                                                                                        property 'sequencer'

                                                                                                                                                                                                                                                                                                        sequencer?: string;
                                                                                                                                                                                                                                                                                                        • Specify the sequencer that should execute this command.

                                                                                                                                                                                                                                                                                                        property 'type'

                                                                                                                                                                                                                                                                                                        type: 'ClearFocus';

                                                                                                                                                                                                                                                                                                          property 'when'

                                                                                                                                                                                                                                                                                                          when?: boolean;
                                                                                                                                                                                                                                                                                                          • If false, the execution of the command is skipped. Defaults to true.

                                                                                                                                                                                                                                                                                                          interface ComponentEntity

                                                                                                                                                                                                                                                                                                          interface ComponentEntity {}
                                                                                                                                                                                                                                                                                                          • The entity context data which was attached to an element.

                                                                                                                                                                                                                                                                                                          property 'id'

                                                                                                                                                                                                                                                                                                          id?: string;

                                                                                                                                                                                                                                                                                                            property 'type'

                                                                                                                                                                                                                                                                                                            type?: string;

                                                                                                                                                                                                                                                                                                              property 'value'

                                                                                                                                                                                                                                                                                                              value?: string;

                                                                                                                                                                                                                                                                                                                interface ComponentVisibleOnScreen

                                                                                                                                                                                                                                                                                                                interface ComponentVisibleOnScreen {}
                                                                                                                                                                                                                                                                                                                • Definition of a visible APL element shown on screen.

                                                                                                                                                                                                                                                                                                                property 'children'

                                                                                                                                                                                                                                                                                                                children?: Array<interfaces.alexa.presentation.apl.ComponentVisibleOnScreen>;
                                                                                                                                                                                                                                                                                                                • All child elements of the displayed element.

                                                                                                                                                                                                                                                                                                                property 'entities'

                                                                                                                                                                                                                                                                                                                entities?: Array<interfaces.alexa.presentation.apl.ComponentEntity>;
                                                                                                                                                                                                                                                                                                                • The entities which were attached to the element.

                                                                                                                                                                                                                                                                                                                property 'id'

                                                                                                                                                                                                                                                                                                                id: string;
                                                                                                                                                                                                                                                                                                                • The id of the element.

                                                                                                                                                                                                                                                                                                                property 'position'

                                                                                                                                                                                                                                                                                                                position: string;
                                                                                                                                                                                                                                                                                                                • Global position of the element (as seen by the device user).

                                                                                                                                                                                                                                                                                                                property 'tags'

                                                                                                                                                                                                                                                                                                                tags: interfaces.alexa.presentation.apl.ComponentVisibleOnScreenTags;
                                                                                                                                                                                                                                                                                                                • The tags which were attached to the element.

                                                                                                                                                                                                                                                                                                                property 'transform'

                                                                                                                                                                                                                                                                                                                transform?: Array<number>;
                                                                                                                                                                                                                                                                                                                • The transform which was applied to the element's position, specified as a 6-element numeric array containing the 2D homogeneous transformation matrix. The center of the transformation coordinate system is the center of the component. The transformation array is ordered as [A,B,C,D,Tx,Ty]. For more information refer to the W3C's CSS transforms documentation.

                                                                                                                                                                                                                                                                                                                property 'type'

                                                                                                                                                                                                                                                                                                                type: string;
                                                                                                                                                                                                                                                                                                                • The visual appearance of the element.

                                                                                                                                                                                                                                                                                                                property 'uid'

                                                                                                                                                                                                                                                                                                                uid: string;
                                                                                                                                                                                                                                                                                                                • The system-generated uid of the element.

                                                                                                                                                                                                                                                                                                                property 'visibility'

                                                                                                                                                                                                                                                                                                                visibility?: number;
                                                                                                                                                                                                                                                                                                                • The relative visibility of the element. 0 = not visible, 1 = fully visible on screen.

                                                                                                                                                                                                                                                                                                                interface ComponentVisibleOnScreenListItemTag

                                                                                                                                                                                                                                                                                                                interface ComponentVisibleOnScreenListItemTag {}
                                                                                                                                                                                                                                                                                                                • An element in a scrolling list

                                                                                                                                                                                                                                                                                                                property 'index'

                                                                                                                                                                                                                                                                                                                index?: number;
                                                                                                                                                                                                                                                                                                                • The zero-based index of this item in its parent.

                                                                                                                                                                                                                                                                                                                interface ComponentVisibleOnScreenListTag

                                                                                                                                                                                                                                                                                                                interface ComponentVisibleOnScreenListTag {}
                                                                                                                                                                                                                                                                                                                • An ordered list of items

                                                                                                                                                                                                                                                                                                                property 'highestIndexSeen'

                                                                                                                                                                                                                                                                                                                highestIndexSeen?: number;
                                                                                                                                                                                                                                                                                                                • The index of the highest item seen.

                                                                                                                                                                                                                                                                                                                property 'highestOrdinalSeen'

                                                                                                                                                                                                                                                                                                                highestOrdinalSeen?: number;
                                                                                                                                                                                                                                                                                                                • The ordinal of the highest ordinal-equipped item seen.

                                                                                                                                                                                                                                                                                                                property 'itemCount'

                                                                                                                                                                                                                                                                                                                itemCount?: number;
                                                                                                                                                                                                                                                                                                                • The total number of items in the list.

                                                                                                                                                                                                                                                                                                                property 'lowestIndexSeen'

                                                                                                                                                                                                                                                                                                                lowestIndexSeen?: number;
                                                                                                                                                                                                                                                                                                                • The index of the lowest item seen.

                                                                                                                                                                                                                                                                                                                property 'lowestOrdinalSeen'

                                                                                                                                                                                                                                                                                                                lowestOrdinalSeen?: number;
                                                                                                                                                                                                                                                                                                                • The ordinal of the lowest ordinal-equipped item seen.

                                                                                                                                                                                                                                                                                                                interface ComponentVisibleOnScreenMediaTag

                                                                                                                                                                                                                                                                                                                interface ComponentVisibleOnScreenMediaTag {}
                                                                                                                                                                                                                                                                                                                • Media player

                                                                                                                                                                                                                                                                                                                property 'allowAdjustSeekPositionBackwards'

                                                                                                                                                                                                                                                                                                                allowAdjustSeekPositionBackwards?: boolean;
                                                                                                                                                                                                                                                                                                                • Whether the user may seek backwards relative to the current position.

                                                                                                                                                                                                                                                                                                                property 'allowAdjustSeekPositionForward'

                                                                                                                                                                                                                                                                                                                allowAdjustSeekPositionForward?: boolean;
                                                                                                                                                                                                                                                                                                                • Whether the user may seek forward relative to the current position.

                                                                                                                                                                                                                                                                                                                property 'allowNext'

                                                                                                                                                                                                                                                                                                                allowNext?: boolean;
                                                                                                                                                                                                                                                                                                                • Whether the user may move forward to the next track.

                                                                                                                                                                                                                                                                                                                property 'allowPrevious'

                                                                                                                                                                                                                                                                                                                allowPrevious?: boolean;
                                                                                                                                                                                                                                                                                                                • Whether the user may move backward to the previous track.

                                                                                                                                                                                                                                                                                                                property 'entities'

                                                                                                                                                                                                                                                                                                                entities?: Array<interfaces.alexa.presentation.apl.ComponentEntity>;

                                                                                                                                                                                                                                                                                                                  property 'positionInMilliseconds'

                                                                                                                                                                                                                                                                                                                  positionInMilliseconds?: number;
                                                                                                                                                                                                                                                                                                                  • Current position of the play head from the start of the track.

                                                                                                                                                                                                                                                                                                                  property 'state'

                                                                                                                                                                                                                                                                                                                  state?: interfaces.alexa.presentation.apl.ComponentVisibleOnScreenMediaTagStateEnum;

                                                                                                                                                                                                                                                                                                                    property 'url'

                                                                                                                                                                                                                                                                                                                    url?: string;
                                                                                                                                                                                                                                                                                                                    • The URL of the current media track.

                                                                                                                                                                                                                                                                                                                    interface ComponentVisibleOnScreenPagerTag

                                                                                                                                                                                                                                                                                                                    interface ComponentVisibleOnScreenPagerTag {}
                                                                                                                                                                                                                                                                                                                    • A collection of items that are displayed one at a time.

                                                                                                                                                                                                                                                                                                                    property 'allowBackwards'

                                                                                                                                                                                                                                                                                                                    allowBackwards?: boolean;
                                                                                                                                                                                                                                                                                                                    • Indicates whether the pager will accept a backward command.

                                                                                                                                                                                                                                                                                                                    property 'allowForward'

                                                                                                                                                                                                                                                                                                                    allowForward?: boolean;
                                                                                                                                                                                                                                                                                                                    • Indicates whether the pager will accept a forward command.

                                                                                                                                                                                                                                                                                                                    property 'index'

                                                                                                                                                                                                                                                                                                                    index?: number;
                                                                                                                                                                                                                                                                                                                    • The index of the current page.

                                                                                                                                                                                                                                                                                                                    property 'pageCount'

                                                                                                                                                                                                                                                                                                                    pageCount?: number;
                                                                                                                                                                                                                                                                                                                    • The total number of pages.

                                                                                                                                                                                                                                                                                                                    interface ComponentVisibleOnScreenScrollableTag

                                                                                                                                                                                                                                                                                                                    interface ComponentVisibleOnScreenScrollableTag {}
                                                                                                                                                                                                                                                                                                                    • A scrollable region.

                                                                                                                                                                                                                                                                                                                    property 'allowBackward'

                                                                                                                                                                                                                                                                                                                    allowBackward?: boolean;
                                                                                                                                                                                                                                                                                                                    • Whether scrolling backward is accepted.

                                                                                                                                                                                                                                                                                                                    property 'allowForward'

                                                                                                                                                                                                                                                                                                                    allowForward?: boolean;
                                                                                                                                                                                                                                                                                                                    • Whether scrolling forward is accepted.

                                                                                                                                                                                                                                                                                                                    property 'direction'

                                                                                                                                                                                                                                                                                                                    direction?: interfaces.alexa.presentation.apl.ComponentVisibleOnScreenScrollableTagDirectionEnum;

                                                                                                                                                                                                                                                                                                                      interface ComponentVisibleOnScreenTags

                                                                                                                                                                                                                                                                                                                      interface ComponentVisibleOnScreenTags {}
                                                                                                                                                                                                                                                                                                                      • The tags which were attached to an element.

                                                                                                                                                                                                                                                                                                                      property 'checked'

                                                                                                                                                                                                                                                                                                                      checked?: boolean;
                                                                                                                                                                                                                                                                                                                      • The checked state of a component that has two states.

                                                                                                                                                                                                                                                                                                                      property 'clickable'

                                                                                                                                                                                                                                                                                                                      clickable?: boolean;
                                                                                                                                                                                                                                                                                                                      • A button or item that can be pressed.

                                                                                                                                                                                                                                                                                                                      property 'disabled'

                                                                                                                                                                                                                                                                                                                      disabled?: boolean;
                                                                                                                                                                                                                                                                                                                      • Whether the element is disabled.

                                                                                                                                                                                                                                                                                                                      property 'focused'

                                                                                                                                                                                                                                                                                                                      focused?: boolean;
                                                                                                                                                                                                                                                                                                                      • The focused state of a component that can take focus.

                                                                                                                                                                                                                                                                                                                      property 'list'

                                                                                                                                                                                                                                                                                                                      list?: interfaces.alexa.presentation.apl.ComponentVisibleOnScreenListTag;
                                                                                                                                                                                                                                                                                                                      • An ordered list of items.

                                                                                                                                                                                                                                                                                                                      property 'listItem'

                                                                                                                                                                                                                                                                                                                      listItem?: interfaces.alexa.presentation.apl.ComponentVisibleOnScreenListItemTag;
                                                                                                                                                                                                                                                                                                                      • An element in a sequence.

                                                                                                                                                                                                                                                                                                                      property 'media'

                                                                                                                                                                                                                                                                                                                      media?: interfaces.alexa.presentation.apl.ComponentVisibleOnScreenMediaTag;
                                                                                                                                                                                                                                                                                                                      • Media player

                                                                                                                                                                                                                                                                                                                      property 'ordinal'

                                                                                                                                                                                                                                                                                                                      ordinal?: number;
                                                                                                                                                                                                                                                                                                                      • A visibly numbered element.

                                                                                                                                                                                                                                                                                                                      property 'pager'

                                                                                                                                                                                                                                                                                                                      pager?: interfaces.alexa.presentation.apl.ComponentVisibleOnScreenPagerTag;
                                                                                                                                                                                                                                                                                                                      • A collection of items that are displayed one at a time.

                                                                                                                                                                                                                                                                                                                      property 'scrollable'

                                                                                                                                                                                                                                                                                                                      scrollable?: interfaces.alexa.presentation.apl.ComponentVisibleOnScreenScrollableTag;
                                                                                                                                                                                                                                                                                                                      • A scrolling region

                                                                                                                                                                                                                                                                                                                      property 'spoken'

                                                                                                                                                                                                                                                                                                                      spoken?: boolean;
                                                                                                                                                                                                                                                                                                                      • A region of the screen that can be read out by TTS

                                                                                                                                                                                                                                                                                                                      property 'viewport'

                                                                                                                                                                                                                                                                                                                      viewport?: interfaces.alexa.presentation.apl.ComponentVisibleOnScreenViewportTag;
                                                                                                                                                                                                                                                                                                                      • The entire screen in which a document is rendered.

                                                                                                                                                                                                                                                                                                                      interface ComponentVisibleOnScreenViewportTag

                                                                                                                                                                                                                                                                                                                      interface ComponentVisibleOnScreenViewportTag {}
                                                                                                                                                                                                                                                                                                                      • The entire screen in which a document is rendered.

                                                                                                                                                                                                                                                                                                                      interface ControlMediaCommand

                                                                                                                                                                                                                                                                                                                      interface ControlMediaCommand {}
                                                                                                                                                                                                                                                                                                                      • Control a media player to play, pause, change tracks, or perform some other common action.

                                                                                                                                                                                                                                                                                                                      property 'command'

                                                                                                                                                                                                                                                                                                                      command: interfaces.alexa.presentation.apl.MediaCommandType;
                                                                                                                                                                                                                                                                                                                      • The command to issue on the media player

                                                                                                                                                                                                                                                                                                                      property 'componentId'

                                                                                                                                                                                                                                                                                                                      componentId?: string;
                                                                                                                                                                                                                                                                                                                      • The name of the media playing component

                                                                                                                                                                                                                                                                                                                      property 'delay'

                                                                                                                                                                                                                                                                                                                      delay?: number | string;
                                                                                                                                                                                                                                                                                                                      • The delay in milliseconds before this command starts executing; must be non-negative. Defaults to 0.

                                                                                                                                                                                                                                                                                                                      property 'description'

                                                                                                                                                                                                                                                                                                                      description?: string;
                                                                                                                                                                                                                                                                                                                      • A user-provided description of this command.

                                                                                                                                                                                                                                                                                                                      property 'screenLock'

                                                                                                                                                                                                                                                                                                                      screenLock?: boolean;
                                                                                                                                                                                                                                                                                                                      • If true, disable the Interaction Timer.

                                                                                                                                                                                                                                                                                                                      property 'sequencer'

                                                                                                                                                                                                                                                                                                                      sequencer?: string;
                                                                                                                                                                                                                                                                                                                      • Specify the sequencer that should execute this command.

                                                                                                                                                                                                                                                                                                                      property 'type'

                                                                                                                                                                                                                                                                                                                      type: 'ControlMedia';

                                                                                                                                                                                                                                                                                                                        property 'value'

                                                                                                                                                                                                                                                                                                                        value?: number | string;
                                                                                                                                                                                                                                                                                                                        • Optional data value

                                                                                                                                                                                                                                                                                                                        property 'when'

                                                                                                                                                                                                                                                                                                                        when?: boolean;
                                                                                                                                                                                                                                                                                                                        • If false, the execution of the command is skipped. Defaults to true.

                                                                                                                                                                                                                                                                                                                        interface ExecuteCommandsDirective

                                                                                                                                                                                                                                                                                                                        interface ExecuteCommandsDirective {}
                                                                                                                                                                                                                                                                                                                        • Alexa.Presentation.APL.ExecuteCommands directive used to send APL commands to a device.

                                                                                                                                                                                                                                                                                                                        property 'commands'

                                                                                                                                                                                                                                                                                                                        commands: Array<interfaces.alexa.presentation.apl.Command>;
                                                                                                                                                                                                                                                                                                                        • List of Command instances

                                                                                                                                                                                                                                                                                                                        property 'token'

                                                                                                                                                                                                                                                                                                                        token: string;
                                                                                                                                                                                                                                                                                                                        • A skill defined token, unique for each presentation. Must match the token provided by the skill in the RenderDocument directive used to render the original APL document.

                                                                                                                                                                                                                                                                                                                        property 'type'

                                                                                                                                                                                                                                                                                                                        type: 'Alexa.Presentation.APL.ExecuteCommands';

                                                                                                                                                                                                                                                                                                                          interface FinishCommand

                                                                                                                                                                                                                                                                                                                          interface FinishCommand {}
                                                                                                                                                                                                                                                                                                                          • The finish command closes the current APL document and exits.

                                                                                                                                                                                                                                                                                                                          property 'delay'

                                                                                                                                                                                                                                                                                                                          delay?: number | string;
                                                                                                                                                                                                                                                                                                                          • The delay in milliseconds before this command starts executing; must be non-negative. Defaults to 0.

                                                                                                                                                                                                                                                                                                                          property 'description'

                                                                                                                                                                                                                                                                                                                          description?: string;
                                                                                                                                                                                                                                                                                                                          • A user-provided description of this command.

                                                                                                                                                                                                                                                                                                                          property 'screenLock'

                                                                                                                                                                                                                                                                                                                          screenLock?: boolean;
                                                                                                                                                                                                                                                                                                                          • If true, disable the Interaction Timer.

                                                                                                                                                                                                                                                                                                                          property 'sequencer'

                                                                                                                                                                                                                                                                                                                          sequencer?: string;
                                                                                                                                                                                                                                                                                                                          • Specify the sequencer that should execute this command.

                                                                                                                                                                                                                                                                                                                          property 'type'

                                                                                                                                                                                                                                                                                                                          type: 'Finish';

                                                                                                                                                                                                                                                                                                                            property 'when'

                                                                                                                                                                                                                                                                                                                            when?: boolean;
                                                                                                                                                                                                                                                                                                                            • If false, the execution of the command is skipped. Defaults to true.

                                                                                                                                                                                                                                                                                                                            interface GoBackCommand

                                                                                                                                                                                                                                                                                                                            interface GoBackCommand {}
                                                                                                                                                                                                                                                                                                                            • GoBack command POJO for the backstack APL extension.

                                                                                                                                                                                                                                                                                                                            property 'backType'

                                                                                                                                                                                                                                                                                                                            backType: interfaces.alexa.presentation.apl.BackType;

                                                                                                                                                                                                                                                                                                                              property 'backValue'

                                                                                                                                                                                                                                                                                                                              backValue: string;
                                                                                                                                                                                                                                                                                                                              • The value of go back command.

                                                                                                                                                                                                                                                                                                                              property 'delay'

                                                                                                                                                                                                                                                                                                                              delay?: number | string;
                                                                                                                                                                                                                                                                                                                              • The delay in milliseconds before this command starts executing; must be non-negative. Defaults to 0.

                                                                                                                                                                                                                                                                                                                              property 'description'

                                                                                                                                                                                                                                                                                                                              description?: string;
                                                                                                                                                                                                                                                                                                                              • A user-provided description of this command.

                                                                                                                                                                                                                                                                                                                              property 'screenLock'

                                                                                                                                                                                                                                                                                                                              screenLock?: boolean;
                                                                                                                                                                                                                                                                                                                              • If true, disable the Interaction Timer.

                                                                                                                                                                                                                                                                                                                              property 'sequencer'

                                                                                                                                                                                                                                                                                                                              sequencer?: string;
                                                                                                                                                                                                                                                                                                                              • Specify the sequencer that should execute this command.

                                                                                                                                                                                                                                                                                                                              property 'type'