type AccessDeniedException struct {
	Message *string
}

type BadRequestException struct {
	Message *string
}

type Category string

const (
	CategoryAwsiot Category = "AWSIoT"
)

type Destination struct {
	// The S3Destination object.
	S3 *S3Destination
}

type EncryptionAlgorithm string

const (
	EncryptionAlgorithmRsa   EncryptionAlgorithm = "RSA"
	EncryptionAlgorithmEcdsa EncryptionAlgorithm = "ECDSA"
)

type EncryptionAlgorithmOptions struct {
	// The default encryption algorithm that is used by a code signing job.
	DefaultValue EncryptionAlgorithm
	// The set of accepted encryption algorithms that are allowed in a code signing
	// job.
	AllowedValues []EncryptionAlgorithm
}

type HashAlgorithm string

const (
	HashAlgorithmSha1   HashAlgorithm = "SHA1"
	HashAlgorithmSha256 HashAlgorithm = "SHA256"
)

type HashAlgorithmOptions struct {
	// The set of accepted hash algorithms allowed in a code signing job.
	AllowedValues []HashAlgorithm
	// The default hash algorithm that is used in a code signing job.
	DefaultValue HashAlgorithm
}

type ImageFormat string

const (
	ImageFormatJson         ImageFormat = "JSON"
	ImageFormatJsonembedded ImageFormat = "JSONEmbedded"
	ImageFormatJsondetached ImageFormat = "JSONDetached"
)

type InternalServiceErrorException struct {
	Message *string
}

type NotFoundException struct {
	Message *string
}

type ResourceNotFoundException struct {
	Message *string
}

type S3Destination struct {
	// Name of the S3 bucket.
	BucketName *string
	// An Amazon S3 prefix that you can use to limit responses to those that begin with
	// the specified prefix.
	Prefix *string
}

type S3SignedObject struct {
	// Name of the S3 bucket.
	BucketName *string
	// Key name that uniquely identifies a signed code image in your bucket.
	Key *string
}

type S3Source struct {
	// Name of the S3 bucket.
	BucketName *string
	// Version of your source image in your version enabled S3 bucket.
	Version *string
	// Key name of the bucket object that contains your unsigned code.
	Key *string
}

type SignedObject struct {
	// The S3SignedObject.
	S3 *S3SignedObject
}

type SigningConfiguration struct {
	// The encryption algorithm options that are available for a code signing job.
	EncryptionAlgorithmOptions *EncryptionAlgorithmOptions
	// The hash algorithm options that are available for a code signing job.
	HashAlgorithmOptions *HashAlgorithmOptions
}

type SigningConfigurationOverrides struct {
	// A specified override of the default encryption algorithm that is used in a code
	// signing job.
	EncryptionAlgorithm EncryptionAlgorithm
	// A specified override of the default hash algorithm that is used in a code
	// signing job.
	HashAlgorithm HashAlgorithm
}

type SigningImageFormat struct {
	// The default format of a code signing image.
	DefaultFormat ImageFormat
	// The supported formats of a code signing image.
	SupportedFormats []ImageFormat
}

type SigningJob struct {
	// The status of the signing job.
	Status SigningStatus
	// A Source that contains information about a signing job's code image source.
	Source *Source
	// The ID of the signing job.
	JobId *string
	// A SigningMaterial object that contains the Amazon Resource Name (ARN) of the
	// certificate used for the signing job.
	SigningMaterial *SigningMaterial
	// The date and time that the signing job was created.
	CreatedAt *time.Time
	// A SignedObject structure that contains information about a signing job's signed
	// code image.
	SignedObject *SignedObject
}

type SigningMaterial struct {
	// The Amazon Resource Name (ARN) of the certificates that is used to sign your
	// code.
	CertificateArn *string
}

type SigningPlatform struct {
	// The types of targets that can be signed by a code signing platform.
	Target *string
	// The display name of a code signing platform.
	DisplayName *string
	// The configuration of a code signing platform. This includes the designated hash
	// algorithm and encryption algorithm of a signing platform.
	SigningConfiguration *SigningConfiguration
	// The image format of a code signing platform or profile.
	SigningImageFormat *SigningImageFormat
	// The ID of a code signing; platform.
	PlatformId *string
	// The category of a code signing platform.
	Category Category
	// Any partner entities linked to a code signing platform.
	Partner *string
	// The maximum size (in MB) of code that can be signed by a code signing platform.
	MaxSizeInMB *int32
}

type SigningPlatformOverrides struct {
	// A signing configuration that overrides the default encryption or hash algorithm
	// of a signing job.
	SigningConfiguration *SigningConfigurationOverrides
	// A signed image is a JSON object. When overriding the default signing platform
	// configuration, a customer can select either of two signing formats, JSONEmbedded
	// or JSONDetached. (A third format value, JSON, is reserved for future use.) With
	// JSONEmbedded, the signing image has the payload embedded in it. With
	// JSONDetached, the payload is not be embedded in the signing image.
	SigningImageFormat ImageFormat
}

type SigningProfile struct {
	// The ACM certificate that is available for use by a signing profile.
	SigningMaterial *SigningMaterial
	// The parameters that are available for use by a code signing user.
	SigningParameters map[string]*string
	// The name of the signing profile.
	ProfileName *string
	// The ID of a platform that is available for use by a signing profile.
	PlatformId *string
	// The Amazon Resource Name (ARN) for the signing profile.
	Arn *string
	// A list of tags associated with the signing profile.
	Tags map[string]*string
	// The status of a code signing profile.
	Status SigningProfileStatus
}

type SigningProfileStatus string

const (
	SigningProfileStatusActive   SigningProfileStatus = "Active"
	SigningProfileStatusCanceled SigningProfileStatus = "Canceled"
)

type SigningStatus string

const (
	SigningStatusInprogress SigningStatus = "InProgress"
	SigningStatusFailed     SigningStatus = "Failed"
	SigningStatusSucceeded  SigningStatus = "Succeeded"
)

type Source struct {
	// The S3Source object.
	S3 *S3Source
}

type ThrottlingException struct {
	Message *string
}

type ValidationException struct {
	Message *string
}