ask-sdk-model/index.d.ts

export declare namespace services {
    /**
     * Represents the interface between ApiClient and a Service Client.
     * @export
     * @interface ApiClientMessage
     */
    interface ApiClientMessage {
        headers: Array<{
            key: string;
            value: string;
        }>;
        body?: string;
    }
    /**
     * Represents a request sent from Service Clients to an ApiClient implementation.
     * @export
     * @interface ApiClientRequest
     * @extends {ApiClientMessage}
     */
    interface ApiClientRequest extends ApiClientMessage {
        url: string;
        method: string;
    }
    /**
     * Represents a response returned by ApiClient implementation to a Service Client.
     * @export
     * @interface ApiClientResponse
     * @extends {ApiClientMessage}
     */
    interface ApiClientResponse extends ApiClientMessage {
        /**
         * Result code of the attempt to satisfy the request. Normally this
         * corresponds to the HTTP status code returned by the server.
         */
        statusCode: number;
    }
    /**
     * Represents a response with parsed body.
     * @export
     * @interface ApiResponse
     */
    interface ApiResponse {
        headers: Array<{
            key: string;
            value: string;
        }>;
        body?: any;
        statusCode: number;
    }
    /**
     * Represents a basic contract for API request execution
     * @export
     * @interface ApiClient
     */
    interface ApiClient {
        /**
         * Dispatches a request to an API endpoint described in the request.
         * An ApiClient is expected to resolve the Promise in the case an API returns a non-200 HTTP
         * status code. The responsibility of translating a particular response code to an error lies with the
         * caller to invoke.
         * @param {ApiClientRequest} request request to dispatch to the ApiClient
         * @returns {Promise<ApiClientResponse>} Response from the ApiClient
         * @memberof ApiClient
         */
        invoke(request: ApiClientRequest): Promise<ApiClientResponse>;
    }
    /**
     * Represents an interface that provides API configuration options needed by service clients.
     * @interface ApiConfiguration
     */
    interface ApiConfiguration {
        /**
         * Configured ApiClient implementation
         */
        apiClient: ApiClient;
        /**
         * Authorization value to be used on any calls of the service client instance
         */
        authorizationValue: string;
        /**
         * Endpoint to hit by the service client instance
         */
        apiEndpoint: string;
    }
    /**
     * Class to be used as the base class for the generated service clients.
     */
    abstract class BaseServiceClient {
        private static isCodeSuccessful;
        private static buildUrl;
        private static interpolateParams;
        private static buildQueryString;
        /**
         * ApiConfiguration instance to provide dependencies for this service client
         */
        protected apiConfiguration: ApiConfiguration;
        private requestInterceptors;
        private responseInterceptors;
        /**
         * Creates new instance of the BaseServiceClient
         * @param {ApiConfiguration} apiConfiguration configuration parameter to provide dependencies to service client instance
         */
        protected constructor(apiConfiguration: ApiConfiguration);
        /**
         * Sets array of functions that is going to be executed before the request is send
         * @param {Function} requestInterceptor request interceptor function
         * @returns {BaseServiceClient}
         */
        withRequestInterceptors(...requestInterceptors: Array<(request: ApiClientRequest) => void | Promise<void>>): BaseServiceClient;
        /**
         * Sets array of functions that is going to be executed after the request is send
         * @param {Function} responseInterceptor response interceptor function
         * @returns {BaseServiceClient}
         */
        withResponseInterceptors(...responseInterceptors: Array<(response: ApiClientResponse) => void | Promise<void>>): BaseServiceClient;
        /**
         * Invocation wrapper to implement service operations in generated classes
         * @param method HTTP method, such as 'POST', 'GET', 'DELETE', etc.
         * @param endpoint base API url
         * @param path the path pattern with possible placeholders for path parameters in form {paramName}
         * @param pathParams path parameters collection
         * @param queryParams query parameters collection
         * @param headerParams headers collection
         * @param bodyParam if body parameter is present it is provided here, otherwise null or undefined
         * @param errors maps recognized status codes to messages
         * @param nonJsonBody if the body is in JSON format
         */
        protected invoke(method: string, endpoint: string, path: string, pathParams: Map<string, string>, queryParams: Array<{
            key: string;
            value: string;
        }>, headerParams: Array<{
            key: string;
            value: string;
        }>, bodyParam: any, errors: Map<number, string>, nonJsonBody?: boolean): Promise<any>;
    }
    /**
     * Represents a Login With Amazon(LWA) access token
     */
    interface AccessToken {
        token: string;
        expiry: Number;
    }
    /**
     * Represents a request for retrieving a Login With Amazon(LWA) access token
     */
    interface AccessTokenRequest {
        clientId: string;
        clientSecret: string;
        scope?: string;
        refreshToken?: string;
    }
    /**
     * Represents a response returned by LWA containing a Login With Amazon(LWA) access token
     */
    interface AccessTokenResponse {
        access_token: string;
        expires_in: number;
        scope: string;
        token_type: string;
    }
    /**
     * Represents the authentication configuration for a client ID and client secret
     */
    interface AuthenticationConfiguration {
        clientId: string;
        clientSecret: string;
        refreshToken?: string;
        authEndpoint?: string;
    }
    /**
     * Class to be used to call Amazon LWA to retrieve access tokens.
     */
    class LwaServiceClient extends BaseServiceClient {
        protected static EXPIRY_OFFSET_MILLIS: number;
        protected static REFRESH_ACCESS_TOKEN: string;
        protected static CLIENT_CREDENTIALS_GRANT_TYPE: string;
        protected static LWA_CREDENTIALS_GRANT_TYPE: string;
        protected static AUTH_ENDPOINT: string;
        protected authenticationConfiguration: AuthenticationConfiguration;
        protected tokenStore: {
            [cacheKey: string]: AccessToken;
        };
        protected grantType: string;
        constructor(options: {
            apiConfiguration: ApiConfiguration;
            authenticationConfiguration: AuthenticationConfiguration;
            grantType?: string;
        });
        getAccessTokenForScope(scope: string): Promise<string>;
        getAccessToken(scope?: string): Promise<string>;
        protected generateAccessToken(accessTokenRequest: AccessTokenRequest): Promise<AccessTokenResponse>;
    }
}
/**
 * function creating an AskSdk user agent.
 * @param packageVersion
 * @param customUserAgent
 */
export declare function createUserAgent(packageVersion: string, customUserAgent: string): string;
/**
 * An object containing an application ID. This is used to verify that the request was intended for your service.
 * @interface
 */
export interface Application {
    /**
     * A string representing the application identifier for your skill.
     */
    'applicationId': string;
}
/**
 * Describes the type of the Cause.
 * @interface
 */
export declare type Cause = ConnectionCompleted;
/**
 *
 * @interface
 */
export interface Context {
    /**
     * Provides information about the current state of the Alexa service and the device interacting with your skill.
     */
    'System': interfaces.system.SystemState;
    /**
     * Provides the current state for the Alexa.Presentation interface.
     */
    'Alexa.Presentation'?: interfaces.alexa.presentation.PresentationState;
    /**
     * Provides the current state for the Alexa.Presentation.APL interface.
     */
    'Alexa.Presentation.APL'?: interfaces.alexa.presentation.apl.RenderedDocumentState;
    /**
     * Provides the current state for the AudioPlayer interface.
     */
    'AudioPlayer'?: interfaces.audioplayer.AudioPlayerState;
    /**
     * Provides the automotive specific information of the device.
     */
    'Automotive'?: interfaces.automotive.AutomotiveState;
    /**
     * Provides the current state for the Display interface.
     */
    'Display'?: interfaces.display.DisplayState;
    /**
     * Provides the last gathered geolocation information of the device.
     */
    'Geolocation'?: interfaces.geolocation.GeolocationState;
    /**
     * Provides the characteristics of a device's viewport.
     */
    'Viewport'?: interfaces.viewport.ViewportState;
    /**
     * This object contains a list of viewports characteristics related to the device's viewports.
     */
    'Viewports'?: Array<interfaces.viewport.TypedViewportState>;
    /**
     * Provides the current state for Extensions interface
     */
    'Extensions'?: interfaces.alexa.extension.ExtensionsState;
    /**
     * Provides the current state for the Alexa.DataStore.PackageManager interface.
     */
    'Alexa.DataStore.PackageManager'?: interfaces.alexa.datastore.packagemanager.PackageManagerState;
    /**
     * Provides the current state for app link capability.
     */
    'AppLink'?: interfaces.applink.AppLinkState;
    /**
     * Provides the current experimentation state
     */
    'Experimentation'?: interfaces.alexa.experimentation.ExperimentationState;
}
/**
 * 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.
 * @interface
 */
export interface Device {
    /**
     * 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.
     */
    'deviceId': 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.
     */
    'persistentEndpointId'?: string;
    /**
     * 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
     */
    'supportedInterfaces': SupportedInterfaces;
}
/**
 * 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.
 * @enum
 */
export declare type DialogState = 'STARTED' | 'IN_PROGRESS' | 'COMPLETED';
/**
 *
 * @interface
 */
export declare 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;
/**
 * An object that represents what the user wants.
 * @interface
 */
export interface Intent {
    /**
     * A string representing the name of the intent.
     */
    'name': string;
    /**
     * A map of key-value pairs that further describes what the user meant based on a predefined intent schema. The map can be empty.
     */
    'slots'?: {
        [key: string]: Slot;
    };
    'confirmationStatus': IntentConfirmationStatus;
}
/**
 * Indication of whether an intent or slot has been explicitly confirmed or denied by the user, or neither.
 * @enum
 */
export declare type IntentConfirmationStatus = 'NONE' | 'DENIED' | 'CONFIRMED';
/**
 * This denotes the status of the permission scope.
 * @enum
 */
export declare type PermissionStatus = 'GRANTED' | 'DENIED';
/**
 * 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.
 * @interface
 */
export interface Permissions {
    /**
     * A token listing all the permissions granted for this user.
     */
    'consentToken'?: string;
    /**
     * 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.
     */
    'scopes'?: {
        [key: string]: Scope;
    };
}
/**
 * An object that describes the user (person) who is interacting with Alexa.
 * @interface
 */
export interface Person {
    /**
     * 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.
     */
    'personId'?: 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.
     */
    'accessToken'?: string;
}
/**
 * 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.
 * @interface
 */
export declare 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;
/**
 * Request wrapper for all requests sent to your Skill.
 * @interface
 */
export interface RequestEnvelope {
    /**
     * The version specifier for the request.
     */
    'version': string;
    /**
     * The session object provides additional context associated with the request.
     */
    'session'?: Session;
    /**
     * 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.
     */
    'context': Context;
    /**
     * A request object that provides the details of the user’s request.
     */
    'request': Request;
}
/**
 *
 * @interface
 */
export interface Response {
    'outputSpeech'?: ui.OutputSpeech;
    'card'?: ui.Card;
    'reprompt'?: ui.Reprompt;
    'directives'?: Array<Directive>;
    /**
     * API response object containing API response value(s)
     */
    'apiResponse'?: any;
    'shouldEndSession'?: boolean;
    'canFulfillIntent'?: canfulfill.CanFulfillIntent;
    /**
     * Experiment trigger response from skill
     */
    'experimentation'?: interfaces.alexa.experimentation.ExperimentTriggerResponse;
}
/**
 *
 * @interface
 */
export interface ResponseEnvelope {
    'version': string;
    'sessionAttributes'?: {
        [key: string]: any;
    };
    'userAgent'?: string;
    'response': Response;
}
/**
 * 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
 * @interface
 */
export interface Scope {
    'status'?: PermissionStatus;
}
/**
 * Represents a single execution of the alexa service
 * @interface
 */
export interface Session {
    /**
     * A boolean value indicating whether this is a new session. Returns true for a new session or false for an existing session.
     */
    'new': boolean;
    /**
     * A string that represents a unique identifier per a user’s active session.
     */
    'sessionId': string;
    /**
     * An object that describes the user making the request.
     */
    'user': User;
    /**
     * 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.
     */
    'attributes'?: {
        [key: string]: any;
    };
    'application': Application;
}
/**
 * An error object providing more information about the error that occurred.
 * @interface
 */
export interface SessionEndedError {
    /**
     * A string indicating the type of error that occurred.
     */
    'type': SessionEndedErrorType;
    /**
     * A string providing more information about the error.
     */
    'message': string;
}
/**
 * A string indicating the type of error that occurred.
 * @enum
 */
export declare type SessionEndedErrorType = 'INVALID_RESPONSE' | 'DEVICE_COMMUNICATION_ERROR' | 'INTERNAL_SERVICE_ERROR' | 'ENDPOINT_TIMEOUT';
/**
 * The reason why session ended when not initiated from the Skill itself.
 * @enum
 */
export declare type SessionEndedReason = 'USER_INITIATED' | 'ERROR' | 'EXCEEDED_MAX_REPROMPTS';
/**
 *
 * @interface
 */
export interface Slot {
    /**
     * A string that represents the name of the slot.
     */
    'name': 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.
     */
    'value'?: string;
    /**
     * Indication of whether an intent or slot has been explicitly confirmed or denied by the user, or neither.
     */
    'confirmationStatus': SlotConfirmationStatus;
    /**
     * 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.
     */
    'resolutions'?: slu.entityresolution.Resolutions;
    /**
     * Object representing the value of the slot.
     */
    'slotValue'?: SlotValue;
}
/**
 * An enumeration indicating whether the user has explicitly confirmed or denied the value of this slot.
 * @enum
 */
export declare type SlotConfirmationStatus = 'NONE' | 'DENIED' | 'CONFIRMED';
/**
 * Object representing the value captured in the slot.
 * @interface
 */
export declare type SlotValue = ListSlotValue | SimpleSlotValue;
/**
 * Status indicates a high level understanding of the result of an execution.
 * @interface
 */
export interface Status {
    /**
     * This is a code signifying the status of the execution initiated by the skill. Protocol adheres to HTTP status codes.
     */
    'code': string;
    /**
     * This is a message that goes along with response code that can provide more information about what occurred.
     */
    'message': string;
}
/**
 * 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.
 * @interface
 */
export interface SupportedInterfaces {
    'Alexa.Advertisement'?: interfaces.alexa.advertisement.AlexaAdvertisementInterface;
    'Alexa.Presentation.APL'?: interfaces.alexa.presentation.apl.AlexaPresentationAplInterface;
    'Alexa.Presentation.APLT'?: interfaces.alexa.presentation.aplt.AlexaPresentationApltInterface;
    'Alexa.Presentation.HTML'?: interfaces.alexa.presentation.html.AlexaPresentationHtmlInterface;
    'AppLink'?: interfaces.applink.AppLinkInterface;
    'AudioPlayer'?: interfaces.audioplayer.AudioPlayerInterface;
    'Display'?: interfaces.display.DisplayInterface;
    'VideoApp'?: interfaces.videoapp.VideoAppInterface;
    'Geolocation'?: interfaces.geolocation.GeolocationInterface;
    'Navigation'?: interfaces.navigation.NavigationInterface;
}
/**
 * This object encapsulates a specific functionality.
 * @interface
 */
export interface Task {
    /**
     * Represents the name of the task.
     */
    'name': string;
    /**
     * Represents the version of the task.
     */
    'version': string;
    /**
     * Represents the input to handle the task.
     */
    'input'?: any;
}
/**
 * An object that describes the Amazon account for which the skill is enabled.
 * @interface
 */
export interface User {
    /**
     * 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.
     */
    'userId': 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.
     */
    'accessToken'?: string;
    'permissions'?: Permissions;
}
export declare namespace authorization {
    /**
     * Authorization grant body.
     * @interface
     */
    interface AuthorizationGrantBody {
        'grant': authorization.Grant;
    }
}
export declare namespace authorization {
    /**
     * Information that identifies a user in Amazon Alexa systems.
     * @interface
     */
    interface Grant {
        /**
         * Type of the grant.
         */
        'type': authorization.GrantType;
        /**
         * The authorization code for the user.
         */
        'code': string;
    }
}
export declare namespace authorization {
    /**
     * One of the grant types supported.
     * @enum
     */
    type GrantType = 'OAuth2.AuthorizationCode';
}
export declare namespace canfulfill {
    /**
     * CanFulfillIntent represents the response to canFulfillIntentRequest includes the details about whether the skill can understand and fulfill the intent request with detected slots.
     * @interface
     */
    interface CanFulfillIntent {
        'canFulfill': canfulfill.CanFulfillIntentValues;
        /**
         * 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.
         */
        'slots'?: {
            [key: string]: canfulfill.CanFulfillSlot;
        };
    }
}
export declare namespace canfulfill {
    /**
     * 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.
     * @enum
     */
    type CanFulfillIntentValues = 'YES' | 'NO' | 'MAYBE';
}
export declare namespace canfulfill {
    /**
     * This represents skill's capability to understand and fulfill each detected slot.
     * @interface
     */
    interface CanFulfillSlot {
        'canUnderstand': canfulfill.CanUnderstandSlotValues;
        'canFulfill'?: canfulfill.CanFulfillSlotValues;
    }
}
export declare namespace canfulfill {
    /**
     * 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.
     * @enum
     */
    type CanFulfillSlotValues = 'YES' | 'NO';
}
export declare namespace canfulfill {
    /**
     * 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.
     * @enum
     */
    type CanUnderstandSlotValues = 'YES' | 'NO' | 'MAYBE';
}
export declare namespace dialog {
    /**
     * The delegation period.
     * @interface
     */
    interface DelegationPeriod {
        'until'?: dialog.DelegationPeriodUntil;
    }
}
export declare namespace dialog {
    /**
     * 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.
     * @enum
     */
    type DelegationPeriodUntil = 'EXPLICIT_RETURN' | 'NEXT_TURN';
}
export declare namespace dialog {
    /**
     * Structured input data to send to a dialog manager. Currently, this is an Alexa Conversations input instance.
     * @interface
     */
    interface Input {
        /**
         * The Alexa Conversations input name as dictated in the Conversations model.
         */
        'name': string;
        /**
         * A map of input slots by slot name.
         */
        'slots'?: {
            [key: string]: Slot;
        };
    }
}
export declare namespace dialog {
    /**
     * The updated request to delegate. Null will delegate the current request.
     * @interface
     */
    type UpdatedRequest = dialog.UpdatedInputRequest | dialog.UpdatedIntentRequest;
}
export declare namespace dynamicEndpoints {
    /**
     * Base response type.
     * @interface
     */
    type BaseResponse = dynamicEndpoints.FailureResponse | dynamicEndpoints.SuccessResponse;
}
export declare namespace dynamicEndpoints {
    /**
     * Request from a Dynamic endpoint connection.
     * @interface
     */
    interface Request {
        /**
         * The version of the request message schema used.
         */
        'version': string;
        /**
         * Denotes type of request.
         */
        'type': string;
        /**
         * The requestId for the dynamic endpoint request.
         */
        'requestId': string;
        /**
         * The request payload.
         */
        'requestPayload': string;
    }
}
export declare namespace er.dynamic {
    /**
     * Represents an entity that the skill wants to store. An entity has an optional Id and the value and the synonyms for the entity
     * @interface
     */
    interface Entity {
        /**
         * An unique id associated with the entity
         */
        'id'?: string;
        'name': er.dynamic.EntityValueAndSynonyms;
    }
}
export declare namespace er.dynamic {
    /**
     * Represents an array of entities of a particular type.
     * @interface
     */
    interface EntityListItem {
        /**
         * The entity type. Must match the slot type as defined in the interaction model.
         */
        'name': string;
        /**
         * A list of dynamic entities which are of the same type
         */
        'values': Array<er.dynamic.Entity>;
    }
}
export declare namespace er.dynamic {
    /**
     * A container object with value and synomyms for the entity
     * @interface
     */
    interface EntityValueAndSynonyms {
        /**
         * The entity value
         */
        'value': string;
        /**
         * An array of synonyms for the entity
         */
        'synonyms'?: Array<string>;
    }
}
export declare namespace er.dynamic {
    /**
     * Replace the existing dynamic entities or clear them from the catalog
     * @enum
     */
    type UpdateBehavior = 'REPLACE' | 'CLEAR';
}
export declare namespace events.skillevents {
    /**
     *
     * @interface
     */
    interface AccountLinkedBody {
        'accessToken'?: string;
    }
}
export declare namespace events.skillevents {
    /**
     *
     * @interface
     */
    interface NotificationSubscriptionChangedBody {
        /**
         * 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.
         */
        'subscriptions'?: Array<events.skillevents.NotificationSubscriptionEvent>;
    }
}
export declare namespace events.skillevents {
    /**
     *
     * @interface
     */
    interface NotificationSubscriptionEvent {
        /**
         * The topicId will be one of the Topics specified in your Skill's manifest file.
         */
        'topicId'?: string;
    }
}
export declare namespace events.skillevents {
    /**
     *
     * @interface
     */
    interface Permission {
        /**
         * The value representing the permission scope.
         */
        'scope'?: string;
    }
}
export declare namespace events.skillevents {
    /**
     *
     * @interface
     */
    interface PermissionBody {
        /**
         * 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.
         */
        'acceptedPermissions'?: 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.
         */
        'acceptedPersonPermissions'?: Array<events.skillevents.Permission>;
    }
}
export declare namespace events.skillevents {
    /**
     *
     * @interface
     */
    interface ProactiveSubscriptionChangedBody {
        /**
         * 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.
         */
        'subscriptions'?: Array<events.skillevents.ProactiveSubscriptionEvent>;
    }
}
export declare namespace events.skillevents {
    /**
     *
     * @interface
     */
    interface ProactiveSubscriptionEvent {
        'eventName'?: string;
    }
}
export declare namespace interfaces.alexa.advertisement {
    /**
     * The interface provides skills with the ability to seamlessly integrate advertisements during their interactions with users.
     * @interface
     */
    interface AlexaAdvertisementInterface {
    }
}
export declare namespace interfaces.alexa.advertisement {
    /**
     * The object encapsulates information regarding the reasons why the ad is not being rendered.
     * @interface
     */
    interface Reason {
        /**
         * The enum represents various details explaining why the ad is not being rendered.
         */
        'type'?: interfaces.alexa.advertisement.ReasonCode;
        /**
         * The message provides an explanation of the specific details as to why the ad is not being rendered.
         */
        'message'?: string;
    }
}
export declare namespace interfaces.alexa.advertisement {
    /**
     * The enum represents various details explaining why the ad is not being rendered.
     * @enum
     */
    type ReasonCode = 'DEVICE_OCCUPIED' | 'UNSUPPORTED_DEVICE' | 'SKILL_DAILY_CAP_LIMIT_REACHED' | 'DOMAIN_DAILY_CAP_LIMIT_REACHED' | 'INTERNAL_SERVER_ERROR' | 'AD_NOT_AVAILABLE';
}
export declare namespace interfaces.alexa.comms.messagingcontroller {
    /**
     * 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.
     * @interface
     */
    interface StatusMap {
        /**
         * List of read messages
         */
        'read'?: Array<string>;
        /**
         * List of deleted messages
         */
        'deleted'?: Array<string>;
    }
}
export declare namespace interfaces.alexa.datastore {
    /**
     * DataStore error object payload.
     * @interface
     */
    type CommandsError = interfaces.alexa.datastore.DeviceUnavailableError | interfaces.alexa.datastore.DevicePermanantlyUnavailableError | interfaces.alexa.datastore.DataStoreInternalError | interfaces.alexa.datastore.StorageLimitExeceededError;
}
export declare namespace interfaces.alexa.datastore {
    /**
     * Content of a commands dispatch error.
     * @interface
     */
    interface DispatchErrorContent {
        /**
         * Identifier of the device where execution