Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type BadRequestException

type BadRequestException struct {
	Message *string

	ErrorDetails []ErrorDetail
}

    General error information.

    func (*BadRequestException) Error

    func (e *BadRequestException) Error() string

    func (*BadRequestException) ErrorCode

    func (e *BadRequestException) ErrorCode() string

    func (*BadRequestException) ErrorFault

    func (e *BadRequestException) ErrorFault() smithy.ErrorFault

    func (*BadRequestException) ErrorMessage

    func (e *BadRequestException) ErrorMessage() string

    type BulkDeployment

    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
    }

      Information about a bulk deployment. You cannot start a new bulk deployment while another one is still running or in a non-terminal state.

      type BulkDeploymentMetrics

      type BulkDeploymentMetrics struct {
      
      	// 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
      
      	// 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
      }

        Relevant metrics on input records processed during bulk deployment.

        type BulkDeploymentResult

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

          Information about an individual group deployment in a bulk deployment operation.

          type BulkDeploymentStatus

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

            Enum values for BulkDeploymentStatus

            func (BulkDeploymentStatus) Values

              Values returns all known values for BulkDeploymentStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

              type ConfigurationSyncStatus

              type ConfigurationSyncStatus string
              const (
              	ConfigurationSyncStatusInSync    ConfigurationSyncStatus = "InSync"
              	ConfigurationSyncStatusOutOfSync ConfigurationSyncStatus = "OutOfSync"
              )

                Enum values for ConfigurationSyncStatus

                func (ConfigurationSyncStatus) Values

                  Values returns all known values for ConfigurationSyncStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                  type ConnectivityInfo

                  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
                  
                  	// Metadata for this endpoint.
                  	Metadata *string
                  
                  	// The port of the Greengrass core. Usually 8883.
                  	PortNumber int32
                  }

                    Information about a Greengrass core's connectivity.

                    type Connector

                    type Connector struct {
                    
                    	// The ARN of the connector.
                    	//
                    	// This member is required.
                    	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:_-]+.
                    	//
                    	// This member is required.
                    	Id *string
                    
                    	// The parameters or configuration that the connector uses.
                    	Parameters map[string]string
                    }

                      Information about a connector. Connectors run on the Greengrass core and contain built-in integration with local infrastructure, device protocols, AWS, and other cloud services.

                      type ConnectorDefinitionVersion

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

                        Information about the connector definition version, which is a container for connectors.

                        type Core

                        type Core struct {
                        
                        	// The ARN of the certificate associated with the core.
                        	//
                        	// This member is required.
                        	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:_-]+”.
                        	//
                        	// This member is required.
                        	Id *string
                        
                        	// The ARN of the thing which is the core.
                        	//
                        	// This member is required.
                        	ThingArn *string
                        
                        	// If true, the core's local shadow is automatically synced with the cloud.
                        	SyncShadow bool
                        }

                          Information about a core.

                          type CoreDefinitionVersion

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

                            Information about a core definition version.

                            type DefinitionInformation

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

                              Information about a definition.

                              type Deployment

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

                                Information about a deployment.

                                type DeploymentType

                                type DeploymentType string
                                const (
                                	DeploymentTypeNewDeployment        DeploymentType = "NewDeployment"
                                	DeploymentTypeRedeployment         DeploymentType = "Redeployment"
                                	DeploymentTypeResetDeployment      DeploymentType = "ResetDeployment"
                                	DeploymentTypeForceResetDeployment DeploymentType = "ForceResetDeployment"
                                )

                                  Enum values for DeploymentType

                                  func (DeploymentType) Values

                                  func (DeploymentType) Values() []DeploymentType

                                    Values returns all known values for DeploymentType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                    type Device

                                    type Device struct {
                                    
                                    	// The ARN of the certificate associated with the device.
                                    	//
                                    	// This member is required.
                                    	CertificateArn *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:_-]+”.
                                    	//
                                    	// This member is required.
                                    	Id *string
                                    
                                    	// The thing ARN of the device.
                                    	//
                                    	// This member is required.
                                    	ThingArn *string
                                    
                                    	// If true, the device's local shadow will be automatically synced with the cloud.
                                    	SyncShadow bool
                                    }

                                      Information about a device.

                                      type DeviceDefinitionVersion

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

                                        Information about a device definition version.

                                        type EncodingType

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

                                          Enum values for EncodingType

                                          func (EncodingType) Values

                                          func (EncodingType) Values() []EncodingType

                                            Values returns all known values for EncodingType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                            type ErrorDetail

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

                                              Details about the error.

                                              type Function

                                              type Function struct {
                                              
                                              	// 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:_-]+”.
                                              	//
                                              	// This member is required.
                                              	Id *string
                                              
                                              	// The ARN of the Lambda function.
                                              	FunctionArn *string
                                              
                                              	// The configuration of the Lambda function.
                                              	FunctionConfiguration *FunctionConfiguration
                                              }

                                                Information about a Lambda function.

                                                type FunctionConfiguration

                                                type FunctionConfiguration struct {
                                                
                                                	// The expected encoding type of the input payload for the function. The default is
                                                	// ”json”.
                                                	EncodingType EncodingType
                                                
                                                	// The environment configuration of the function.
                                                	Environment *FunctionConfigurationEnvironment
                                                
                                                	// The execution arguments.
                                                	ExecArgs *string
                                                
                                                	// The name of the function executable.
                                                	Executable *string
                                                
                                                	// 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
                                                
                                                	// True if the function is pinned. Pinned means the function is long-lived and
                                                	// starts when the core starts.
                                                	Pinned bool
                                                
                                                	// 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
                                                }

                                                  The configuration of the Lambda function.

                                                  type FunctionConfigurationEnvironment

                                                  type FunctionConfigurationEnvironment struct {
                                                  
                                                  	// 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
                                                  
                                                  	// 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
                                                  
                                                  	// Environment variables for the Lambda function's configuration.
                                                  	Variables map[string]string
                                                  }

                                                    The environment configuration of the function.

                                                    type FunctionDefaultConfig

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

                                                      The default configuration that applies to all Lambda functions in the group. Individual Lambda functions can override these settings.

                                                      type FunctionDefaultExecutionConfig

                                                      type FunctionDefaultExecutionConfig 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
                                                      }

                                                        Configuration information that specifies how a Lambda function runs.

                                                        type FunctionDefinitionVersion

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

                                                          Information about a function definition version.

                                                          type FunctionExecutionConfig

                                                          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
                                                          }

                                                            Configuration information that specifies how a Lambda function runs.

                                                            type FunctionIsolationMode

                                                            type FunctionIsolationMode string
                                                            const (
                                                            	FunctionIsolationModeGreengrassContainer FunctionIsolationMode = "GreengrassContainer"
                                                            	FunctionIsolationModeNoContainer         FunctionIsolationMode = "NoContainer"
                                                            )

                                                              Enum values for FunctionIsolationMode

                                                              func (FunctionIsolationMode) Values

                                                                Values returns all known values for FunctionIsolationMode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                type FunctionRunAsConfig

                                                                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
                                                                }

                                                                  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”.

                                                                  type GroupCertificateAuthorityProperties

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

                                                                    Information about a certificate authority for a group.

                                                                    type GroupInformation

                                                                    type GroupInformation struct {
                                                                    
                                                                    	// The ARN of the group.
                                                                    	Arn *string
                                                                    
                                                                    	// The time, in milliseconds since the epoch, when the group was created.
                                                                    	CreationTimestamp *string
                                                                    
                                                                    	// The ID of the group.
                                                                    	Id *string
                                                                    
                                                                    	// The time, in milliseconds since the epoch, when the group was last updated.
                                                                    	LastUpdatedTimestamp *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 name of the group.
                                                                    	Name *string
                                                                    }

                                                                      Information about a group.

                                                                      type GroupOwnerSetting

                                                                      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
                                                                      }

                                                                        Group owner related settings for local resources.

                                                                        type GroupVersion

                                                                        type GroupVersion struct {
                                                                        
                                                                        	// 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 device definition version for this group.
                                                                        	DeviceDefinitionVersionArn *string
                                                                        
                                                                        	// The ARN of the function definition version for this group.
                                                                        	FunctionDefinitionVersionArn *string
                                                                        
                                                                        	// The ARN of the logger definition version for this group.
                                                                        	LoggerDefinitionVersionArn *string
                                                                        
                                                                        	// The ARN of the resource definition version for this group.
                                                                        	ResourceDefinitionVersionArn *string
                                                                        
                                                                        	// The ARN of the subscription definition version for this group.
                                                                        	SubscriptionDefinitionVersionArn *string
                                                                        }

                                                                          Information about a group version.

                                                                          type InternalServerErrorException

                                                                          type InternalServerErrorException struct {
                                                                          	Message *string
                                                                          
                                                                          	ErrorDetails []ErrorDetail
                                                                          }

                                                                            General error information.

                                                                            func (*InternalServerErrorException) Error

                                                                            func (*InternalServerErrorException) ErrorCode

                                                                            func (e *InternalServerErrorException) ErrorCode() string

                                                                            func (*InternalServerErrorException) ErrorFault

                                                                            func (*InternalServerErrorException) ErrorMessage

                                                                            func (e *InternalServerErrorException) ErrorMessage() string

                                                                            type LocalDeviceResourceData

                                                                            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
                                                                            }

                                                                              Attributes that define a local device resource.

                                                                              type LocalVolumeResourceData

                                                                              type LocalVolumeResourceData struct {
                                                                              
                                                                              	// The absolute local path of the resource inside the Lambda environment.
                                                                              	DestinationPath *string
                                                                              
                                                                              	// Allows you to configure additional group privileges for the Lambda process. This
                                                                              	// field is optional.
                                                                              	GroupOwnerSetting *GroupOwnerSetting
                                                                              
                                                                              	// 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
                                                                              }

                                                                                Attributes that define a local volume resource.

                                                                                type Logger

                                                                                type Logger struct {
                                                                                
                                                                                	// The component that will be subject to logging.
                                                                                	//
                                                                                	// This member is required.
                                                                                	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:_-]+”.
                                                                                	//
                                                                                	// This member is required.
                                                                                	Id *string
                                                                                
                                                                                	// The level of the logs.
                                                                                	//
                                                                                	// This member is required.
                                                                                	Level LoggerLevel
                                                                                
                                                                                	// The type of log output which will be used.
                                                                                	//
                                                                                	// This member is required.
                                                                                	Type LoggerType
                                                                                
                                                                                	// The amount of file space, in KB, to use if the local file system is used for
                                                                                	// logging purposes.
                                                                                	Space int32
                                                                                }

                                                                                  Information about a logger

                                                                                  type LoggerComponent

                                                                                  type LoggerComponent string
                                                                                  const (
                                                                                  	LoggerComponentGreengrassSystem LoggerComponent = "GreengrassSystem"
                                                                                  	LoggerComponentLambda           LoggerComponent = "Lambda"
                                                                                  )

                                                                                    Enum values for LoggerComponent

                                                                                    func (LoggerComponent) Values

                                                                                    func (LoggerComponent) Values() []LoggerComponent

                                                                                      Values returns all known values for LoggerComponent. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                      type LoggerDefinitionVersion

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

                                                                                        Information about a logger definition version.

                                                                                        type LoggerLevel

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

                                                                                          Enum values for LoggerLevel

                                                                                          func (LoggerLevel) Values

                                                                                          func (LoggerLevel) Values() []LoggerLevel

                                                                                            Values returns all known values for LoggerLevel. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                            type LoggerType

                                                                                            type LoggerType string
                                                                                            const (
                                                                                            	LoggerTypeFileSystem    LoggerType = "FileSystem"
                                                                                            	LoggerTypeAWSCloudWatch LoggerType = "AWSCloudWatch"
                                                                                            )

                                                                                              Enum values for LoggerType

                                                                                              func (LoggerType) Values

                                                                                              func (LoggerType) Values() []LoggerType

                                                                                                Values returns all known values for LoggerType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                type Permission

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

                                                                                                  Enum values for Permission

                                                                                                  func (Permission) Values

                                                                                                  func (Permission) Values() []Permission

                                                                                                    Values returns all known values for Permission. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                    type Resource

                                                                                                    type Resource struct {
                                                                                                    
                                                                                                    	// 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.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	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.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	Name *string
                                                                                                    
                                                                                                    	// A container of data for all resource types.
                                                                                                    	//
                                                                                                    	// This member is required.
                                                                                                    	ResourceDataContainer *ResourceDataContainer
                                                                                                    }

                                                                                                      Information about a resource.

                                                                                                      type ResourceAccessPolicy

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

                                                                                                        A policy used by the function to access a resource.

                                                                                                        type ResourceDataContainer

                                                                                                        type ResourceDataContainer struct {
                                                                                                        
                                                                                                        	// Attributes that define the local device resource.
                                                                                                        	LocalDeviceResourceData *LocalDeviceResourceData
                                                                                                        
                                                                                                        	// Attributes that define the local volume resource.
                                                                                                        	LocalVolumeResourceData *LocalVolumeResourceData
                                                                                                        
                                                                                                        	// Attributes that define an Amazon S3 machine learning resource.
                                                                                                        	S3MachineLearningModelResourceData *S3MachineLearningModelResourceData
                                                                                                        
                                                                                                        	// 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
                                                                                                        }

                                                                                                          A container for resource data. The container takes only one of the following supported resource data types: ”LocalDeviceResourceData”, ”LocalVolumeResourceData”, ”SageMakerMachineLearningModelResourceData”, ”S3MachineLearningModelResourceData”, ”SecretsManagerSecretResourceData”.

                                                                                                          type ResourceDefinitionVersion

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

                                                                                                            Information about a resource definition version.

                                                                                                            type ResourceDownloadOwnerSetting

                                                                                                            type ResourceDownloadOwnerSetting struct {
                                                                                                            
                                                                                                            	// 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.
                                                                                                            	//
                                                                                                            	// This member is required.
                                                                                                            	GroupOwner *string
                                                                                                            
                                                                                                            	// The permissions that the group owner has to the resource. Valid values are
                                                                                                            	// ”rw” (read/write) or ”ro” (read-only).
                                                                                                            	//
                                                                                                            	// This member is required.
                                                                                                            	GroupPermission Permission
                                                                                                            }

                                                                                                              The owner setting for downloaded machine learning resources.

                                                                                                              type RuntimeConfiguration

                                                                                                              type RuntimeConfiguration struct {
                                                                                                              
                                                                                                              	// Configuration for telemetry service.
                                                                                                              	TelemetryConfiguration *TelemetryConfiguration
                                                                                                              }

                                                                                                                Runtime configuration for a thing.

                                                                                                                type S3MachineLearningModelResourceData

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

                                                                                                                  Attributes that define an Amazon S3 machine learning resource.

                                                                                                                  type SageMakerMachineLearningModelResourceData

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

                                                                                                                    Attributes that define an Amazon SageMaker machine learning resource.

                                                                                                                    type SecretsManagerSecretResourceData

                                                                                                                    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
                                                                                                                    }

                                                                                                                      Attributes that define a secret resource, which references a secret from AWS Secrets Manager. AWS IoT Greengrass stores a local, encrypted copy of the secret on the Greengrass core, where it can be securely accessed by connectors and Lambda functions.

                                                                                                                      type SoftwareToUpdate

                                                                                                                      type SoftwareToUpdate string
                                                                                                                      const (
                                                                                                                      	SoftwareToUpdateCore     SoftwareToUpdate = "core"
                                                                                                                      	SoftwareToUpdateOtaAgent SoftwareToUpdate = "ota_agent"
                                                                                                                      )

                                                                                                                        Enum values for SoftwareToUpdate

                                                                                                                        func (SoftwareToUpdate) Values

                                                                                                                          Values returns all known values for SoftwareToUpdate. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                          type Subscription

                                                                                                                          type Subscription struct {
                                                                                                                          
                                                                                                                          	// 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:_-]+”.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Id *string
                                                                                                                          
                                                                                                                          	// 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'.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Source *string
                                                                                                                          
                                                                                                                          	// The MQTT topic used to route the message.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Subject *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'.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Target *string
                                                                                                                          }

                                                                                                                            Information about a subscription.

                                                                                                                            type SubscriptionDefinitionVersion

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

                                                                                                                              Information about a subscription definition version.

                                                                                                                              type Telemetry

                                                                                                                              type Telemetry string
                                                                                                                              const (
                                                                                                                              	TelemetryOn  Telemetry = "On"
                                                                                                                              	TelemetryOff Telemetry = "Off"
                                                                                                                              )

                                                                                                                                Enum values for Telemetry

                                                                                                                                func (Telemetry) Values

                                                                                                                                func (Telemetry) Values() []Telemetry

                                                                                                                                  Values returns all known values for Telemetry. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                  type TelemetryConfiguration

                                                                                                                                  type TelemetryConfiguration struct {
                                                                                                                                  
                                                                                                                                  	// Configure telemetry to be on or off.
                                                                                                                                  	//
                                                                                                                                  	// This member is required.
                                                                                                                                  	Telemetry Telemetry
                                                                                                                                  
                                                                                                                                  	// Synchronization status of the device reported configuration with the desired
                                                                                                                                  	// configuration.
                                                                                                                                  	ConfigurationSyncStatus ConfigurationSyncStatus
                                                                                                                                  }

                                                                                                                                    Configuration settings for running telemetry.

                                                                                                                                    type TelemetryConfigurationUpdate

                                                                                                                                    type TelemetryConfigurationUpdate struct {
                                                                                                                                    
                                                                                                                                    	// Configure telemetry to be on or off.
                                                                                                                                    	//
                                                                                                                                    	// This member is required.
                                                                                                                                    	Telemetry Telemetry
                                                                                                                                    }

                                                                                                                                      Configuration settings for running telemetry.

                                                                                                                                      type UpdateAgentLogLevel

                                                                                                                                      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"
                                                                                                                                      )

                                                                                                                                        Enum values for UpdateAgentLogLevel

                                                                                                                                        func (UpdateAgentLogLevel) Values

                                                                                                                                          Values returns all known values for UpdateAgentLogLevel. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                          type UpdateTargetsArchitecture

                                                                                                                                          type UpdateTargetsArchitecture string
                                                                                                                                          const (
                                                                                                                                          	UpdateTargetsArchitectureArmv6l  UpdateTargetsArchitecture = "armv6l"
                                                                                                                                          	UpdateTargetsArchitectureArmv7l  UpdateTargetsArchitecture = "armv7l"
                                                                                                                                          	UpdateTargetsArchitectureX8664   UpdateTargetsArchitecture = "x86_64"
                                                                                                                                          	UpdateTargetsArchitectureAarch64 UpdateTargetsArchitecture = "aarch64"
                                                                                                                                          )

                                                                                                                                            Enum values for UpdateTargetsArchitecture

                                                                                                                                            func (UpdateTargetsArchitecture) Values

                                                                                                                                              Values returns all known values for UpdateTargetsArchitecture. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                              type UpdateTargetsOperatingSystem

                                                                                                                                              type UpdateTargetsOperatingSystem string
                                                                                                                                              const (
                                                                                                                                              	UpdateTargetsOperatingSystemUbuntu      UpdateTargetsOperatingSystem = "ubuntu"
                                                                                                                                              	UpdateTargetsOperatingSystemRaspbian    UpdateTargetsOperatingSystem = "raspbian"
                                                                                                                                              	UpdateTargetsOperatingSystemAmazonLinux UpdateTargetsOperatingSystem = "amazon_linux"
                                                                                                                                              	UpdateTargetsOperatingSystemOpenwrt     UpdateTargetsOperatingSystem = "openwrt"
                                                                                                                                              )

                                                                                                                                                Enum values for UpdateTargetsOperatingSystem

                                                                                                                                                func (UpdateTargetsOperatingSystem) Values

                                                                                                                                                  Values returns all known values for UpdateTargetsOperatingSystem. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                  type VersionInformation

                                                                                                                                                  type VersionInformation struct {
                                                                                                                                                  
                                                                                                                                                  	// The ARN of the version.
                                                                                                                                                  	Arn *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 ID of the version.
                                                                                                                                                  	Version *string
                                                                                                                                                  }

                                                                                                                                                    Information about a version.