amsapi

type Art struct {
	Sources []ArtSource `json:"sources"`
}

type ArtSource struct {
	// The URL for the image of this size. URL must be HTTPS.
	Url string `json:"url"`
	// The size for the image. Alexa can use this optional field to help determine which size of ArtSource to use.
	//	"X_SMALL" (recommended for images approximately 48 x 48 pixels)
	//	"SMALL"   (recommended for 60 x 60 pixels)
	//	"MEDIUM"  (recommended for 110 x 110 pixels)
	//	"LARGE"   (recommended for 256 x 256 pixels)
	//	"X_LARGE" (recommended for 600 x 600 pixels)
	Size         string `json:"size,omitempty"`
	WidthPixels  int    `json:"widthPixels,omitempty"`
	HeightPixels int    `json:"heightPixels,omitempty"`
}

type Content struct {
	Id       string         `json:"id"`
	Actions  ContentActions `json:"actions"`
	Metadata MediaMetadata  `json:"metadata"`
}

type ContentActions struct {
	Playable  bool `json:"playable"`
	Browsable bool `json:"browsable"`
}

type EntityMetadata struct {
	Name MetadataNameProperty `json:"name"`
}

type Feedback struct {
	Type  string `json:"type"`
	Value string `json:"value"`
}

type Filter struct {
	ExplicitLanguageAllowed bool `json:"explicitLanguageAllowed"`
}

type GetNextItem struct {
	// Context information about the request.
	RequestContext *RequestContext `json:"requestContext"`
	// The currently playing item.
	CurrentItemReference *ItemReference `json:"currentItemReference"`
	// true if the user explicitly asked to skip to the next track (for music) or program (for podcasts),
	// false if the current track or program will soon end and the next item is needed.
	IsUserInitiated bool `json:"isUserInitiated,omitempty"`
}

type GetNextItemResponse struct {
	// A flag that indicates whether the currently playing item is the last item in the queue.
	// When this value is false, the item field must be present and contain a non-null value.
	// When this value is true, the item field must be absent or set to null.
	IsQueueFinished bool `json:"isQueueFinished"`
	// The requested item in the play queue.
	Item *Item `json:"item"`
}

type GetPlayableContent struct {
	RequestContext    RequestContext            `json:"requestContext"`
	Filters           Filter                    `json:"filters"`
	SelectionCriteria ResolvedSelectionCriteria `json:"selectionCriteria"`
}

type GetPlayableContentResponse struct {
	Content Content `json:"content"`
}

type GetPreviousItem struct {
	// Context information about the request.
	RequestContext *RequestContext `json:"requestContext"`
	// The currently playing item.
	CurrentItemReference *ItemReference `json:"currentItemReference"`
}

type GetPreviousItemResponse struct {
	// The previous item in the play queue.
	Item *Item `json:"item"`
}

type Initiate struct {
	RequestContext       RequestContext `json:"requestContext"`
	Filters              Filter         `json:"filters"`
	ContentId            string         `json:"contentId"`
	CurrentItemReference MediaReference `json:"currentItemReference"`
	PlaybackModes        PlaybackModes  `json:"playbackModes"`
}

type InitiateResponse struct {
	PlaybackMethod PlaybackMethod `json:"playbackMethod"`
}

type Item struct {
	// A identifier for the item that is opaque to Alexa.
	// Note that the item should be unique within the queue.
	Id string `json:"id"`
	// Describes which business rules Alexa should run when playing or displaying this item. See the PlaybackInfo object for details.
	PlaybackInfo PlaybackInfo `json:"playbackInfo"`

	// Metadata for the item.
	//
	// For playbackInfo types DEFAULT and SAMPLE, the value is an instance of MediaMetadata, where the metadata
	// type field can be TRACK (for music), STATION (for radio), or PROGRAM (for podcasts).
	// See the MediaMetadata object for details.
	//
	// For playbackInfo type AD, the value is an instance of AdMetadata. See the AdMetadata object for details.
	// (Note: Ads aren't supported for podcasts.)
	// TODO: support AdMetadata also with common interface or generics
	Metadata MediaMetadata `json:"metadata"`
	// Duration of the item in milliseconds. If the item is a live stream, do not return this field.
	DurationInMilliseconds int `json:"durationInMilliseconds,omitempty"`
	// List of ItemControl objects used by Alexa to determine which controls should be clickable in the Alexa app.
	Controls []ItemControl `json:"controls,omitempty"`
	// Object which contains rules for the item. See ItemRules for details.
	Rules ItemRules `json:"rules"`
	// Object that contains stream information for this item. See the Stream object for more information.
	Stream Stream `json:"stream"`

	Feedback *Feedback `json:"feedback,omitempty"`
}

type ItemControl struct {
	// The type of the control. This can be one of the following:
	//  ADJUST - for controls such as seeking
	//  COMMAND - for controls such as skipping
	Type ItemControlType `json:"type"`
	// The name of the control.
	//
	// For type ADJUST, the value for name can be one of the following:
	//  SEEK_POSITION - enables user to seek forward and back within a currently playing track
	//
	// For type COMMAND, the value for name can be one of the following:
	//  NEXT - for skipping to the next item
	//  PREVIOUS - for skipping to the previous item
	Name ItemControlName `json:"name"`
	// Informs Alexa whether the control is enabled.
	// For some control types, this determines whether the button for the control should be clickable:
	// set the value to true when the control should be clickable by the user in the Alexa app.
	Enabled bool `json:"enabled"`
}

type ItemControlName string

type ItemControlType string

type ItemReference struct {
	Id        string `json:"id"`
	QueueId   string `json:"queueId"`
	ContentId string `json:"contentId"`
}

type ItemRules struct {
	FeedbackEnabled bool `json:"feedbackEnabled"`
}

type JumpToItem struct {
	// Context information about the request.
	RequestContext *RequestContext `json:"requestContext"`
	// The currently playing item.
	CurrentItemReference *ItemReference `json:"currentItemReference"`
	// The identifier of the item to jump to.
	TargetItemId string `json:"targetItemId"`
}

type JumpToItemResponse struct {
	// The requested item in the play queue.
	Item *Item `json:"item"`
}

type Location struct {
	OriginatingLocale string `json:"originatingLocale,omitempty"`
	CountryCode       string `json:"countryCode,omitempty"`
}

type MediaMetadata struct {
	Type    types.EntityType `json:"type"`
	Name    MetadataName     `json:"name"`
	Art     Art              `json:"art"`
	Authors []EntityMetadata `json:"authors,omitempty"`
	Album   EntityMetadata   `json:"albums,omitempty"`
	Artists []EntityMetadata `json:"artists,omitempty"`
}

type MediaReference struct {
	Namespace string        `json:"namespace"`
	Name      string        `json:"name"`
	Value     ItemReference `json:"value"`
}

type MetadataName struct {
	Speech  SpeechInfo `json:"speech"`
	Display string     `json:"display"`
}

type MetadataNameProperty struct {
	Speech  SpeechInfo `json:"speech"`
	Display string     `json:"display"`
}

type PlaybackInfo struct {
	// The type of playback info. The field can have one of the following values:
	//
	//  DEFAULT - describes an item that is neither a sample nor an ad
	//  SAMPLE - describes an item whose stream is a shorter version of a full track
	//  AD - describes an item whose stream is an advertisement
	//  (Note: Ads aren't supported for podcasts.)
	Type PlaybackInfoType `json:"type"`
}

type PlaybackInfoType string

type PlaybackMethod struct {
	// The type of the playback method. The only allowed value is ALEXA_AUDIO_PLAYER_QUEUE.
	Type string `json:"type"`
	// The identifier for this play queue that is opaque to Alexa. If the skill wants to enforce concurrency limits,
	// then the queue ID should be unique for each user. Note that all Music Skill API requests after a queue is
	// created will report this queue ID back to the skill in all requests.
	Id string `json:"id"`
	// List of QueueControl objects used by Alexa to determine which controls should be clickable in the Alexa app.
	// Note that some queue-level controls might be overridden at the item-level.
	// See the QueueControl object for more information.
	Controls []QueueControl `json:"controls,omitempty"`
	// Identifies rules that apply to all audio items in the play queue.
	// Note that some queue-level rules may be overridden at the item-level.
	Rules QueueRules `json:"rules,omitempty"`
	// The first item from this queue that Alexa should play for the user.
	// See the Item object for more information.
	FirstItem Item `json:"firstItem"`
}

type PlaybackModes struct {
	Shuffle bool `json:"shuffle"`
	Loop    bool `json:"loop"`
}

type QueueControl struct {
	// The type of the control. This can be one of the following:
	//  ADJUST - for controls such as seeking
	//  COMMAND - for controls such as skipping
	//
	// QueueControl supports the following types in addition to the base types:
	//  TOGGLE - for controls such as shuffle
	Type string `json:"type"`
	// The name of the control.
	//
	// For type ADJUST, the value for name can be one of the following:
	//  SEEK_POSITION - enables user to seek forward and back within a currently playing track
	//
	// For type COMMAND, the value for name can be one of the following:
	//  NEXT - for skipping to the next item
	//  PREVIOUS - for skipping to the previous item
	//
	// For QueueControl type TOGGLE, the value can be one of the following:
	//  SHUFFLE - for toggling shuffle mode for the queue
	//  LOOP - for toggling loop mode for the queue
	//
	// Note the following controls are overridable at the item level:
	//  SEEK_POSITION, NEXT, PREVIOUS
	Name string `json:"name"`
	// Informs Alexa whether the control is enabled.
	//
	// For some control types, this determines whether the button for the control should be
	// clickable: set the value to true when the control should be clickable by the user in the Alexa app.
	Enabled bool `json:"enabled"`
	// Indicates that a control should render in a selected state.
	// For example, if a user has turned on loop mode in the provider's app, when the queue is cast to an Alexa device,
	// the loop control will have a selected value of true. Defaults to false.
	Selected bool `json:"selected,omitempty"`
}

type QueueFeedbackRule struct {
	// The type of feedback.
	//  The only supported value is PREFERENCE.
	Type string `json:"type"`
	// Whether feedback should be enabled.
	//
	// If false, Alexa will render error prompts (VUI) or show error messages (GUI) when the user tries to provide
	// feedback. Note that this flag can be overridden on an item-by-item basis.
	Enabled bool `json:"enabled"`
}

type QueueRules struct {
	Feedback QueueFeedbackRule `json:"feedback"`
}

type Request struct {
	Header       *header.Header   `json:"header"`
	Payload      *json.RawMessage `json:"payload,omitempty"`
	BoundPayload any              `json:"bound_payload,omitempty"`
}

type RequestContext struct {
	User     User     `json:"user"`
	Location Location `json:"location,omitempty"`
}

type ResolvedSelectionCriteria struct {
	Attributes []ResolvedSelectionCriteriaAttribute `json:"attributes"`
}

type ResolvedSelectionCriteriaAttribute struct {
	Type     types.EntityType `json:"type"`
	EntityId string           `json:"entityId,omitempty"`
	Value    string           `json:"value,omitempty"`
}

type Response struct {
	Header  *header.Header `json:"header"`
	Payload any            `json:"payload"`
}

type SpeechInfo struct {
	Type SpeechInfoType `json:"type"`
	Text string         `json:"text"`
}

type SpeechInfoType string

type Stream struct {
	// A unique opaque (to Alexa) identifier for the stream.
	//
	// Note that the same stream (with the same identifier) can be re-used across User and Queue instances.
	Id string `json:"id"`
	// URI of the stream (file or audio-chunk playlist).
	//
	// This URI is sent to the Alexa device media player to play the content.
	//
	// URIs must be HTTPS.
	Uri string `json:"uri"`
	// Offset, in milliseconds, at which to start playback of the stream.
	//
	// Defaults to 0.
	OffsetInMilliseconds int `json:"offsetInMilliseconds,omitempty"`
	// Offset, in milliseconds, at which to stop playback.
	//
	// If endOffsetInMilliseconds is greater than the actual track length, it's ignored, and the
	// stream plays to the end. Must be greater than or equal to offsetInMilliseconds.
	//
	// If endOffsetInMilliseconds is less than offsetInMilliseconds, a validation exception is raised.
	EndOffsetInMilliseconds int `json:"endOffsetInMilliseconds,omitempty"`
	// https://en.wikipedia.org/wiki/ISO_8601 representation of when the stream URI expires.
	//
	// Use the ISO 8601 extended format with UTC offset, for example 2019-01-29TT07:00:00.000Z.
	ValidUntil time.Time `json:"validUntil,omitempty"`
}

type User struct {
	Id          string `json:"id"`
	AccessToken string `json:"accessToken,omitempty"`
}