components

type AudioInput struct {
	// Type of overlay (currently only supports 'audio').
	Type *AudioInputType `json:"type,omitempty"`
	// URL of the audio track to replace the existing audio in the video.
	SwapTrackURL *string `json:"swapTrackUrl,omitempty"`
	// List of additional audio tracks to overlay on the video.
	ImposeTracks []ImposeTrack `json:"imposeTracks,omitempty"`
}

type AudioInputType string

type BadRequestError struct {
	// Displays the error code indicating the type of the error.
	Code *float64 `json:"code,omitempty"`
	// A descriptive message providing more details for the error.
	Message *string `json:"message,omitempty"`
	// A detailed explanation of the possible causes for the error.
	//
	Description *string `json:"description,omitempty"`
}

type CreateLiveStreamRequest struct {
	// Displays the result of the playback settings.
	PlaybackSettings PlaybackSettings `json:"playbackSettings"`
	// Displays the result of the input Media settings.
	InputMediaSettings InputMediaSettings `json:"inputMediaSettings"`
}

type CreateLiveStreamRequestMaxResolution string

type CreateLiveStreamRequestMetadata struct {
}

type CreateMediaRequest struct {
	Inputs []Input `json:"inputs"`
	// You can search for videos with specific key-value pairs using metadata, when you tag a video in "key" : "value" pairs. Dynamic Metadata allows you to define a key that allows any value pair. You can have a maximum of 255 characters and up to 10 entries are allowed.
	//
	Metadata *CreateMediaRequestMetadata `json:"metadata,omitempty"`
	// Generates subtitle files for audio/video files.
	//
	Subtitle *Subtitle `json:"subtitle,omitempty"`
	// Determines whether access to the streamed content is kept private or available to all.
	//
	AccessPolicy CreateMediaRequestAccessPolicy `json:"accessPolicy"`
	// “capped_4k": Generates an mp4 video file up to 4k resolution "audioOnly": Generates an m4a audio file of the media file "audioOnly,capped_4k": Generates both video and audio media files for offline viewing
	//
	Mp4Support *CreateMediaRequestMp4Support `json:"mp4Support,omitempty"`
	// The sourceAccess parameter determines whether the original media file is accessible. Set to true to enable access or false to restrict it
	SourceAccess *bool `json:"sourceAccess,omitempty"`
	// normalize volume of the audio track. This is available for pre-recorded content only.
	//
	OptimizeAudio *bool `default:"false" json:"optimizeAudio"`
	// The maximum resolution tier determines the highest quality your media will be available in.
	//
	MaxResolution *CreateMediaRequestMaxResolution `default:"1080p" json:"maxResolution"`
	Summary       *Summary                         `json:"summary,omitempty"`
	// Enable or disable the chapters feature for the media. Set to `true` to enable chapters or `false` to disable.
	//
	Chapters *bool `json:"chapters,omitempty"`
	// Enable or disable named entity extraction. Set to `true` to enable or `false` to disable.
	//
	NamedEntities      *bool                                 `json:"namedEntities,omitempty"`
	Moderation         *Moderation                           `json:"moderation,omitempty"`
	AccessRestrictions *CreateMediaRequestAccessRestrictions `json:"accessRestrictions,omitempty"`
}

type CreateMediaRequestAccessPolicy string

type CreateMediaRequestAccessRestrictions struct {
	Domains    *CreateMediaRequestDomains    `json:"domains,omitempty"`
	UserAgents *CreateMediaRequestUserAgents `json:"userAgents,omitempty"`
}

type CreateMediaRequestDomains struct {
	// Specifies the default access policy for domains.
	// If set to `allow`, all domains are allowed access unless otherwise specified in the `deny` lists.
	// If set to `deny`, all domains are denied access unless otherwise specified in the `allow` lists.
	//
	DefaultPolicy *CreateMediaRequestDomainsDefaultPolicy `json:"defaultPolicy,omitempty"`
	// A list of domain names or patterns that are explicitly allowed access.
	// This list is only effective when the `defaultPolicy` is set to `deny`.
	//
	Allow []string `json:"allow,omitempty"`
	// A list of domain names or patterns that are explicitly denied access.
	// This list is only effective when the `defaultPolicy` is set to `allow`.
	//
	Deny []string `json:"deny,omitempty"`
}

type CreateMediaRequestDomainsDefaultPolicy string

type CreateMediaRequestLanguageCode string

type CreateMediaRequestMaxResolution string

type CreateMediaRequestMetadata struct {
}

type CreateMediaRequestMp4Support string

type CreateMediaRequestType string

type CreateMediaRequestUserAgents struct {
	// Specifies the default access policy for user agents (browsers, bots, etc.).
	// If set to `allow`, all user agents are allowed access unless otherwise specified in the `deny` lists.
	// If set to `deny`, all user agents are denied access unless otherwise specified in the `allow` lists.
	//
	DefaultPolicy *CreateMediaRequestUserAgentsDefaultPolicy `json:"defaultPolicy,omitempty"`
	// A list of user agents (identified by string names or patterns) that are explicitly allowed access.
	// This list is only effective when the `defaultPolicy` is set to `deny`.
	//
	Allow []string `json:"allow,omitempty"`
	// A list of user agents (identified by string names or patterns) that are explicitly denied access.
	// This list is only effective when the `defaultPolicy` is set to `allow`.
	//
	Deny []string `json:"deny,omitempty"`
}

type CreateMediaRequestUserAgentsDefaultPolicy string

type CreateMediaResponse struct {
	// The Media is assigned a universal unique identifier, which can contain a maximum of 255 characters.
	ID *string `json:"id,omitempty"`
	// FastPix allows for a free trial. Create as many media files as you like during the trial period. Remember, each clip can only be 10 seconds long and will be deleted after 24 hours. Also, all trial content will have the FastPix logo watermark.
	//
	Trial *bool `default:"true" json:"trial"`
	// Determines the media's status, which can be one of the possible values.
	Status *string `json:"status,omitempty"`
	// Time the media was created, defined as a localDateTime (UTC Time).
	CreatedAt *time.Time `json:"createdAt,omitempty"`
	// Time the media was updated, defined as a localDateTime (UTC Time).
	UpdatedAt *time.Time `json:"updatedAt,omitempty"`
	// A collection of Playback ID objects utilized for crafting HLS playback URLs.
	PlaybackIds []PlaybackID `json:"playbackIds,omitempty"`
	// You can search for videos with specific key value pairs using metadata, when you tag a video in "key" : "value" pairs. Dynamic Metadata allows you to define a key that allows any value pair. You can have maximum of 255 characters and upto 10 entries are allowed.
	Metadata *CreateMediaResponseMetadata `json:"metadata,omitempty"`
	// The maximum resolution tier determines the highest quality your media will be available in.
	MaxResolution *CreateMediaResponseMaxResolution `default:"1080p" json:"maxResolution"`
}

type CreateMediaResponseMaxResolution string

type CreateMediaResponseMetadata struct {
}

type DirectUpload struct {
	// When creating the upload, FastPix assigns a universally unique identifier with a maximum length of 255 characters.
	ID *string `json:"id,omitempty"`
	// When creating the media, FastPix assigns a universally unique identifier with a maximum length of 255 characters.
	MediaID *string `json:"mediaId,omitempty"`
	// Determines the media's status, which can be one of the possible values.
	Status *string `json:"status,omitempty"`
	// The url hosts the media file for FastPix, which needs to be download to use further.  It supports formats like MP3, MP4, MOV, MKV, or TS, and includes text tracks for subtitles/CC (SRT file/VTT file). While FastPix can handle various audio and video formats and codecs, using standard inputs can help with optimal processing speed.
	URL *string `json:"url,omitempty"`
	// The duration set for the validity of the upload URL. If the upload isn't completed within this timeframe, it's marked as timed out.
	//
	Timeout *float64 `default:"14400" json:"timeout"`
	// Upload media directly from a device using the url name or enter '*' to allow all.
	CorsOrigin        *string               `json:"corsOrigin,omitempty"`
	PushMediaSettings *DirectUploadResponse `json:"pushMediaSettings,omitempty"`
}

type DirectUploadResponse struct {
	PlaybackIds []PlaybackID `json:"playbackIds,omitempty"`
	// You can search for videos with specific key value pairs using metadata, when you tag a video in "key" : "value" pairs. Dynamic Metadata allows you to define a key that allows any value pair. You can have maximum of 255 characters and upto 10 entries are allowed.
	Metadata *DirectUploadResponseMetadata `json:"metadata,omitempty"`
}

type DirectUploadResponseMetadata struct {
}

type Field struct {
	// Displays the specific field associated with the error.
	Field *string `json:"field,omitempty"`
	// A descriptive message providing more details for the error
	Message *string `json:"message,omitempty"`
}

type ForbiddenError struct {
	// Displays the error code indicating the type of the error.
	Code *int64 `json:"code,omitempty"`
	// A descriptive message providing more details for the error.
	Message *string `json:"message,omitempty"`
	// A detailed explanation of the possible causes for the error.
	//
	Description *string `json:"description,omitempty"`
}

type GetCreateLiveStreamResponseDTO struct {
	// Upon creating a new live stream, FastPix assigns a unique identifier to the stream.
	StreamID *string `json:"streamId,omitempty"`
	// A unique stream key is generated for streaming, allowing the user to start streaming on any third-party platform using this key.
	StreamKey *string `json:"streamKey,omitempty"`
	// A secret used for securing the SRT stream. This ensures that only authorized users can access the stream.
	SrtSecret *string `json:"srtSecret,omitempty"`
	// FastPix allows for a to trial the live stream for free. The duration of trial streams is five minutes. After five minutes of activity, the trial stream is turned off, and the recorded asset is removed after a day.
	Trial *bool `json:"trial,omitempty"`
	// The current live stream status can be one of four values:Idle, Preparing, Active or Disabled.The Idle status signifies that there isn't a broadcast in progress.The preparing status indicates that the stream is getting prepared. while, the Active status indicates that a broadcast is currently in progress. The Disabled status means that no more RTMP streams can be published.
	Status *string `json:"status,omitempty"`
	// Max resolution can be used to control the maximum resolution your media is encoded, stored, and streamed at.
	MaxResolution *string `json:"maxResolution,omitempty"`
	// The maximum duration in seconds that a live stream can have before it ends the stream.
	MaxDuration *int64 `json:"maxDuration,omitempty"`
	// It is the moment when the stream was created Time the media was generated, defined as a localDateTime (UTC Time).
	CreatedAt *time.Time `json:"createdAt,omitempty"`
	// In case the software streaming the live, get disrupted for any reason and get disconnect from FastPix, the reconnect window specifies the waiting time span of FastPix will wait before ending the stream. Before starting the stream, you can set the reconnect window time set which is up to 1800 seconds.
	ReconnectWindow *int64 `default:"60" json:"reconnectWindow"`
	// When set to true, the livestream will be recorded and stored for later viewing purposes. If set to false, the livestream will not be recorded.
	EnableRecording *bool `json:"enableRecording,omitempty"`
	// Determines whether the recorded stream should be publicly accessible or private in Live to VOD (Video on Demand).
	MediaPolicy *string `json:"mediaPolicy,omitempty"`
	// You can search for videos with specific key value pairs using metadata, when you tag a video in "key":"value"s pairs. Dynamic Metadata allows you to define a key that allows any value pair. You can have maximum of 255 characters and upto 10 entries are allowed.
	Metadata *GetCreateLiveStreamResponseDTOMetadata `json:"metadata,omitempty"`
	// A collection of Playback ID objects utilized for crafting HLS playback urls.
	PlaybackID []PlaybackIds `json:"playbackId,omitempty"`
	// This object contains the livestream playback response details for SRT Protocol.
	SrtPlaybackResponse *GetCreateLiveStreamResponseDTOSrtPlaybackResponse `json:"srtPlaybackResponse,omitempty"`
}

type GetCreateLiveStreamResponseDTOMetadata struct {
}

type GetCreateLiveStreamResponseDTOSrtPlaybackResponse struct {
	// A unique identifier for the SRT playback stream. This ID is used to distinguish between different playback streams.
	SrtPlaybackStreamID *string `json:"srtPlaybackStreamId,omitempty"`
	// A playback secret used for securing the SRT playback stream. This ensures that only authorized users can access the playback.
	SrtPlaybackSecret *string `json:"srtPlaybackSecret,omitempty"`
}

type GetStreamsResponse struct {
	// It demonstrates whether the request is successful or not.
	Success *bool `json:"success,omitempty"`
	// Displays the result of the request.
	Data []GetCreateLiveStreamResponseDTO `json:"data,omitempty"`
	// Pagination organizes content into pages for better readability and navigation.
	Pagination *Pagination `json:"pagination,omitempty"`
}

type HTTPMetadata struct {
	// Raw HTTP response; suitable for custom response parsing
	Response *http.Response `json:"-"`
	// Raw HTTP request; suitable for debugging
	Request *http.Request `json:"-"`
}

type ImposeTrack struct {
	// URL of the audio track to impose on the video.
	URL *string `json:"url,omitempty"`
	// Start time (in seconds) of the imposed audio in the video.
	StartTime *int64 `json:"startTime,omitempty"`
	// End time (in seconds) of the imposed audio in the video.
	EndTime *int64 `json:"endTime,omitempty"`
	// Level of fade-in effect (in seconds) at the start of the imposed audio.
	FadeInLevel *int64 `json:"fadeInLevel,omitempty"`
	// Level of fade-out effect (in seconds) at the end of the imposed audio.
	FadeOutLevel *int64 `json:"fadeOutLevel,omitempty"`
}

type Input struct {
	VideoInput     *VideoInput     `queryParam:"inline"`
	WatermarkInput *WatermarkInput `queryParam:"inline"`
	AudioInput     *AudioInput     `queryParam:"inline"`
	SubtitleInput  *SubtitleInput  `queryParam:"inline"`

	Type InputType
}

type InputMediaSettings struct {
	// Max resolution can be used to control the maximum resolution your media is encoded, stored, and streamed at.
	MaxResolution *CreateLiveStreamRequestMaxResolution `default:"1080p" json:"maxResolution"`
	// In case the software streaming the live, get disrupted for any reason and get disconnect from FastPix, the reconnect window specifies the waiting time span of FastPix will wait before ending the stream. Before starting the stream, you can set the reconnect window time set which is up to 1800 seconds.
	ReconnectWindow *int64 `default:"60" json:"reconnectWindow"`
	// Determines whether the recorded stream should be publicly accessible or private in Live to VOD (Video on Demand).
	MediaPolicy *MediaPolicy `default:"public" json:"mediaPolicy"`
	// You can search for videos with specific key value pairs using metadata, when you tag a video in "key":"value"s pairs. Dynamic Metadata allows you to define a key that allows any value pair. You can have maximum of 255 characters and upto 10 entries are allowed.
	Metadata *CreateLiveStreamRequestMetadata `json:"metadata,omitempty"`
}

type InputType string

type InvalidPermissionError struct {
	// Displays the error code indicating the type of the error.
	Code *int64 `json:"code,omitempty"`
	// A descriptive message providing more details for the error.
	Message *string `json:"message,omitempty"`
	// A detailed explanation of the possible causes for the error.
	//
	Description *string `json:"description,omitempty"`
}

type LiveStreamDeleteResponse struct {
	// It demonstrates whether the request is successful or not.
	Success *bool `json:"success,omitempty"`
}

type LiveStreamResponseDTO struct {
	// It demonstrates whether the request is successful or not.
	Success *bool `json:"success,omitempty"`
	// Displays the result of the request.
	Data *GetCreateLiveStreamResponseDTO `json:"data,omitempty"`
}

type LivestreamgetResponse struct {
	// It demonstrates whether the request is successful or not.
	Success *bool `json:"success,omitempty"`
	// Displays the result of the request.
	Data *GetCreateLiveStreamResponseDTO `json:"data,omitempty"`
}

type Media struct {
	// A video thumbnail is a still image that acts as the preview image for your video.
	Thumbnail *string `json:"thumbnail,omitempty"`
	// When creating the media, FastPix assigns a universally unique identifier with a maximum length of 255 characters.
	ID *string `json:"id,omitempty"`
	// A unique identifier is generated by FastPix for the workspace.
	WorkspaceID *string `json:"workspaceId,omitempty"`
	// You can search for videos with specific key value pairs using metadata, when you tag a video in "key" : "value" pairs. Dynamic Metadata allows you to define a key that allows any value pair. You can have maximum of 255 characters and upto 10 entries are allowed.
	Metadata *MediaMetadata `json:"metadata,omitempty"`
	// The maximum resolution specified by the user for the media.
	MaxResolution *MediaMaxResolution `default:"1080p" json:"maxResolution"`
	// The actual resolution of the uploaded media. This represents the native quality of the source media.
	SourceResolution *SourceResolution `default:"1080p" json:"sourceResolution"`
	// Determines the media's status, which can be one of the possible values.
	Status *string `json:"status,omitempty"`
	// Determines the type of MP4 support for the media.   - **none**: Disables MP4 support.   - **capped_4k**: Enables MP4 downloads with resolutions up to 4K.   - **audioOnly**: Provides an MP4 stream containing only the audio.   - **audioOnly,capped_4k**: Enables both MP4 video downloads (up to 4K) and an audio-only stream.
	Mp4Support *MediaMp4Support `json:"mp4Support,omitempty"`
	// The sourceAccess parameter determines whether the original media file is accessible. Set to true to enable access or false to restrict it
	SourceAccess *bool `json:"sourceAccess,omitempty"`
	// A collection of Playback ID objects utilized for crafting HLS playback URLs.
	PlaybackIds []PlaybackID `json:"playbackIds,omitempty"`
	// A media consists of different media tracks, like video, audio, and subtitle, all combined.
	Tracks []Track `json:"tracks,omitempty"`
	// The time span of the media, measured in seconds with a maximum allowable duration of 12 hours per individual media.
	Duration *string `json:"duration,omitempty"`
	// Frame rate quantifies the speed at which frames are displayed per second. It represents the range of frames available for a specific track. If the frame rate of the input file is indeterminable, it will be indicated by a value of -1.
	FrameRate *string `json:"frameRate,omitempty"`
	// The aspect ratio of a video is a value that describes the relative shape of a video based on its width and height.
	AspectRatio *string `json:"aspectRatio,omitempty"`
	// Time the media was created, defined as a localDateTime (UTC Time).
	CreatedAt *time.Time `json:"createdAt,omitempty"`
	// Time the media was updated, defined as a localDateTime (UTC Time).
	UpdatedAt *time.Time `json:"updatedAt,omitempty"`
}

type MediaMaxResolution string

type MediaMetadata struct {
}

type MediaMp4Support string

type MediaNotFoundError struct {
	// Displays the error code indicating the type of the error.
	Code *float64 `json:"code,omitempty"`
	// A descriptive message providing more details for the error.
	Message *string `json:"message,omitempty"`
	// A detailed explanation of the possible causes for the error.
	//
	Description *string `json:"description,omitempty"`
}

type MediaOrPlaybackNotFoundError struct {
	// Displays the error code indicating the type of the error.
	Code *float64 `json:"code,omitempty"`
	// A descriptive message providing more details for the error.
	Message *string `json:"message,omitempty"`
	// A detailed explanation of the possible causes for the error.
	//
	Description *string `json:"description,omitempty"`
}

type MediaPolicy string

type Moderation struct {
	// Defines the type of input. Possible values include video, audio, av.
	//
	Type CreateMediaRequestType `json:"type"`
}

type NotFoundErrorError struct {
	// Displays the error code indicating the type of the error.
	Code *float64 `json:"code,omitempty"`
	// A descriptive message providing more details for the error.
	Message *string `json:"message,omitempty"`
	// A detailed explanation of the possible causes for the error.
	//
	Description *string `json:"description,omitempty"`
}

type NotFoundErrorPlaybackIDError struct {
	// Displays the error code indicating the type of the error.
	Code *float64 `json:"code,omitempty"`
	// A descriptive message providing more details for the error.
	Message *string `json:"message,omitempty"`
	// A detailed explanation of the possible causes for the error.
	//
	Description *string `json:"description,omitempty"`
}

type NotFoundErrorSimulcastError struct {
	// Displays the error code indicating the type of the error.
	Code *float64 `json:"code,omitempty"`
	// A descriptive message providing more details for the error.
	Message *string `json:"message,omitempty"`
	// A detailed explanation of the possible causes for the error.
	//
	Description *string `json:"description,omitempty"`
}

type Pagination struct {
	// It gives the total number of media assets that are accessible overall.
	TotalRecords *int64 `json:"totalRecords,omitempty"`
	// Determines the current point for data retrieval within a paginated list.
	CurrentOffset *int64 `json:"currentOffset,omitempty"`
	// The offset count is expressed as total records by limit.
	OffsetCount *int64 `json:"offsetCount,omitempty"`
}

type PatchLiveStreamRequest struct {
	// You can search for videos with specific key value pairs using metadata, when you tag a video in "key":"value"s pairs. Dynamic Metadata allows you to define a key that allows any value pair. You can have maximum of 255 characters and upto 10 entries are allowed.
	Metadata *PatchLiveStreamRequestMetadata `json:"metadata,omitempty"`
	// In case the software streaming the live, get disrupted for any reason and get disconnect from FastPix, the reconnect window specifies the waiting time span of FastPix will wait before ending the stream. Before starting the stream, you can set the reconnect window time set which is up to 1800 seconds.
	ReconnectWindow *int64 `default:"60" json:"reconnectWindow"`
}

type PatchLiveStreamRequestMetadata struct {
}

type PatchResponseDTO struct {
	// It demonstrates whether the request is successful or not.
	Success *bool `json:"success,omitempty"`
	// Displays the result of the request.
	Data *PatchResponseData `json:"data,omitempty"`
}

type PatchResponseData struct {
	// Upon creating a new live stream, FastPix assigns a unique identifier to the stream.
	StreamID *string `json:"streamId,omitempty"`
	// A unique stream key is generated for streaming, allowing the user to start streaming on any third-party platform using this key.
	StreamKey *string `json:"streamKey,omitempty"`
	// A secret used for securing the SRT stream. This ensures that only authorized users can access the stream.
	SrtSecret *string `json:"srtSecret,omitempty"`
	// FastPix allows for a to trial the live stream for free. The duration of trial streams is five minutes. After five minutes of activity, the trial stream is turned off, and the recorded asset is removed after a day.
	Trial *bool `json:"trial,omitempty"`
	// The current live stream status can be one of four values:Idle, Preparing, Active or Disabled.The Idle status signifies that there isn't a broadcast in progress.The preparing status indicates that the stream is getting prepared. while, the Active status indicates that a broadcast is currently in progress. The Disabled status means that no more RTMP streams can be published.
	Status *string `json:"status,omitempty"`
	// Max resolution can be used to control the maximum resolution your media is encoded, stored, and streamed at.
	MaxResolution *string `json:"maxResolution,omitempty"`
	// The maximum duration in seconds that a live stream can have before it ends the stream.
	MaxDuration *int64 `json:"maxDuration,omitempty"`
	// It is the moment when the stream was created Time the media was generated, defined as a localDateTime (UTC Time).
	CreatedAt *time.Time `json:"createdAt,omitempty"`
	// In case the software streaming the live, get disrupted for any reason and get disconnect from FastPix, the reconnect window specifies the waiting time span of FastPix will wait before ending the stream. Before starting the stream, you can set the reconnect window time set which is up to 1800 seconds.
	ReconnectWindow *int64 `json:"reconnectWindow,omitempty"`
	// When set to true, the livestream will be recorded and stored for later viewing purposes. If set to false, the livestream will not be recorded.
	EnableRecording *bool `json:"enableRecording,omitempty"`
	// Determines whether the recorded stream should be publicly accessible or private in Live to VOD (Video on Demand).
	MediaPolicy *string `json:"mediaPolicy,omitempty"`
	// You can search for videos with specific key value pairs using metadata, when you tag a video in "key":"value"s pairs. Dynamic Metadata allows you to define a key that allows any value pair. You can have maximum of 255 characters and upto 10 entries are allowed.
	Metadata   *PatchResponseDataMetadata `json:"metadata,omitempty"`
	PlaybackID []PlaybackIds              `json:"playbackId,omitempty"`
	// This object contains the livestream playback response details for SRT Protocol.
	SrtPlaybackResponse *PatchResponseDataSrtPlaybackResponse `json:"srtPlaybackResponse,omitempty"`
}

type PatchResponseDataMetadata struct {
}

type PatchResponseDataSrtPlaybackResponse struct {
	// A unique identifier for the SRT playback stream. This ID is used to distinguish between different playback streams.
	SrtPlaybackStreamID *string `json:"srtPlaybackStreamId,omitempty"`
	// A playback secret used for securing the SRT playback stream. This ensures that only authorized users can access the playback.
	SrtPlaybackSecret *string `json:"srtPlaybackSecret,omitempty"`
}

type Placement struct {
	// Horizontal alignment of the watermark.
	XAlign *XAlign `json:"xAlign,omitempty"`
	// Horizontal margin from the edge of the video.
	XMargin *string `json:"xMargin,omitempty"`
	// Vertical alignment of the watermark.
	YAlign *YAlign `json:"yAlign,omitempty"`
	// Vertical margin from the edge of the video.
	YMargin *string `json:"yMargin,omitempty"`
}

type PlaybackID struct {
	// A unique identifier is generated by FastPix for the playbacks.
	ID *string `json:"id,omitempty"`
	// Determines if access to the streamed content is kept private or available to all.
	AccessPolicy *PlaybackIDAccessPolicy `json:"accessPolicy,omitempty"`
	// Controls access based on domains and user agents. Defines a default policy (either "allow" or "deny") and provides lists for explicitly allowed or denied domains and user agents.
	AccessRestrictions *PlaybackIDAccessRestrictions `json:"accessRestrictions,omitempty"`
}

type PlaybackIDAccessPolicy string

type PlaybackIDAccessRestrictions struct {
	// Restrictions based on the originating domain of a request (e.g., whether requests from certain websites should be allowed or blocked).
	Domains *PlaybackIDDomains `json:"domains,omitempty"`
	// Restrictions based on the user agent (which is typically a string sent by browsers or bots identifying themselves).
	UserAgents *PlaybackIDUserAgents `json:"userAgents,omitempty"`
}

type PlaybackIDDomains struct {
	// This sets the default behavior for domain access (either "allow" or "deny").
	DefaultPolicy *PlaybackIDDomainsDefaultPolicy `json:"defaultPolicy,omitempty"`
	// A list of domains that are explicitly allowed access.
	Allow []string `json:"allow,omitempty"`
	// A list of domains that are explicitly blocked from accessing the resource.
	Deny []string `json:"deny,omitempty"`
}

type PlaybackIDDomainsDefaultPolicy string

type PlaybackIDRequest struct {
	// Determines if access to the streamed content is kept private or available to all.
	AccessPolicy *PlaybackIDRequestAccessPolicy `default:"public" json:"accessPolicy"`
}

type PlaybackIDRequestAccessPolicy string

type PlaybackIDResponse struct {
	// It demonstrates whether the request is successful or not.
	Success *bool                   `json:"success,omitempty"`
	Data    *PlaybackIDResponseData `json:"data,omitempty"`
}

type PlaybackIDResponseData struct {
	// Unique identifier for the playbackId
	ID *string `json:"id,omitempty"`
	// Determines if access to the streamed content is kept private or available to all.
	AccessPolicy *string `json:"accessPolicy,omitempty"`
}

type PlaybackIDUserAgents struct {
	// This sets the default behavior for user agent access (either "allow" or "deny").
	DefaultPolicy *PlaybackIDUserAgentsDefaultPolicy `json:"defaultPolicy,omitempty"`
	// A list of specific user agents that are allowed to access the resource.
	Allow []string `json:"allow,omitempty"`
	// A list of specific user agents that are blocked.
	Deny []string `json:"deny,omitempty"`
}

type PlaybackIDUserAgentsDefaultPolicy string

type PlaybackIds struct {
	// Unique identifier for the playbackId
	ID *string `json:"id,omitempty"`
	// Determines if access to the streamed content is kept private or available to all.
	AccessPolicy *string `json:"accessPolicy,omitempty"`
}

type PlaybackSettings struct {
	// Determines if access to the streamed content is kept private or available to all.
	AccessPolicy *PlaybackSettingsAccessPolicy `default:"public" json:"accessPolicy"`
}

type PlaybackSettingsAccessPolicy string

type Security struct {
	Username *string `security:"scheme,type=http,subtype=basic,name=username,env=fastpixsdk_username"`
	Password *string `security:"scheme,type=http,subtype=basic,name=password,env=fastpixsdk_password"`
}

type Segment1 struct {
	// URL of the segment to be added.
	URL string `json:"url"`
	// The timestamp at which the segment should be inserted.
	InsertAt int64 `json:"insertAt"`
}

type Segment2 struct {
	// URL of the segment to be added.
	URL string `json:"url"`
	// Flag indicating the segment should be inserted at the end.
	InsertAtEnd bool `json:"insertAtEnd"`
}

type SegmentUnion struct {
	Segment1 *Segment1 `queryParam:"inline"`
	Segment2 *Segment2 `queryParam:"inline"`

	Type SegmentUnionType
}

type SegmentUnionType string

type SimulcastRequest struct {
	// The RTMP hostname, combined with the application name, is crucial for connecting to third-party live streaming services and transmitting the live stream.
	URL *string `json:"url,omitempty"`
	// A unique stream key is generated for streaming, allowing the user to start streaming on any third-party platform using this key.
	StreamKey *string `json:"streamKey,omitempty"`
}

type SimulcastResponse struct {
	// It demonstrates whether the request is successful or not.
	Success *bool `json:"success,omitempty"`
	// Displays the result of the request.
	Data *SimulcastResponseData `json:"data,omitempty"`
}

type SimulcastResponseData struct {
	// When you create the new simulcast, FastPix assign a universal unique identifier which can contain a maximum of 255 characters.
	SimulcastID *string `json:"simulcastId,omitempty"`
	// The RTMP hostname, combined with the application name, is crucial for connecting to third-party live streaming services and transmitting the live stream.
	URL *string `json:"url,omitempty"`
	// A unique stream key is generated for streaming, allowing the user to start streaming on any third-party platform using this key.
	StreamKey *string `json:"streamKey,omitempty"`
	// When the value is true, the simulcast will be enabled for the given stream
	IsEnabled *bool `json:"isEnabled,omitempty"`
	// Arbitrary user-supplied metadata that will be included in the simulcast details. Can be used to store your own ID for a video along with the simulcast. Max:255 characters, Upto 10 entries are allowed.
	Metadata *SimulcastResponseMetadata `json:"metadata,omitempty"`
}

type SimulcastResponseMetadata struct {
}

type SimulcastUnavailableError struct {
	// An error code indicating the type of the error.
	//
	Code *int64 `json:"code,omitempty"`
	// A descriptive message providing more details for the error
	//
	Message *string `json:"message,omitempty"`
	// A detailed explanation of the possible causes for the error.
	//
	Description *string `json:"description,omitempty"`
}

type SimulcastUpdateRequest struct {
	// When the value is set to false, the simulcast will be disabled for the given stream.
	IsEnabled *bool `json:"isEnabled,omitempty"`
	// Arbitrary user-supplied metadata that will be included in the simulcast details. Can be used to store your own ID for a video along with the simulcast. Max:255 characters, Upto 10 entries are allowed.
	Metadata *SimulcastUpdateRequestMetadata `json:"metadata,omitempty"`
}

type SimulcastUpdateRequestMetadata struct {
}

type SimulcastUpdateResponse struct {
	// It demonstrates whether the request is successful or not.
	Success *bool `json:"success,omitempty"`
	// Displays the result of the request.
	Data *SimulcastUpdateResponseData `json:"data,omitempty"`
}

type SimulcastUpdateResponseData struct {
	// When you create the new simulcast, FastPix assign a universal unique identifier which can contain a maximum of 255 characters.
	SimulcastID *string `json:"simulcastId,omitempty"`
	// The RTMP hostname, combined with the application name, is crucial for connecting to third-party live streaming services and transmitting the live stream.
	URL *string `json:"url,omitempty"`
	// A unique stream key is generated for streaming, allowing the user to start streaming on any third-party platform using this key.
	StreamKey *string `json:"streamKey,omitempty"`
	// When the value is set to false, the simulcast will be disabled for the given stream
	IsEnabled *bool `json:"isEnabled,omitempty"`
	// Arbitrary user-supplied metadata that will be included in the simulcast details. Can be used to store your own ID for a video along with the simulcast. Max:255 characters, Upto 10 entries are allowed.
	Metadata *SimulcastUpdateResponseMetadata `json:"metadata,omitempty"`
}

type SimulcastUpdateResponseMetadata struct {
}

type SimulcastdeleteResponse struct {
	// It demonstrates whether the request is successful or not.
	Success *bool `json:"success,omitempty"`
}

type SourceResolution string

type Subtitle struct {
	// Name of the language in which the subtitles will be generated.
	//
	LanguageName *string `json:"languageName,omitempty"`
	// You can search for videos with specific key-value pairs using metadata, when you tag a video in "key" : "value" pairs. Dynamic Metadata allows you to define a key that allows any value pair. You can have a maximum of 255 characters and up to 10 entries are allowed.
	//
	Metadata *SubtitleMetadata `json:"metadata,omitempty"`
	// Language codes are concise, standardized symbols that denote languages, utilizing either two or three characters for identification. The language code must be compliant with the BCP 47 standard to ensure compatibility. (for text only).
	//
	LanguageCode *CreateMediaRequestLanguageCode `json:"languageCode,omitempty"`
}

type SubtitleInput struct {
	// Defines the type of input.
	//
	Type string `json:"type"`
	// The direct URL of the subtitle file.
	URL string `json:"url"`
	// Name of the language in which the subtitles will be generated.
	LanguageName string `json:"languageName"`
	// The BCP 47 language code representing the language of the generated track.
	//
	LanguageCode SubtitleInputLanguageCode `json:"languageCode"`
}

type SubtitleInputLanguageCode string

type SubtitleMetadata struct {
}

type Summary struct {
	// Enable or disable the summary feature for the media. Set to true to enable summary or false to disable.
	//
	Generate bool `json:"generate"`
	// Specifies the desired word count for the generated summary.
	// - The value must be between **30** and **250** words.
	//
	SummaryLength *int64 `default:"100" json:"summaryLength"`
}

type Track struct {
	// FastPix generates a unique identifier for each track.
	ID *string `json:"id,omitempty"`
	// Defines the type of input. This option is mandatory.
	Type string `json:"type"`
	// Track width denotes the range of widths applicable to a specific track. Currently, this setting can be modified only for video tracks
	Width *float64 `json:"width,omitempty"`
	// Track height denotes the range of height applicable to a specific track. Currently, this setting can be modified only for video tracks.
	Height *float64 `json:"height,omitempty"`
	// Frame rate quantifies the speed at which frames are displayed per second. It represents the range of frames available for a specific track. If the frame rate of the input file is indeterminable, it will be indicated by a value of -1.
	FrameRate *string `json:"frameRate,omitempty"`
	// Indicates if the track contains closed captions.
	ClosedCaptions *bool `json:"closedCaptions,omitempty"`
}

type UnauthorizedError struct {
	// Displays the error code indicating the type of the error.
	Code *int64 `json:"code,omitempty"`
	// A descriptive message providing more details for the error.
	Message *string `json:"message,omitempty"`
	// A detailed explanation of the possible causes for the error.
	//
	Description *string `json:"description,omitempty"`
}

type ValidationErrorResponseError struct {
	// An error code indicating the type of the error.
	Code *int64 `json:"code,omitempty"`
	// A descriptive message providing more details for the error
	Message *string `json:"message,omitempty"`
	// It is an array of objects, where each object contains information about a specific field and a corresponding error message.
	Fields []Field `json:"fields,omitempty"`
}

type VideoInput struct {
	// Defines the type of input.
	//
	Type string `json:"type"`
	// The url hosts the media file for FastPix, which needs to be downloaded to use further. It supports formats like MP3, MP4, MOV, MKV, or TS, and includes text tracks for subtitles/CC (SRT file/VTT file). While FastPix can handle various audio and video formats and codecs, using standard inputs can help with optimal processing speed.
	//
	URL string `json:"url"`
	// Start time indicates where encoding should begin within the video file. For example, if you want to encode a segment from 3 minutes (180 seconds) to 6 minutes (360 seconds) in a 10-minute (600 seconds) video, the start time is 3 minutes (180 seconds). Note: Start time is always mentioned in seconds.
	//
	StartTime *float64 `json:"startTime,omitempty"`
	// End time indicates where encoding should end within the video file. For example, if you want to encode a segment from 3 minutes (180 seconds) to 6 minutes (360 seconds) in a 10-minute (600 seconds) video, the end time is 6 minutes (360 seconds). Note: End time is always mentioned in seconds.
	//
	EndTime *float64 `json:"endTime,omitempty"`
	// The url of the intro video which is to be added at the start of the video.
	//
	IntroURL *string `json:"introUrl,omitempty"`
	// The url of the outro video which is to be added at the end of the video.
	//
	OutroURL *string `json:"outroUrl,omitempty"`
	// The list of the startTime-endTime of the segments to be removed from the actual video.
	//
	ExpungeSegments []string `json:"expungeSegments,omitempty"`
	// A list of media segments to be added or processed. Each segment includes details such as the URL of the media file and instructions on where it should be inserted in the final media composition. A segment can either specify an exact timestamp  (`insertAt`) or indicate that it should be added at the end (`insertAtEnd`).
	Segments []SegmentUnion `json:"segments,omitempty"`
}

type WatermarkInput struct {
	// Type of overlay (currently only supports 'watermark').
	Type *WatermarkInputType `json:"type,omitempty"`
	// URL of the watermark image.
	URL       *string    `json:"url,omitempty"`
	Placement *Placement `json:"placement,omitempty"`
	// Width of the watermark in percentage or pixels.
	Width *string `json:"width,omitempty"`
	// Height of the watermark in percentage or pixels.
	Height *string `json:"height,omitempty"`
	// Opacity of the watermark in percentage.
	Opacity *string `json:"opacity,omitempty"`
}

type WatermarkInputType string

type XAlign string

type YAlign string