type AccessDeniedException struct {
	Message *string

	Logref *string
	Code   *string
}

type AgeRange struct {

	// The highest estimated age.
	High *int32

	// The lowest estimated age.
	Low *int32
}

type Asset struct {

	// The S3 bucket that contains the Ground Truth manifest file.
	GroundTruthManifest *GroundTruthManifest
}

type Attribute string

const (
	AttributeDefault Attribute = "DEFAULT"
	AttributeAll     Attribute = "ALL"
)

type AudioMetadata struct {

	// The number of audio channels in the segement.
	NumberOfChannels *int64

	// The duration of the audio stream in milliseconds.
	DurationMillis *int64

	// The audio codec used to encode or decode the audio stream.
	Codec *string

	// The sample rate for the audio stream.
	SampleRate *int64
}

type Beard struct {

	// Boolean value that indicates whether the face has beard or not.
	Value *bool

	// Level of confidence in the determination.
	Confidence *float32
}

type BoundingBox struct {

	// Width of the bounding box as a ratio of the overall image width.
	Width *float32

	// Height of the bounding box as a ratio of the overall image height.
	Height *float32

	// Left coordinate of the bounding box as a ratio of overall image width.
	Left *float32

	// Top coordinate of the bounding box as a ratio of overall image height.
	Top *float32
}

type Celebrity struct {

	// A unique identifier for the celebrity.
	Id *string

	// The confidence, in percentage, that Amazon Rekognition has that the recognized
	// face is the celebrity.
	MatchConfidence *float32

	// The name of the celebrity.
	Name *string

	// An array of URLs pointing to additional information about the celebrity. If
	// there is no additional information about the celebrity, this list is empty.
	Urls []*string

	// Provides information about the celebrity's face, such as its location on the
	// image.
	Face *ComparedFace
}

type CelebrityDetail struct {

	// Bounding box around the body of a celebrity.
	BoundingBox *BoundingBox

	// The name of the celebrity.
	Name *string

	// The confidence, in percentage, that Amazon Rekognition has that the recognized
	// face is the celebrity.
	Confidence *float32

	// An array of URLs pointing to additional celebrity information.
	Urls []*string

	// Face details for the recognized celebrity.
	Face *FaceDetail

	// The unique identifier for the celebrity.
	Id *string
}

type CelebrityRecognition struct {

	// The time, in milliseconds from the start of the video, that the celebrity was
	// recognized.
	Timestamp *int64

	// Information about a recognized celebrity.
	Celebrity *CelebrityDetail
}

type CelebrityRecognitionSortBy string

const (
	CelebrityRecognitionSortById        CelebrityRecognitionSortBy = "ID"
	CelebrityRecognitionSortByTimestamp CelebrityRecognitionSortBy = "TIMESTAMP"
)

type CompareFacesMatch struct {

	// Level of confidence that the faces match.
	Similarity *float32

	// Provides face metadata (bounding box and confidence that the bounding box
	// actually contains a face).
	Face *ComparedFace
}

type ComparedFace struct {

	// An array of facial landmarks.
	Landmarks []*Landmark

	// Bounding box of the face.
	BoundingBox *BoundingBox

	// Identifies face image brightness and sharpness.
	Quality *ImageQuality

	// Level of confidence that what the bounding box contains is a face.
	Confidence *float32

	// Indicates the pose of the face as determined by its pitch, roll, and yaw.
	Pose *Pose
}

type ComparedSourceImageFace struct {

	// Confidence level that the selected bounding box contains a face.
	Confidence *float32

	// Bounding box of the face.
	BoundingBox *BoundingBox
}

type ContentClassifier string

const (
	ContentClassifierFree_of_personally_identifiable_information ContentClassifier = "FreeOfPersonallyIdentifiableInformation"
	ContentClassifierFree_of_adult_content                       ContentClassifier = "FreeOfAdultContent"
)

type ContentModerationDetection struct {

	// The unsafe content label detected by in the stored video.
	ModerationLabel *ModerationLabel

	// Time, in milliseconds from the beginning of the video, that the unsafe content
	// label was detected.
	Timestamp *int64
}

type ContentModerationSortBy string

const (
	ContentModerationSortByName      ContentModerationSortBy = "NAME"
	ContentModerationSortByTimestamp ContentModerationSortBy = "TIMESTAMP"
)

type CustomLabel struct {

	// The name of the custom label.
	Name *string

	// The location of the detected object on the image that corresponds to the custom
	// label. Includes an axis aligned coarse bounding box surrounding the object and a
	// finer grain polygon for more accurate spatial information.
	Geometry *Geometry

	// The confidence that the model has in the detection of the custom label. The
	// range is 0-100. A higher value indicates a higher confidence.
	Confidence *float32
}

type DetectTextFilters struct {

	// A set of parameters that allow you to filter out certain results from your
	// returned results.
	WordFilter *DetectionFilter

	// A Filter focusing on a certain area of the image. Uses a BoundingBox object to
	// set the region of the image.
	RegionsOfInterest []*RegionOfInterest
}

type DetectionFilter struct {

	// Sets the minimum height of the word bounding box. Words with bounding box
	// heights lesser than this value will be excluded from the result. Value is
	// relative to the video frame height.
	MinBoundingBoxHeight *float32

	// Sets the minimum width of the word bounding box. Words with bounding boxes
	// widths lesser than this value will be excluded from the result. Value is
	// relative to the video frame width.
	MinBoundingBoxWidth *float32

	// Sets confidence of word detection. Words with detection confidence below this
	// will be excluded from the result. Values should be between 0.5 and 1 as Text in
	// Video will not return any result below 0.5.
	MinConfidence *float32
}

type Emotion struct {

	// Type of emotion detected.
	Type EmotionName

	// Level of confidence in the determination.
	Confidence *float32
}

type EmotionName string

const (
	EmotionNameHappy     EmotionName = "HAPPY"
	EmotionNameSad       EmotionName = "SAD"
	EmotionNameAngry     EmotionName = "ANGRY"
	EmotionNameConfused  EmotionName = "CONFUSED"
	EmotionNameDisgusted EmotionName = "DISGUSTED"
	EmotionNameSurprised EmotionName = "SURPRISED"
	EmotionNameCalm      EmotionName = "CALM"
	EmotionNameUnknown   EmotionName = "UNKNOWN"
	EmotionNameFear      EmotionName = "FEAR"
)

type EvaluationResult struct {

	// The F1 score for the evaluation of all labels. The F1 score metric evaluates the
	// overall precision and recall performance of the model as a single value. A
	// higher value indicates better precision and recall performance. A lower score
	// indicates that precision, recall, or both are performing poorly.
	F1Score *float32

	// The S3 bucket that contains the training summary.
	Summary *Summary
}

type EyeOpen struct {

	// Level of confidence in the determination.
	Confidence *float32

	// Boolean value that indicates whether the eyes on the face are open.
	Value *bool
}

type Eyeglasses struct {

	// Level of confidence in the determination.
	Confidence *float32

	// Boolean value that indicates whether the face is wearing eye glasses or not.
	Value *bool
}

type Face struct {

	// Unique identifier that Amazon Rekognition assigns to the face.
	FaceId *string

	// Confidence level that the bounding box contains a face (and not a different
	// object such as a tree).
	Confidence *float32

	// Unique identifier that Amazon Rekognition assigns to the input image.
	ImageId *string

	// Bounding box of the face.
	BoundingBox *BoundingBox

	// Identifier that you assign to all the faces in the input image.
	ExternalImageId *string
}

type FaceAttributes string

const (
	FaceAttributesDefault FaceAttributes = "DEFAULT"
	FaceAttributesAll     FaceAttributes = "ALL"
)

type FaceDetail struct {

	// Indicates whether or not the mouth on the face is open, and the confidence level
	// in the determination.
	MouthOpen *MouthOpen

	// Indicates whether or not the face is wearing sunglasses, and the confidence
	// level in the determination.
	Sunglasses *Sunglasses

	// Indicates whether or not the eyes on the face are open, and the confidence level
	// in the determination.
	EyesOpen *EyeOpen

	// The predicted gender of a detected face.
	Gender *Gender

	// Indicates whether or not the face has a mustache, and the confidence level in
	// the determination.
	Mustache *Mustache

	// Identifies image brightness and sharpness. Default attribute.
	Quality *ImageQuality

	// Indicates whether or not the face is wearing eye glasses, and the confidence
	// level in the determination.
	Eyeglasses *Eyeglasses

	// Confidence level that the bounding box contains a face (and not a different
	// object such as a tree). Default attribute.
	Confidence *float32

	// Indicates whether or not the face is smiling, and the confidence level in the
	// determination.
	Smile *Smile

	// Indicates whether or not the face has a beard, and the confidence level in the
	// determination.
	Beard *Beard

	// The emotions that appear to be expressed on the face, and the confidence level
	// in the determination. The API is only making a determination of the physical
	// appearance of a person's face. It is not a determination of the person’s
	// internal emotional state and should not be used in such a way. For example, a
	// person pretending to have a sad face might not be sad emotionally.
	Emotions []*Emotion

	// Bounding box of the face. Default attribute.
	BoundingBox *BoundingBox

	// Indicates the location of landmarks on the face. Default attribute.
	Landmarks []*Landmark

	// The estimated age range, in years, for the face. Low represents the lowest
	// estimated age and High represents the highest estimated age.
	AgeRange *AgeRange

	// Indicates the pose of the face as determined by its pitch, roll, and yaw.
	// Default attribute.
	Pose *Pose
}

type FaceDetection struct {

	// Time, in milliseconds from the start of the video, that the face was detected.
	Timestamp *int64

	// The face properties for the detected face.
	Face *FaceDetail
}

type FaceMatch struct {

	// Confidence in the match of this face with the input face.
	Similarity *float32

	// Describes the face properties such as the bounding box, face ID, image ID of the
	// source image, and external image ID that you assigned.
	Face *Face
}

type FaceRecord struct {

	// Describes the face properties such as the bounding box, face ID, image ID of the
	// input image, and external image ID that you assigned.
	Face *Face

	// Structure containing attributes of the face that the algorithm detected.
	FaceDetail *FaceDetail
}

type FaceSearchSettings struct {

	// The ID of a collection that contains faces that you want to search for.
	CollectionId *string

	// Minimum face match confidence score that must be met to return a result for a
	// recognized face. Default is 80. 0 is the lowest confidence. 100 is the highest
	// confidence.
	FaceMatchThreshold *float32
}

type FaceSearchSortBy string

const (
	FaceSearchSortByIndex     FaceSearchSortBy = "INDEX"
	FaceSearchSortByTimestamp FaceSearchSortBy = "TIMESTAMP"
)

type Gender struct {

	// Level of confidence in the prediction.
	Confidence *float32

	// The predicted gender of the face.
	Value GenderType
}

type GenderType string

const (
	GenderTypeMale   GenderType = "Male"
	GenderTypeFemale GenderType = "Female"
)

type Geometry struct {

	// Within the bounding box, a fine-grained polygon around the detected item.
	Polygon []*Point

	// An axis-aligned coarse representation of the detected item's location on the
	// image.
	BoundingBox *BoundingBox
}

type GroundTruthManifest struct {

	// Provides the S3 bucket name and object name. The region for the S3 bucket
	// containing the S3 object must match the region you use for Amazon Rekognition
	// operations.  <p>For Amazon Rekognition to process an S3 object, the user must
	// have permission to access the S3 object. For more information, see
	// Resource-Based Policies in the Amazon Rekognition Developer Guide. </p>
	S3Object *S3Object
}

type HumanLoopActivationOutput struct {

	// Shows the result of condition evaluations, including those conditions which
	// activated a human review.
	// This value conforms to the media type: application/json
	HumanLoopActivationConditionsEvaluationResults *string

	// The Amazon Resource Name (ARN) of the HumanLoop created.
	HumanLoopArn *string

	// Shows if and why human review was needed.
	HumanLoopActivationReasons []*string
}

type HumanLoopConfig struct {

	// Sets attributes of the input data.
	DataAttributes *HumanLoopDataAttributes

	// The name of the human review used for this image. This should be kept unique
	// within a region.
	//
	// This member is required.
	HumanLoopName *string

	// The Amazon Resource Name (ARN) of the flow definition. You can create a flow
	// definition by using the Amazon Sagemaker CreateFlowDefinition
	// (https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateFlowDefinition.html)
	// Operation.
	//
	// This member is required.
	FlowDefinitionArn *string
}

type HumanLoopDataAttributes struct {

	// Sets whether the input image is free of personally identifiable information.
	ContentClassifiers []ContentClassifier
}

type HumanLoopQuotaExceededException struct {
	Message *string

	ResourceType *string
	QuotaCode    *string
	Logref       *string
	Code         *string
	ServiceCode  *string
}

type IdempotentParameterMismatchException struct {
	Message *string

	Logref *string
	Code   *string
}

type Image struct {

	// Blob of image bytes up to 5 MBs.
	Bytes []byte

	// Identifies an S3 object as the image source.
	S3Object *S3Object
}

type ImageQuality struct {

	// Value representing sharpness of the face. The service returns a value between 0
	// and 100 (inclusive). A higher value indicates a sharper face image.
	Sharpness *float32

	// Value representing brightness of the face. The service returns a value between 0
	// and 100 (inclusive). A higher value indicates a brighter face image.
	Brightness *float32
}

type ImageTooLargeException struct {
	Message *string

	Logref *string
	Code   *string
}

type Instance struct {

	// The position of the label instance on the image.
	BoundingBox *BoundingBox

	// The confidence that Amazon Rekognition has in the accuracy of the bounding box.
	Confidence *float32
}

type InternalServerError struct {
	Message *string

	Logref *string
	Code   *string
}

type InvalidImageFormatException struct {
	Message *string

	Code   *string
	Logref *string
}

type InvalidPaginationTokenException struct {
	Message *string

	Code   *string
	Logref *string
}

type InvalidParameterException struct {
	Message *string

	Code   *string
	Logref *string
}

type InvalidS3ObjectException struct {
	Message *string

	Code   *string
	Logref *string
}

type KinesisDataStream struct {

	// ARN of the output Amazon Kinesis Data Streams stream.
	Arn *string
}

type KinesisVideoStream struct {

	// ARN of the Kinesis video stream stream that streams the source video.
	Arn *string
}

type Label struct {

	// The name (label) of the object or scene.
	Name *string

	// If Label represents an object, Instances contains the bounding boxes for each
	// instance of the detected object. Bounding boxes are returned for common object
	// labels such as people, cars, furniture, apparel or pets.
	Instances []*Instance

	// The parent labels for a label. The response includes all ancestor labels.
	Parents []*Parent

	// Level of confidence.
	Confidence *float32
}

type LabelDetection struct {

	// Details about the detected label.
	Label *Label

	// Time, in milliseconds from the start of the video, that the label was detected.
	Timestamp *int64
}

type LabelDetectionSortBy string

const (
	LabelDetectionSortByName      LabelDetectionSortBy = "NAME"
	LabelDetectionSortByTimestamp LabelDetectionSortBy = "TIMESTAMP"
)

type Landmark struct {

	// Type of landmark.
	Type LandmarkType

	// The y-coordinate from the top left of the landmark expressed as the ratio of the
	// height of the image. For example, if the image is 700 x 200 and the y-coordinate
	// of the landmark is at 100 pixels, this value is 0.5.
	Y *float32

	// The x-coordinate from the top left of the landmark expressed as the ratio of the
	// width of the image. For example, if the image is 700 x 200 and the x-coordinate
	// of the landmark is at 350 pixels, this value is 0.5.
	X *float32
}

type LandmarkType string

const (
	LandmarkTypeEyeleft           LandmarkType = "eyeLeft"
	LandmarkTypeEyeright          LandmarkType = "eyeRight"
	LandmarkTypeNose              LandmarkType = "nose"
	LandmarkTypeMouthleft         LandmarkType = "mouthLeft"
	LandmarkTypeMouthright        LandmarkType = "mouthRight"
	LandmarkTypeLefteyebrowleft   LandmarkType = "leftEyeBrowLeft"
	LandmarkTypeLefteyebrowright  LandmarkType = "leftEyeBrowRight"
	LandmarkTypeLefteyebrowup     LandmarkType = "leftEyeBrowUp"
	LandmarkTypeRighteyebrowleft  LandmarkType = "rightEyeBrowLeft"
	LandmarkTypeRighteyebrowright LandmarkType = "rightEyeBrowRight"
	LandmarkTypeRighteyebrowup    LandmarkType = "rightEyeBrowUp"
	LandmarkTypeLefteyeleft       LandmarkType = "leftEyeLeft"
	LandmarkTypeLefteyeright      LandmarkType = "leftEyeRight"
	LandmarkTypeLefteyeup         LandmarkType = "leftEyeUp"
	LandmarkTypeLefteyedown       LandmarkType = "leftEyeDown"
	LandmarkTypeRighteyeleft      LandmarkType = "rightEyeLeft"
	LandmarkTypeRighteyeright     LandmarkType = "rightEyeRight"
	LandmarkTypeRighteyeup        LandmarkType = "rightEyeUp"
	LandmarkTypeRighteyedown      LandmarkType = "rightEyeDown"
	LandmarkTypeNoseleft          LandmarkType = "noseLeft"
	LandmarkTypeNoseright         LandmarkType = "noseRight"
	LandmarkTypeMouthup           LandmarkType = "mouthUp"
	LandmarkTypeMouthdown         LandmarkType = "mouthDown"
	LandmarkTypeLeftpupil         LandmarkType = "leftPupil"
	LandmarkTypeRightpupil        LandmarkType = "rightPupil"
	LandmarkTypeUpperjawlineleft  LandmarkType = "upperJawlineLeft"
	LandmarkTypeMidjawlineleft    LandmarkType = "midJawlineLeft"
	LandmarkTypeChinbottom        LandmarkType = "chinBottom"
	LandmarkTypeMidjawlineright   LandmarkType = "midJawlineRight"
	LandmarkTypeUpperjawlineright LandmarkType = "upperJawlineRight"
)

type LimitExceededException struct {
	Message *string

	Logref *string
	Code   *string
}

type ModerationLabel struct {

	// The name for the parent label. Labels at the top level of the hierarchy have the
	// parent label "".
	ParentName *string

	// The label name for the type of unsafe content detected in the image.
	Name *string

	// Specifies the confidence that Amazon Rekognition has that the label has been
	// correctly identified. If you don't specify the MinConfidence parameter in the
	// call to DetectModerationLabels, the operation returns labels with a confidence
	// value greater than or equal to 50 percent.
	Confidence *float32
}

type MouthOpen struct {

	// Boolean value that indicates whether the mouth on the face is open or not.
	Value *bool

	// Level of confidence in the determination.
	Confidence *float32
}

type Mustache struct {

	// Boolean value that indicates whether the face has mustache or not.
	Value *bool

	// Level of confidence in the determination.
	Confidence *float32
}

type NotificationChannel struct {

	// The ARN of an IAM role that gives Amazon Rekognition publishing permissions to
	// the Amazon SNS topic.
	//
	// This member is required.
	RoleArn *string

	// The Amazon SNS topic to which Amazon Rekognition to posts the completion status.
	//
	// This member is required.
	SNSTopicArn *string
}

type OrientationCorrection string

const (
	OrientationCorrectionRotate_0   OrientationCorrection = "ROTATE_0"
	OrientationCorrectionRotate_90  OrientationCorrection = "ROTATE_90"
	OrientationCorrectionRotate_180 OrientationCorrection = "ROTATE_180"
	OrientationCorrectionRotate_270 OrientationCorrection = "ROTATE_270"
)

type OutputConfig struct {

	// The S3 bucket where training output is placed.
	S3Bucket *string

	// The prefix applied to the training output files.
	S3KeyPrefix *string
}

type Parent struct {

	// The name of the parent label.
	Name *string
}

type PersonDetail struct {

	// Identifier for the person detected person within a video. Use to keep track of
	// the person throughout the video. The identifier is not stored by Amazon
	// Rekognition.
	Index *int64

	// Face details for the detected person.
	Face *FaceDetail

	// Bounding box around the detected person.
	BoundingBox *BoundingBox
}

type PersonDetection struct {

	// The time, in milliseconds from the start of the video, that the person's path
	// was tracked.
	Timestamp *int64

	// Details about a person whose path was tracked in a video.
	Person *PersonDetail
}

type PersonMatch struct {

	// Information about the faces in the input collection that match the face of a
	// person in the video.
	FaceMatches []*FaceMatch

	// The time, in milliseconds from the beginning of the video, that the person was
	// matched in the video.
	Timestamp *int64

	// Information about the matched person.
	Person *PersonDetail
}

type PersonTrackingSortBy string

const (
	PersonTrackingSortByIndex     PersonTrackingSortBy = "INDEX"
	PersonTrackingSortByTimestamp PersonTrackingSortBy = "TIMESTAMP"
)

type Point struct {

	// The value of the X coordinate for a point on a Polygon.
	X *float32

	// The value of the Y coordinate for a point on a Polygon.
	Y *float32
}

type Pose struct {

	// Value representing the face rotation on the yaw axis.
	Yaw *float32

	// Value representing the face rotation on the roll axis.
	Roll *float32

	// Value representing the face rotation on the pitch axis.
	Pitch *float32
}

type ProjectDescription struct {

	// The current status of the project.
	Status ProjectStatus

	// The Amazon Resource Name (ARN) of the project.
	ProjectArn *string

	// The Unix timestamp for the date and time that the project was created.
	CreationTimestamp *time.Time
}

type ProjectStatus string

const (
	ProjectStatusCreating ProjectStatus = "CREATING"
	ProjectStatusCreated  ProjectStatus = "CREATED"
	ProjectStatusDeleting ProjectStatus = "DELETING"
)

type ProjectVersionDescription struct {

	// The location where training results are saved.
	OutputConfig *OutputConfig

	// The current status of the model version.
	Status ProjectVersionStatus

	// The minimum number of inference units used by the model. For more information,
	// see StartProjectVersion ().
	MinInferenceUnits *int32

	// The Unix date and time that training of the model ended.
	TrainingEndTimestamp *time.Time

	// The manifest file that represents the testing results.
	TestingDataResult *TestingDataResult

	// The manifest file that represents the training results.
	TrainingDataResult *TrainingDataResult

	// The Amazon Resource Name (ARN) of the model version.
	ProjectVersionArn *string

	// The training results. EvaluationResult is only returned if training is
	// successful.
	EvaluationResult *EvaluationResult

	// The duration, in seconds, that the model version has been billed for training.
	// This value is only returned if the model version has been successfully trained.
	BillableTrainingTimeInSeconds *int64

	// A descriptive message for an error or warning that occurred.
	StatusMessage *string

	// The Unix datetime for the date and time that training started.
	CreationTimestamp *time.Time
}

type ProjectVersionStatus string

const (
	ProjectVersionStatusTraining_in_progress ProjectVersionStatus = "TRAINING_IN_PROGRESS"
	ProjectVersionStatusTraining_completed   ProjectVersionStatus = "TRAINING_COMPLETED"
	ProjectVersionStatusTraining_failed      ProjectVersionStatus = "TRAINING_FAILED"
	ProjectVersionStatusStarting             ProjectVersionStatus = "STARTING"
	ProjectVersionStatusRunning              ProjectVersionStatus = "RUNNING"
	ProjectVersionStatusFailed               ProjectVersionStatus = "FAILED"
	ProjectVersionStatusStopping             ProjectVersionStatus = "STOPPING"
	ProjectVersionStatusStopped              ProjectVersionStatus = "STOPPED"
	ProjectVersionStatusDeleting             ProjectVersionStatus = "DELETING"
)

type ProvisionedThroughputExceededException struct {
	Message *string

	Code   *string
	Logref *string
}

type QualityFilter string

const (
	QualityFilterNone   QualityFilter = "NONE"
	QualityFilterAuto   QualityFilter = "AUTO"
	QualityFilterLow    QualityFilter = "LOW"
	QualityFilterMedium QualityFilter = "MEDIUM"
	QualityFilterHigh   QualityFilter = "HIGH"
)

type Reason string

const (
	ReasonExceeds_max_faces  Reason = "EXCEEDS_MAX_FACES"
	ReasonExtreme_pose       Reason = "EXTREME_POSE"
	ReasonLow_brightness     Reason = "LOW_BRIGHTNESS"
	ReasonLow_sharpness      Reason = "LOW_SHARPNESS"
	ReasonLow_confidence     Reason = "LOW_CONFIDENCE"
	ReasonSmall_bounding_box Reason = "SMALL_BOUNDING_BOX"
	ReasonLow_face_quality   Reason = "LOW_FACE_QUALITY"
)

type RegionOfInterest struct {

	// The box representing a region of interest on screen.
	BoundingBox *BoundingBox
}

type ResourceAlreadyExistsException struct {
	Message *string

	Code   *string
	Logref *string
}

type ResourceInUseException struct {
	Message *string

	Code   *string
	Logref *string
}

type ResourceNotFoundException struct {
	Message *string

	Logref *string
	Code   *string
}

type ResourceNotReadyException struct {
	Message *string

	Logref *string
	Code   *string
}

type S3Object struct {

	// Name of the S3 bucket.
	Bucket *string

	// If the bucket is versioning enabled, you can specify the object version.
	Version *string

	// S3 object key name.
	Name *string
}

type SegmentDetection struct {

	// The frame-accurate SMPTE timecode, from the start of a video, for the start of a
	// detected segment. StartTimecode is in HH:MM:SS:fr format (and ;fr for drop
	// frame-rates).
	StartTimecodeSMPTE *string

	// The duration of the timecode for the detected segment in SMPTE format.
	DurationSMPTE *string

	// If the segment is a shot detection, contains information about the shot
	// detection.
	ShotSegment *ShotSegment

	// The frame-accurate SMPTE timecode, from the start of a video, for the end of a
	// detected segment. EndTimecode is in HH:MM:SS:fr format (and ;fr for drop
	// frame-rates).
	EndTimecodeSMPTE *string

	// The end time of the detected segment, in milliseconds, from the start of the
	// video.
	EndTimestampMillis *int64

	// The start time of the detected segment in milliseconds from the start of the
	// video.
	StartTimestampMillis *int64

	// The type of the segment. Valid values are TECHNICAL_CUE and SHOT.
	Type SegmentType

	// If the segment is a technical cue, contains information about the technical cue.
	TechnicalCueSegment *TechnicalCueSegment

	// The duration of the detected segment in milliseconds.
	DurationMillis *int64
}

type SegmentType string

const (
	SegmentTypeTechnical_cue SegmentType = "TECHNICAL_CUE"
	SegmentTypeShot          SegmentType = "SHOT"
)

type SegmentTypeInfo struct {

	// The type of a segment (technical cue or shot detection).
	Type SegmentType

	// The version of the model used to detect segments.
	ModelVersion *string
}

type ShotSegment struct {

	// The confidence that Amazon Rekognition Video has in the accuracy of the detected
	// segment.
	Confidence *float32

	// An Identifier for a shot detection segment detected in a video
	Index *int64
}

type Smile struct {

	// Boolean value that indicates whether the face is smiling or not.
	Value *bool

	// Level of confidence in the determination.
	Confidence *float32
}

type StartSegmentDetectionFilters struct {

	// Filters that are specific to shot detections.
	ShotFilter *StartShotDetectionFilter

	// Filters that are specific to technical cues.
	TechnicalCueFilter *StartTechnicalCueDetectionFilter
}

type StartShotDetectionFilter struct {

	// Specifies the minimum confidence that Amazon Rekognition Video must have in
	// order to return a detected segment. Confidence represents how certain Amazon
	// Rekognition is that a segment is correctly identified. 0 is the lowest
	// confidence. 100 is the highest confidence. Amazon Rekognition Video doesn't
	// return any segments with a confidence level lower than this specified value. If
	// you don't specify MinSegmentConfidence, the GetSegmentDetection returns segments
	// with confidence values greater than or equal to 50 percent.
	MinSegmentConfidence *float32
}

type StartTechnicalCueDetectionFilter struct {

	// Specifies the minimum confidence that Amazon Rekognition Video must have in
	// order to return a detected segment. Confidence represents how certain Amazon
	// Rekognition is that a segment is correctly identified. 0 is the lowest
	// confidence. 100 is the highest confidence. Amazon Rekognition Video doesn't
	// return any segments with a confidence level lower than this specified value. If
	// you don't specify MinSegmentConfidence, GetSegmentDetection returns segments
	// with confidence values greater than or equal to 50 percent.
	MinSegmentConfidence *float32
}

type StartTextDetectionFilters struct {

	// Filter focusing on a certain area of the frame. Uses a BoundingBox object to set
	// the region of the screen.
	RegionsOfInterest []*RegionOfInterest

	// Filters focusing on qualities of the text, such as confidence or size.
	WordFilter *DetectionFilter
}

type StreamProcessor struct {

	// Name of the Amazon Rekognition stream processor.
	Name *string

	// Current status of the Amazon Rekognition stream processor.
	Status StreamProcessorStatus
}

type StreamProcessorInput struct {

	// The Kinesis video stream input stream for the source streaming video.
	KinesisVideoStream *KinesisVideoStream
}

type StreamProcessorOutput struct {

	// The Amazon Kinesis Data Streams stream to which the Amazon Rekognition stream
	// processor streams the analysis results.
	KinesisDataStream *KinesisDataStream
}

type StreamProcessorSettings struct {

	// Face search settings to use on a streaming video.
	FaceSearch *FaceSearchSettings
}

type StreamProcessorStatus string

const (
	StreamProcessorStatusStopped  StreamProcessorStatus = "STOPPED"
	StreamProcessorStatusStarting StreamProcessorStatus = "STARTING"
	StreamProcessorStatusRunning  StreamProcessorStatus = "RUNNING"
	StreamProcessorStatusFailed   StreamProcessorStatus = "FAILED"
	StreamProcessorStatusStopping StreamProcessorStatus = "STOPPING"
)

type Summary struct {

	// Provides the S3 bucket name and object name. The region for the S3 bucket
	// containing the S3 object must match the region you use for Amazon Rekognition
	// operations.  <p>For Amazon Rekognition to process an S3 object, the user must
	// have permission to access the S3 object. For more information, see
	// Resource-Based Policies in the Amazon Rekognition Developer Guide. </p>
	S3Object *S3Object
}

type Sunglasses struct {

	// Level of confidence in the determination.
	Confidence *float32

	// Boolean value that indicates whether the face is wearing sunglasses or not.
	Value *bool
}

type TechnicalCueSegment struct {

	// The type of the technical cue.
	Type TechnicalCueType

	// The confidence that Amazon Rekognition Video has in the accuracy of the detected
	// segment.
	Confidence *float32
}

type TechnicalCueType string

const (
	TechnicalCueTypeColor_bars   TechnicalCueType = "ColorBars"
	TechnicalCueTypeEnd_credits  TechnicalCueType = "EndCredits"
	TechnicalCueTypeBlack_frames TechnicalCueType = "BlackFrames"
)

type TestingData struct {

	// The assets used for testing.
	Assets []*Asset

	// If specified, Amazon Rekognition Custom Labels creates a testing dataset with an
	// 80/20 split of the training dataset.
	AutoCreate *bool
}

type TestingDataResult struct {

	// The testing dataset that was supplied for training.
	Input *TestingData

	// The subset of the dataset that was actually tested. Some images (assets) might
	// not be tested due to file formatting and other issues.
	Output *TestingData
}

type TextDetection struct {

	// The identifier for the detected text. The identifier is only unique for a single
	// call to DetectText.
	Id *int32

	// The location of the detected text on the image. Includes an axis aligned coarse
	// bounding box surrounding the text and a finer grain polygon for more accurate
	// spatial information.
	Geometry *Geometry

	// The type of text that was detected.
	Type TextTypes

	// The word or line of text recognized by Amazon Rekognition.
	DetectedText *string

	// The Parent identifier for the detected text identified by the value of ID. If
	// the type of detected text is LINE, the value of ParentId is Null.
	ParentId *int32

	// The confidence that Amazon Rekognition has in the accuracy of the detected text
	// and the accuracy of the geometry points around the detected text.
	Confidence *float32
}

type TextDetectionResult struct {

	// Details about text detected in a video.
	TextDetection *TextDetection

	// The time, in milliseconds from the start of the video, that the text was
	// detected.
	Timestamp *int64
}

type TextTypes string

const (
	TextTypesLine TextTypes = "LINE"
	TextTypesWord TextTypes = "WORD"
)

type ThrottlingException struct {
	Message *string

	Logref *string
	Code   *string
}

type TrainingData struct {

	// A Sagemaker GroundTruth manifest file that contains the training images
	// (assets).
	Assets []*Asset
}

type TrainingDataResult struct {

	// The images (assets) that were actually trained by Amazon Rekognition Custom
	// Labels.
	Output *TrainingData

	// The training assets that you supplied for training.
	Input *TrainingData
}

type UnindexedFace struct {

	// An array of reasons that specify why a face wasn't indexed.
	//
	//     * EXTREME_POSE
	// - The face is at a pose that can't be detected. For example, the head is turned
	// too far away from the camera.
	//
	//     * EXCEEDS_MAX_FACES - The number of faces
	// detected is already higher than that specified by the MaxFaces input parameter
	// for IndexFaces.
	//
	//     * LOW_BRIGHTNESS - The image is too dark.
	//
	//     *
	// LOW_SHARPNESS - The image is too blurry.
	//
	//     * LOW_CONFIDENCE - The face was
	// detected with a low confidence.
	//
	//     * SMALL_BOUNDING_BOX - The bounding box
	// around the face is too small.
	Reasons []Reason

	// The structure that contains attributes of a face that IndexFacesdetected, but
	// didn't index.
	FaceDetail *FaceDetail
}

type Video struct {

	// The Amazon S3 bucket name and file name for the video.
	S3Object *S3Object
}

type VideoJobStatus string

const (
	VideoJobStatusIn_progress VideoJobStatus = "IN_PROGRESS"
	VideoJobStatusSucceeded   VideoJobStatus = "SUCCEEDED"
	VideoJobStatusFailed      VideoJobStatus = "FAILED"
)

type VideoMetadata struct {

	// Length of the video in milliseconds.
	DurationMillis *int64

	// Vertical pixel dimension of the video.
	FrameHeight *int64

	// Number of frames per second in the video.
	FrameRate *float32

	// Horizontal pixel dimension of the video.
	FrameWidth *int64

	// Format of the analyzed video. Possible values are MP4, MOV and AVI.
	Format *string

	// Type of compression used in the analyzed video.
	Codec *string
}

type VideoTooLargeException struct {
	Message *string

	Code   *string
	Logref *string
}