type BadRequestException struct {
	Message *string

	ErrorDetails []*ErrorDetail
}

type BulkDeployment struct {
	// The ARN of the bulk deployment.
	BulkDeploymentArn *string
	// The ID of the bulk deployment.
	BulkDeploymentId *string
	// The time, in ISO format, when the deployment was created.
	CreatedAt *string
}

type BulkDeploymentMetrics struct {
	// The total number of group records from the input file that have been processed
	// so far, or attempted.
	RecordsProcessed *int32
	// The total number of deployment attempts that returned a retryable error. For
	// example, a retry is triggered if the attempt to deploy a group returns a
	// throttling error. ''StartBulkDeployment'' retries a group deployment up to five
	// times.
	RetryAttempts *int32
	// The total number of records that returned a non-retryable error. For example,
	// this can occur if a group record from the input file uses an invalid format or
	// specifies a nonexistent group version, or if the execution role doesn't grant
	// permission to deploy a group or group version.
	InvalidInputRecords *int32
}

type BulkDeploymentResult struct {
	// The current status of the group deployment: ''InProgress'', ''Building'',
	// ''Success'', or ''Failure''.
	DeploymentStatus *string
	// The error message for a failed deployment
	ErrorMessage *string
	// The ID of the group deployment.
	DeploymentId *string
	// Details about the error.
	ErrorDetails []*ErrorDetail
	// The type of the deployment.
	DeploymentType DeploymentType
	// The time, in ISO format, when the deployment was created.
	CreatedAt *string
	// The ARN of the group deployment.
	DeploymentArn *string
	// The ARN of the Greengrass group.
	GroupArn *string
}

type BulkDeploymentStatus string

const (
	BulkDeploymentStatusInitializing BulkDeploymentStatus = "Initializing"
	BulkDeploymentStatusRunning      BulkDeploymentStatus = "Running"
	BulkDeploymentStatusCompleted    BulkDeploymentStatus = "Completed"
	BulkDeploymentStatusStopping     BulkDeploymentStatus = "Stopping"
	BulkDeploymentStatusStopped      BulkDeploymentStatus = "Stopped"
	BulkDeploymentStatusFailed       BulkDeploymentStatus = "Failed"
)

type ConnectivityInfo struct {
	// The endpoint for the Greengrass core. Can be an IP address or DNS.
	HostAddress *string
	// The ID of the connectivity information.
	Id *string
	// The port of the Greengrass core. Usually 8883.
	PortNumber *int32
	// Metadata for this endpoint.
	Metadata *string
}

type Connector struct {
	// The parameters or configuration that the connector uses.
	Parameters map[string]*string
	// The ARN of the connector.
	ConnectorArn *string
	// A descriptive or arbitrary ID for the connector. This value must be unique
	// within the connector definition version. Max length is 128 characters with
	// pattern [a-zA-Z0-9:_-]+.
	Id *string
}

type ConnectorDefinitionVersion struct {
	// A list of references to connectors in this version, with their corresponding
	// configuration settings.
	Connectors []*Connector
}

type Core struct {
	// The ARN of the certificate associated with the core.
	CertificateArn *string
	// A descriptive or arbitrary ID for the core. This value must be unique within the
	// core definition version. Max length is 128 characters with pattern
	// ''[a-zA-Z0-9:_-]+''.
	Id *string
	// If true, the core's local shadow is automatically synced with the cloud.
	SyncShadow *bool
	// The ARN of the thing which is the core.
	ThingArn *string
}

type CoreDefinitionVersion struct {
	// A list of cores in the core definition version.
	Cores []*Core
}

type DefinitionInformation struct {
	// The name of the definition.
	Name *string
	// The ID of the definition.
	Id *string
	// The time, in milliseconds since the epoch, when the definition was created.
	CreationTimestamp *string
	// The ID of the latest version associated with the definition.
	LatestVersion *string
	// The ARN of the definition.
	Arn *string
	// The time, in milliseconds since the epoch, when the definition was last updated.
	LastUpdatedTimestamp *string
	// Tag(s) attached to the resource arn.
	Tags map[string]*string
	// The ARN of the latest version associated with the definition.
	LatestVersionArn *string
}

type Deployment struct {
	// The ARN of the group for this deployment.
	GroupArn *string
	// The type of the deployment.
	DeploymentType DeploymentType
	// The ARN of the deployment.
	DeploymentArn *string
	// The ID of the deployment.
	DeploymentId *string
	// The time, in milliseconds since the epoch, when the deployment was created.
	CreatedAt *string
}

type DeploymentType string

const (
	DeploymentTypeNewdeployment        DeploymentType = "NewDeployment"
	DeploymentTypeRedeployment         DeploymentType = "Redeployment"
	DeploymentTypeResetdeployment      DeploymentType = "ResetDeployment"
	DeploymentTypeForceresetdeployment DeploymentType = "ForceResetDeployment"
)

type Device struct {
	// If true, the device's local shadow will be automatically synced with the cloud.
	SyncShadow *bool
	// The thing ARN of the device.
	ThingArn *string
	// A descriptive or arbitrary ID for the device. This value must be unique within
	// the device definition version. Max length is 128 characters with pattern
	// ''[a-zA-Z0-9:_-]+''.
	Id *string
	// The ARN of the certificate associated with the device.
	CertificateArn *string
}

type DeviceDefinitionVersion struct {
	// A list of devices in the definition version.
	Devices []*Device
}

type EncodingType string

const (
	EncodingTypeBinary EncodingType = "binary"
	EncodingTypeJson   EncodingType = "json"
)

type ErrorDetail struct {
	// A detailed error code.
	DetailedErrorCode *string
	// A detailed error message.
	DetailedErrorMessage *string
}

type Function struct {
	// The configuration of the Lambda function.
	FunctionConfiguration *FunctionConfiguration
	// A descriptive or arbitrary ID for the function. This value must be unique within
	// the function definition version. Max length is 128 characters with pattern
	// ''[a-zA-Z0-9:_-]+''.
	Id *string
	// The ARN of the Lambda function.
	FunctionArn *string
}

type FunctionConfiguration struct {
	// The allowed function execution time, after which Lambda should terminate the
	// function. This timeout still applies to pinned Lambda functions for each
	// request.
	Timeout *int32
	// True if the function is pinned. Pinned means the function is long-lived and
	// starts when the core starts.
	Pinned *bool
	// The expected encoding type of the input payload for the function. The default is
	// ''json''.
	EncodingType EncodingType
	// The name of the function executable.
	Executable *string
	// The environment configuration of the function.
	Environment *FunctionConfigurationEnvironment
	// The memory size, in KB, which the function requires. This setting is not
	// applicable and should be cleared when you run the Lambda function without
	// containerization.
	MemorySize *int32
	// The execution arguments.
	ExecArgs *string
}

type FunctionConfigurationEnvironment struct {
	// Environment variables for the Lambda function's configuration.
	Variables map[string]*string
	// A list of the resources, with their permissions, to which the Lambda function
	// will be granted access. A Lambda function can have at most 10 resources.
	// ResourceAccessPolicies apply only when you run the Lambda function in a
	// Greengrass container.
	ResourceAccessPolicies []*ResourceAccessPolicy
	// If true, the Lambda function is allowed to access the host's /sys folder. Use
	// this when the Lambda function needs to read device information from /sys. This
	// setting applies only when you run the Lambda function in a Greengrass container.
	AccessSysfs *bool
	// Configuration related to executing the Lambda function
	Execution *FunctionExecutionConfig
}

type FunctionDefaultConfig struct {
	// Configuration information that specifies how a Lambda function runs.
	Execution *FunctionDefaultExecutionConfig
}

type FunctionDefaultExecutionConfig struct {
	// Specifies the user and group whose permissions are used when running the Lambda
	// function. You can specify one or both values to override the default values. We
	// recommend that you avoid running as root unless absolutely necessary to minimize
	// the risk of unintended changes or malicious attacks. To run as root, you must
	// set ''IsolationMode'' to ''NoContainer'' and update config.json in
	// ''greengrass-root/config'' to set ''allowFunctionsToRunAsRoot'' to ''yes''.
	RunAs *FunctionRunAsConfig
	// Specifies whether the Lambda function runs in a Greengrass container (default)
	// or without containerization. Unless your scenario requires that you run without
	// containerization, we recommend that you run in a Greengrass container. Omit this
	// value to run the Lambda function with the default containerization for the
	// group.
	IsolationMode FunctionIsolationMode
}

type FunctionDefinitionVersion struct {
	// A list of Lambda functions in this function definition version.
	Functions []*Function
	// The default configuration that applies to all Lambda functions in this function
	// definition version. Individual Lambda functions can override these settings.
	DefaultConfig *FunctionDefaultConfig
}

type FunctionExecutionConfig struct {
	// Specifies whether the Lambda function runs in a Greengrass container (default)
	// or without containerization. Unless your scenario requires that you run without
	// containerization, we recommend that you run in a Greengrass container. Omit this
	// value to run the Lambda function with the default containerization for the
	// group.
	IsolationMode FunctionIsolationMode
	// Specifies the user and group whose permissions are used when running the Lambda
	// function. You can specify one or both values to override the default values. We
	// recommend that you avoid running as root unless absolutely necessary to minimize
	// the risk of unintended changes or malicious attacks. To run as root, you must
	// set ''IsolationMode'' to ''NoContainer'' and update config.json in
	// ''greengrass-root/config'' to set ''allowFunctionsToRunAsRoot'' to ''yes''.
	RunAs *FunctionRunAsConfig
}

type FunctionIsolationMode string

const (
	FunctionIsolationModeGreengrasscontainer FunctionIsolationMode = "GreengrassContainer"
	FunctionIsolationModeNocontainer         FunctionIsolationMode = "NoContainer"
)

type FunctionRunAsConfig struct {
	// The group ID whose permissions are used to run a Lambda function.
	Gid *int32
	// The user ID whose permissions are used to run a Lambda function.
	Uid *int32
}

type GroupCertificateAuthorityProperties struct {
	// The ID of the certificate authority for the group.
	GroupCertificateAuthorityId *string
	// The ARN of the certificate authority for the group.
	GroupCertificateAuthorityArn *string
}

type GroupInformation struct {
	// The time, in milliseconds since the epoch, when the group was created.
	CreationTimestamp *string
	// The ID of the latest version associated with the group.
	LatestVersion *string
	// The ARN of the latest version associated with the group.
	LatestVersionArn *string
	// The time, in milliseconds since the epoch, when the group was last updated.
	LastUpdatedTimestamp *string
	// The ID of the group.
	Id *string
	// The name of the group.
	Name *string
	// The ARN of the group.
	Arn *string
}

type GroupOwnerSetting struct {
	// If true, AWS IoT Greengrass automatically adds the specified Linux OS group
	// owner of the resource to the Lambda process privileges. Thus the Lambda process
	// will have the file access permissions of the added Linux group.
	AutoAddGroupOwner *bool
	// The name of the Linux OS group whose privileges will be added to the Lambda
	// process. This field is optional.
	GroupOwner *string
}

type GroupVersion struct {
	// The ARN of the subscription definition version for this group.
	SubscriptionDefinitionVersionArn *string
	// The ARN of the logger definition version for this group.
	LoggerDefinitionVersionArn *string
	// The ARN of the connector definition version for this group.
	ConnectorDefinitionVersionArn *string
	// The ARN of the core definition version for this group.
	CoreDefinitionVersionArn *string
	// The ARN of the resource definition version for this group.
	ResourceDefinitionVersionArn *string
	// The ARN of the device definition version for this group.
	DeviceDefinitionVersionArn *string
	// The ARN of the function definition version for this group.
	FunctionDefinitionVersionArn *string
}

type InternalServerErrorException struct {
	Message *string

	ErrorDetails []*ErrorDetail
}

type LocalDeviceResourceData struct {
	// Group/owner related settings for local resources.
	GroupOwnerSetting *GroupOwnerSetting
	// The local absolute path of the device resource. The source path for a device
	// resource can refer only to a character device or block device under ''/dev''.
	SourcePath *string
}

type LocalVolumeResourceData struct {
	// The absolute local path of the resource inside the Lambda environment.
	DestinationPath *string
	// The local absolute path of the volume resource on the host. The source path for
	// a volume resource type cannot start with ''/sys''.
	SourcePath *string
	// Allows you to configure additional group privileges for the Lambda process. This
	// field is optional.
	GroupOwnerSetting *GroupOwnerSetting
}

type Logger struct {
	// The amount of file space, in KB, to use if the local file system is used for
	// logging purposes.
	Space *int32
	// The type of log output which will be used.
	Type LoggerType
	// The level of the logs.
	Level LoggerLevel
	// The component that will be subject to logging.
	Component LoggerComponent
	// A descriptive or arbitrary ID for the logger. This value must be unique within
	// the logger definition version. Max length is 128 characters with pattern
	// ''[a-zA-Z0-9:_-]+''.
	Id *string
}

type LoggerComponent string

const (
	LoggerComponentGreengrasssystem LoggerComponent = "GreengrassSystem"
	LoggerComponentLambda           LoggerComponent = "Lambda"
)

type LoggerDefinitionVersion struct {
	// A list of loggers.
	Loggers []*Logger
}

type LoggerLevel string

const (
	LoggerLevelDebug LoggerLevel = "DEBUG"
	LoggerLevelInfo  LoggerLevel = "INFO"
	LoggerLevelWarn  LoggerLevel = "WARN"
	LoggerLevelError LoggerLevel = "ERROR"
	LoggerLevelFatal LoggerLevel = "FATAL"
)

type LoggerType string

const (
	LoggerTypeFilesystem    LoggerType = "FileSystem"
	LoggerTypeAwscloudwatch LoggerType = "AWSCloudWatch"
)

type Permission string

const (
	PermissionRo Permission = "ro"
	PermissionRw Permission = "rw"
)

type Resource struct {
	// A container of data for all resource types.
	ResourceDataContainer *ResourceDataContainer
	// The resource ID, used to refer to a resource in the Lambda function
	// configuration. Max length is 128 characters with pattern ''[a-zA-Z0-9:_-]+''.
	// This must be unique within a Greengrass group.
	Id *string
	// The descriptive resource name, which is displayed on the AWS IoT Greengrass
	// console. Max length 128 characters with pattern ''[a-zA-Z0-9:_-]+''. This must
	// be unique within a Greengrass group.
	Name *string
}

type ResourceAccessPolicy struct {
	// The permissions that the Lambda function has to the resource. Can be one of
	// ''rw'' (read/write) or ''ro'' (read-only).
	Permission Permission
	// The ID of the resource. (This ID is assigned to the resource when you create the
	// resource definiton.)
	ResourceId *string
}

type ResourceDataContainer struct {
	// Attributes that define an Amazon SageMaker machine learning resource.
	SageMakerMachineLearningModelResourceData *SageMakerMachineLearningModelResourceData
	// Attributes that define a secret resource, which references a secret from AWS
	// Secrets Manager.
	SecretsManagerSecretResourceData *SecretsManagerSecretResourceData
	// Attributes that define an Amazon S3 machine learning resource.
	S3MachineLearningModelResourceData *S3MachineLearningModelResourceData
	// Attributes that define the local volume resource.
	LocalVolumeResourceData *LocalVolumeResourceData
	// Attributes that define the local device resource.
	LocalDeviceResourceData *LocalDeviceResourceData
}

type ResourceDefinitionVersion struct {
	// A list of resources.
	Resources []*Resource
}

type ResourceDownloadOwnerSetting struct {
	// The permissions that the group owner has to the resource. Valid values are
	// ''rw'' (read/write) or ''ro'' (read-only).
	GroupPermission Permission
	// The group owner of the resource. This is the name of an existing Linux OS group
	// on the system or a GID. The group's permissions are added to the Lambda process.
	GroupOwner *string
}

type S3MachineLearningModelResourceData struct {
	// The URI of the source model in an S3 bucket. The model package must be in tar.gz
	// or .zip format.
	S3Uri *string
	// The absolute local path of the resource inside the Lambda environment.
	DestinationPath *string
	// The owner setting for downloaded machine learning resources.
	OwnerSetting *ResourceDownloadOwnerSetting
}

type SageMakerMachineLearningModelResourceData struct {
	// The ARN of the Amazon SageMaker training job that represents the source model.
	SageMakerJobArn *string
	// The owner setting for downloaded machine learning resources.
	OwnerSetting *ResourceDownloadOwnerSetting
	// The absolute local path of the resource inside the Lambda environment.
	DestinationPath *string
}

type SecretsManagerSecretResourceData struct {
	// The ARN of the Secrets Manager secret to make available on the core. The value
	// of the secret's latest version (represented by the ''AWSCURRENT'' staging label)
	// is included by default.
	ARN *string
	// Optional. The staging labels whose values you want to make available on the
	// core, in addition to ''AWSCURRENT''.
	AdditionalStagingLabelsToDownload []*string
}

type SoftwareToUpdate string

const (
	SoftwareToUpdateCore      SoftwareToUpdate = "core"
	SoftwareToUpdateOta_agent SoftwareToUpdate = "ota_agent"
)

type Subscription struct {
	// The source of the subscription. Can be a thing ARN, a Lambda function ARN, a
	// connector ARN, 'cloud' (which represents the AWS IoT cloud), or
	// 'GGShadowService'.
	Source *string
	// Where the message is sent to. Can be a thing ARN, a Lambda function ARN, a
	// connector ARN, 'cloud' (which represents the AWS IoT cloud), or
	// 'GGShadowService'.
	Target *string
	// The MQTT topic used to route the message.
	Subject *string
	// A descriptive or arbitrary ID for the subscription. This value must be unique
	// within the subscription definition version. Max length is 128 characters with
	// pattern ''[a-zA-Z0-9:_-]+''.
	Id *string
}

type SubscriptionDefinitionVersion struct {
	// A list of subscriptions.
	Subscriptions []*Subscription
}

type UpdateAgentLogLevel string

const (
	UpdateAgentLogLevelNone    UpdateAgentLogLevel = "NONE"
	UpdateAgentLogLevelTrace   UpdateAgentLogLevel = "TRACE"
	UpdateAgentLogLevelDebug   UpdateAgentLogLevel = "DEBUG"
	UpdateAgentLogLevelVerbose UpdateAgentLogLevel = "VERBOSE"
	UpdateAgentLogLevelInfo    UpdateAgentLogLevel = "INFO"
	UpdateAgentLogLevelWarn    UpdateAgentLogLevel = "WARN"
	UpdateAgentLogLevelError   UpdateAgentLogLevel = "ERROR"
	UpdateAgentLogLevelFatal   UpdateAgentLogLevel = "FATAL"
)

type UpdateTargetsArchitecture string

const (
	UpdateTargetsArchitectureArmv6l  UpdateTargetsArchitecture = "armv6l"
	UpdateTargetsArchitectureArmv7l  UpdateTargetsArchitecture = "armv7l"
	UpdateTargetsArchitectureX86_64  UpdateTargetsArchitecture = "x86_64"
	UpdateTargetsArchitectureAarch64 UpdateTargetsArchitecture = "aarch64"
)

type UpdateTargetsOperatingSystem string

const (
	UpdateTargetsOperatingSystemUbuntu       UpdateTargetsOperatingSystem = "ubuntu"
	UpdateTargetsOperatingSystemRaspbian     UpdateTargetsOperatingSystem = "raspbian"
	UpdateTargetsOperatingSystemAmazon_linux UpdateTargetsOperatingSystem = "amazon_linux"
	UpdateTargetsOperatingSystemOpenwrt      UpdateTargetsOperatingSystem = "openwrt"
)

type VersionInformation struct {
	// The ID of the version.
	Version *string
	// The time, in milliseconds since the epoch, when the version was created.
	CreationTimestamp *string
	// The ID of the parent definition that the version is associated with.
	Id *string
	// The ARN of the version.
	Arn *string
}