Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessPointAlreadyExists

type AccessPointAlreadyExists struct {
	Message *string

	ErrorCode_    *string
	AccessPointId *string
}

    Returned if the access point you are trying to create already exists, with the creation token you provided in the request.

    func (*AccessPointAlreadyExists) Error

    func (e *AccessPointAlreadyExists) Error() string

    func (*AccessPointAlreadyExists) ErrorCode

    func (e *AccessPointAlreadyExists) ErrorCode() string

    func (*AccessPointAlreadyExists) ErrorFault

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

    func (*AccessPointAlreadyExists) ErrorMessage

    func (e *AccessPointAlreadyExists) ErrorMessage() string

    type AccessPointDescription

    type AccessPointDescription struct {
    
    	// The unique Amazon Resource Name (ARN) associated with the access point.
    	AccessPointArn *string
    
    	// The ID of the access point, assigned by Amazon EFS.
    	AccessPointId *string
    
    	// The opaque string specified in the request to ensure idempotent creation.
    	ClientToken *string
    
    	// The ID of the EFS file system that the access point applies to.
    	FileSystemId *string
    
    	// Identifies the lifecycle phase of the access point.
    	LifeCycleState LifeCycleState
    
    	// The name of the access point. This is the value of the Name tag.
    	Name *string
    
    	// Identified the AWS account that owns the access point resource.
    	OwnerId *string
    
    	// The full POSIX identity, including the user ID, group ID, and secondary group
    	// IDs on the access point that is used for all file operations by NFS clients
    	// using the access point.
    	PosixUser *PosixUser
    
    	// The directory on the Amazon EFS file system that the access point exposes as the
    	// root directory to NFS clients using the access point.
    	RootDirectory *RootDirectory
    
    	// The tags associated with the access point, presented as an array of Tag objects.
    	Tags []Tag
    }

      Provides a description of an EFS file system access point.

      type AccessPointLimitExceeded

      type AccessPointLimitExceeded struct {
      	Message *string
      
      	ErrorCode_ *string
      }

        Returned if the AWS account has already created the maximum number of access points allowed per file system.

        func (*AccessPointLimitExceeded) Error

        func (e *AccessPointLimitExceeded) Error() string

        func (*AccessPointLimitExceeded) ErrorCode

        func (e *AccessPointLimitExceeded) ErrorCode() string

        func (*AccessPointLimitExceeded) ErrorFault

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

        func (*AccessPointLimitExceeded) ErrorMessage

        func (e *AccessPointLimitExceeded) ErrorMessage() string

        type AccessPointNotFound

        type AccessPointNotFound struct {
        	Message *string
        
        	ErrorCode_ *string
        }

          Returned if the specified AccessPointId value doesn't exist in the requester's AWS account.

          func (*AccessPointNotFound) Error

          func (e *AccessPointNotFound) Error() string

          func (*AccessPointNotFound) ErrorCode

          func (e *AccessPointNotFound) ErrorCode() string

          func (*AccessPointNotFound) ErrorFault

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

          func (*AccessPointNotFound) ErrorMessage

          func (e *AccessPointNotFound) ErrorMessage() string

          type BackupPolicy

          type BackupPolicy struct {
          
          	// Describes the status of the file system's backup policy.
          	//
          	// * ENABLED - EFS is
          	// automatically backing up the file system.
          	//
          	// * ENABLING - EFS is turning on
          	// automatic backups for the file system.
          	//
          	// * DISABLED - automatic back ups are
          	// turned off for the file system.
          	//
          	// * DISABLED - EFS is turning off automatic
          	// backups for the file system.
          	//
          	// This member is required.
          	Status Status
          }

            The backup policy for the file system, showing the curent status. If ENABLED, the file system is being backed up.

            type BadRequest

            type BadRequest struct {
            	Message *string
            
            	ErrorCode_ *string
            }

              Returned if the request is malformed or contains an error such as an invalid parameter value or a missing required parameter.

              func (*BadRequest) Error

              func (e *BadRequest) Error() string

              func (*BadRequest) ErrorCode

              func (e *BadRequest) ErrorCode() string

              func (*BadRequest) ErrorFault

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

              func (*BadRequest) ErrorMessage

              func (e *BadRequest) ErrorMessage() string

              type CreationInfo

              type CreationInfo struct {
              
              	// Specifies the POSIX group ID to apply to the RootDirectory. Accepts values from
              	// 0 to 2^32 (4294967295).
              	//
              	// This member is required.
              	OwnerGid *int64
              
              	// Specifies the POSIX user ID to apply to the RootDirectory. Accepts values from 0
              	// to 2^32 (4294967295).
              	//
              	// This member is required.
              	OwnerUid *int64
              
              	// Specifies the POSIX permissions to apply to the RootDirectory, in the format of
              	// an octal number representing the file's mode bits.
              	//
              	// This member is required.
              	Permissions *string
              }

                Required if the RootDirectory > Path specified does not exist. Specifies the POSIX IDs and permissions to apply to the access point's RootDirectory > Path. If the access point root directory does not exist, EFS creates it with these settings when a client connects to the access point. When specifying CreationInfo, you must include values for all properties. If you do not provide CreationInfo and the specified RootDirectory does not exist, attempts to mount the file system using the access point will fail.

                type DependencyTimeout

                type DependencyTimeout struct {
                	Message *string
                
                	ErrorCode_ *string
                }

                  The service timed out trying to fulfill the request, and the client should try the call again.

                  func (*DependencyTimeout) Error

                  func (e *DependencyTimeout) Error() string

                  func (*DependencyTimeout) ErrorCode

                  func (e *DependencyTimeout) ErrorCode() string

                  func (*DependencyTimeout) ErrorFault

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

                  func (*DependencyTimeout) ErrorMessage

                  func (e *DependencyTimeout) ErrorMessage() string

                  type FileSystemAlreadyExists

                  type FileSystemAlreadyExists struct {
                  	Message *string
                  
                  	ErrorCode_   *string
                  	FileSystemId *string
                  }

                    Returned if the file system you are trying to create already exists, with the creation token you provided.

                    func (*FileSystemAlreadyExists) Error

                    func (e *FileSystemAlreadyExists) Error() string

                    func (*FileSystemAlreadyExists) ErrorCode

                    func (e *FileSystemAlreadyExists) ErrorCode() string

                    func (*FileSystemAlreadyExists) ErrorFault

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

                    func (*FileSystemAlreadyExists) ErrorMessage

                    func (e *FileSystemAlreadyExists) ErrorMessage() string

                    type FileSystemDescription

                    type FileSystemDescription struct {
                    
                    	// The time that the file system was created, in seconds (since
                    	// 1970-01-01T00:00:00Z).
                    	//
                    	// This member is required.
                    	CreationTime *time.Time
                    
                    	// The opaque string specified in the request.
                    	//
                    	// This member is required.
                    	CreationToken *string
                    
                    	// The ID of the file system, assigned by Amazon EFS.
                    	//
                    	// This member is required.
                    	FileSystemId *string
                    
                    	// The lifecycle phase of the file system.
                    	//
                    	// This member is required.
                    	LifeCycleState LifeCycleState
                    
                    	// The current number of mount targets that the file system has. For more
                    	// information, see CreateMountTarget.
                    	//
                    	// This member is required.
                    	NumberOfMountTargets int32
                    
                    	// The AWS account that created the file system. If the file system was created by
                    	// an IAM user, the parent account to which the user belongs is the owner.
                    	//
                    	// This member is required.
                    	OwnerId *string
                    
                    	// The performance mode of the file system.
                    	//
                    	// This member is required.
                    	PerformanceMode PerformanceMode
                    
                    	// The latest known metered size (in bytes) of data stored in the file system, in
                    	// its Value field, and the time at which that size was determined in its Timestamp
                    	// field. The Timestamp value is the integer number of seconds since
                    	// 1970-01-01T00:00:00Z. The SizeInBytes value doesn't represent the size of a
                    	// consistent snapshot of the file system, but it is eventually consistent when
                    	// there are no writes to the file system. That is, SizeInBytes represents actual
                    	// size only if the file system is not modified for a period longer than a couple
                    	// of hours. Otherwise, the value is not the exact size that the file system was at
                    	// any point in time.
                    	//
                    	// This member is required.
                    	SizeInBytes *FileSystemSize
                    
                    	// The tags associated with the file system, presented as an array of Tag objects.
                    	//
                    	// This member is required.
                    	Tags []Tag
                    
                    	// A Boolean value that, if true, indicates that the file system is encrypted.
                    	Encrypted *bool
                    
                    	// The Amazon Resource Name (ARN) for the EFS file system, in the format
                    	// arn:aws:elasticfilesystem:region:account-id:file-system/file-system-id . Example
                    	// with sample data:
                    	// arn:aws:elasticfilesystem:us-west-2:1111333322228888:file-system/fs-01234567
                    	FileSystemArn *string
                    
                    	// The ID of an AWS Key Management Service (AWS KMS) customer master key (CMK) that
                    	// was used to protect the encrypted file system.
                    	KmsKeyId *string
                    
                    	// You can add tags to a file system, including a Name tag. For more information,
                    	// see CreateFileSystem. If the file system has a Name tag, Amazon EFS returns the
                    	// value in this field.
                    	Name *string
                    
                    	// The throughput, measured in MiB/s, that you want to provision for a file system.
                    	// Valid values are 1-1024. Required if ThroughputMode is set to provisioned. The
                    	// limit on throughput is 1024 MiB/s. You can get these limits increased by
                    	// contacting AWS Support. For more information, see Amazon EFS Limits That You Can
                    	// Increase (https://docs.aws.amazon.com/efs/latest/ug/limits.html#soft-limits) in
                    	// the Amazon EFS User Guide.
                    	ProvisionedThroughputInMibps *float64
                    
                    	// The throughput mode for a file system. There are two throughput modes to choose
                    	// from for your file system: bursting and provisioned. If you set ThroughputMode
                    	// to provisioned, you must also set a value for ProvisionedThroughPutInMibps. You
                    	// can decrease your file system's throughput in Provisioned Throughput mode or
                    	// change between the throughput modes as long as it’s been more than 24 hours
                    	// since the last decrease or throughput mode change.
                    	ThroughputMode ThroughputMode
                    }

                      A description of the file system.

                      type FileSystemInUse

                      type FileSystemInUse struct {
                      	Message *string
                      
                      	ErrorCode_ *string
                      }

                        Returned if a file system has mount targets.

                        func (*FileSystemInUse) Error

                        func (e *FileSystemInUse) Error() string

                        func (*FileSystemInUse) ErrorCode

                        func (e *FileSystemInUse) ErrorCode() string

                        func (*FileSystemInUse) ErrorFault

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

                        func (*FileSystemInUse) ErrorMessage

                        func (e *FileSystemInUse) ErrorMessage() string

                        type FileSystemLimitExceeded

                        type FileSystemLimitExceeded struct {
                        	Message *string
                        
                        	ErrorCode_ *string
                        }

                          Returned if the AWS account has already created the maximum number of file systems allowed per account.

                          func (*FileSystemLimitExceeded) Error

                          func (e *FileSystemLimitExceeded) Error() string

                          func (*FileSystemLimitExceeded) ErrorCode

                          func (e *FileSystemLimitExceeded) ErrorCode() string

                          func (*FileSystemLimitExceeded) ErrorFault

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

                          func (*FileSystemLimitExceeded) ErrorMessage

                          func (e *FileSystemLimitExceeded) ErrorMessage() string

                          type FileSystemNotFound

                          type FileSystemNotFound struct {
                          	Message *string
                          
                          	ErrorCode_ *string
                          }

                            Returned if the specified FileSystemId value doesn't exist in the requester's AWS account.

                            func (*FileSystemNotFound) Error

                            func (e *FileSystemNotFound) Error() string

                            func (*FileSystemNotFound) ErrorCode

                            func (e *FileSystemNotFound) ErrorCode() string

                            func (*FileSystemNotFound) ErrorFault

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

                            func (*FileSystemNotFound) ErrorMessage

                            func (e *FileSystemNotFound) ErrorMessage() string

                            type FileSystemSize

                            type FileSystemSize struct {
                            
                            	// The latest known metered size (in bytes) of data stored in the file system.
                            	//
                            	// This member is required.
                            	Value int64
                            
                            	// The time at which the size of data, returned in the Value field, was determined.
                            	// The value is the integer number of seconds since 1970-01-01T00:00:00Z.
                            	Timestamp *time.Time
                            
                            	// The latest known metered size (in bytes) of data stored in the Infrequent Access
                            	// storage class.
                            	ValueInIA *int64
                            
                            	// The latest known metered size (in bytes) of data stored in the Standard storage
                            	// class.
                            	ValueInStandard *int64
                            }

                              The latest known metered size (in bytes) of data stored in the file system, in its Value field, and the time at which that size was determined in its Timestamp field. The value doesn't represent the size of a consistent snapshot of the file system, but it is eventually consistent when there are no writes to the file system. That is, the value represents the actual size only if the file system is not modified for a period longer than a couple of hours. Otherwise, the value is not necessarily the exact size the file system was at any instant in time.

                              type IncorrectFileSystemLifeCycleState

                              type IncorrectFileSystemLifeCycleState struct {
                              	Message *string
                              
                              	ErrorCode_ *string
                              }

                                Returned if the file system's lifecycle state is not "available".

                                func (*IncorrectFileSystemLifeCycleState) Error

                                func (*IncorrectFileSystemLifeCycleState) ErrorCode

                                func (*IncorrectFileSystemLifeCycleState) ErrorFault

                                func (*IncorrectFileSystemLifeCycleState) ErrorMessage

                                func (e *IncorrectFileSystemLifeCycleState) ErrorMessage() string

                                type IncorrectMountTargetState

                                type IncorrectMountTargetState struct {
                                	Message *string
                                
                                	ErrorCode_ *string
                                }

                                  Returned if the mount target is not in the correct state for the operation.

                                  func (*IncorrectMountTargetState) Error

                                  func (e *IncorrectMountTargetState) Error() string

                                  func (*IncorrectMountTargetState) ErrorCode

                                  func (e *IncorrectMountTargetState) ErrorCode() string

                                  func (*IncorrectMountTargetState) ErrorFault

                                  func (*IncorrectMountTargetState) ErrorMessage

                                  func (e *IncorrectMountTargetState) ErrorMessage() string

                                  type InsufficientThroughputCapacity

                                  type InsufficientThroughputCapacity struct {
                                  	Message *string
                                  
                                  	ErrorCode_ *string
                                  }

                                    Returned if there's not enough capacity to provision additional throughput. This value might be returned when you try to create a file system in provisioned throughput mode, when you attempt to increase the provisioned throughput of an existing file system, or when you attempt to change an existing file system from bursting to provisioned throughput mode.

                                    func (*InsufficientThroughputCapacity) Error

                                    func (*InsufficientThroughputCapacity) ErrorCode

                                    func (e *InsufficientThroughputCapacity) ErrorCode() string

                                    func (*InsufficientThroughputCapacity) ErrorFault

                                    func (*InsufficientThroughputCapacity) ErrorMessage

                                    func (e *InsufficientThroughputCapacity) ErrorMessage() string

                                    type InternalServerError

                                    type InternalServerError struct {
                                    	Message *string
                                    
                                    	ErrorCode_ *string
                                    }

                                      Returned if an error occurred on the server side.

                                      func (*InternalServerError) Error

                                      func (e *InternalServerError) Error() string

                                      func (*InternalServerError) ErrorCode

                                      func (e *InternalServerError) ErrorCode() string

                                      func (*InternalServerError) ErrorFault

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

                                      func (*InternalServerError) ErrorMessage

                                      func (e *InternalServerError) ErrorMessage() string

                                      type InvalidPolicyException

                                      type InvalidPolicyException struct {
                                      	Message *string
                                      
                                      	ErrorCode_ *string
                                      }

                                        Returned if the FileSystemPolicy is is malformed or contains an error such as an invalid parameter value or a missing required parameter. Returned in the case of a policy lockout safety check error.

                                        func (*InvalidPolicyException) Error

                                        func (e *InvalidPolicyException) Error() string

                                        func (*InvalidPolicyException) ErrorCode

                                        func (e *InvalidPolicyException) ErrorCode() string

                                        func (*InvalidPolicyException) ErrorFault

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

                                        func (*InvalidPolicyException) ErrorMessage

                                        func (e *InvalidPolicyException) ErrorMessage() string

                                        type IpAddressInUse

                                        type IpAddressInUse struct {
                                        	Message *string
                                        
                                        	ErrorCode_ *string
                                        }

                                          Returned if the request specified an IpAddress that is already in use in the subnet.

                                          func (*IpAddressInUse) Error

                                          func (e *IpAddressInUse) Error() string

                                          func (*IpAddressInUse) ErrorCode

                                          func (e *IpAddressInUse) ErrorCode() string

                                          func (*IpAddressInUse) ErrorFault

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

                                          func (*IpAddressInUse) ErrorMessage

                                          func (e *IpAddressInUse) ErrorMessage() string

                                          type LifeCycleState

                                          type LifeCycleState string
                                          const (
                                          	LifeCycleStateCreating  LifeCycleState = "creating"
                                          	LifeCycleStateAvailable LifeCycleState = "available"
                                          	LifeCycleStateUpdating  LifeCycleState = "updating"
                                          	LifeCycleStateDeleting  LifeCycleState = "deleting"
                                          	LifeCycleStateDeleted   LifeCycleState = "deleted"
                                          )

                                            Enum values for LifeCycleState

                                            func (LifeCycleState) Values

                                            func (LifeCycleState) Values() []LifeCycleState

                                              Values returns all known values for LifeCycleState. 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 LifecyclePolicy

                                              type LifecyclePolicy struct {
                                              
                                              	// A value that describes the period of time that a file is not accessed, after
                                              	// which it transitions to the IA storage class. Metadata operations such as
                                              	// listing the contents of a directory don't count as file access events.
                                              	TransitionToIA TransitionToIARules
                                              }

                                                Describes a policy used by EFS lifecycle management to transition files to the Infrequent Access (IA) storage class.

                                                type MountTargetConflict

                                                type MountTargetConflict struct {
                                                	Message *string
                                                
                                                	ErrorCode_ *string
                                                }

                                                  Returned if the mount target would violate one of the specified restrictions based on the file system's existing mount targets.

                                                  func (*MountTargetConflict) Error

                                                  func (e *MountTargetConflict) Error() string

                                                  func (*MountTargetConflict) ErrorCode

                                                  func (e *MountTargetConflict) ErrorCode() string

                                                  func (*MountTargetConflict) ErrorFault

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

                                                  func (*MountTargetConflict) ErrorMessage

                                                  func (e *MountTargetConflict) ErrorMessage() string

                                                  type MountTargetDescription

                                                  type MountTargetDescription struct {
                                                  
                                                  	// The ID of the file system for which the mount target is intended.
                                                  	//
                                                  	// This member is required.
                                                  	FileSystemId *string
                                                  
                                                  	// Lifecycle state of the mount target.
                                                  	//
                                                  	// This member is required.
                                                  	LifeCycleState LifeCycleState
                                                  
                                                  	// System-assigned mount target ID.
                                                  	//
                                                  	// This member is required.
                                                  	MountTargetId *string
                                                  
                                                  	// The ID of the mount target's subnet.
                                                  	//
                                                  	// This member is required.
                                                  	SubnetId *string
                                                  
                                                  	// The unique and consistent identifier of the Availability Zone (AZ) that the
                                                  	// mount target resides in. For example, use1-az1 is an AZ ID for the us-east-1
                                                  	// Region and it has the same location in every AWS account.
                                                  	AvailabilityZoneId *string
                                                  
                                                  	// The name of the Availability Zone (AZ) that the mount target resides in. AZs are
                                                  	// independently mapped to names for each AWS account. For example, the
                                                  	// Availability Zone us-east-1a for your AWS account might not be the same location
                                                  	// as us-east-1a for another AWS account.
                                                  	AvailabilityZoneName *string
                                                  
                                                  	// Address at which the file system can be mounted by using the mount target.
                                                  	IpAddress *string
                                                  
                                                  	// The ID of the network interface that Amazon EFS created when it created the
                                                  	// mount target.
                                                  	NetworkInterfaceId *string
                                                  
                                                  	// AWS account ID that owns the resource.
                                                  	OwnerId *string
                                                  
                                                  	// The Virtual Private Cloud (VPC) ID that the mount target is configured in.
                                                  	VpcId *string
                                                  }

                                                    Provides a description of a mount target.

                                                    type MountTargetNotFound

                                                    type MountTargetNotFound struct {
                                                    	Message *string
                                                    
                                                    	ErrorCode_ *string
                                                    }

                                                      Returned if there is no mount target with the specified ID found in the caller's account.

                                                      func (*MountTargetNotFound) Error

                                                      func (e *MountTargetNotFound) Error() string

                                                      func (*MountTargetNotFound) ErrorCode

                                                      func (e *MountTargetNotFound) ErrorCode() string

                                                      func (*MountTargetNotFound) ErrorFault

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

                                                      func (*MountTargetNotFound) ErrorMessage

                                                      func (e *MountTargetNotFound) ErrorMessage() string

                                                      type NetworkInterfaceLimitExceeded

                                                      type NetworkInterfaceLimitExceeded struct {
                                                      	Message *string
                                                      
                                                      	ErrorCode_ *string
                                                      }

                                                        The calling account has reached the limit for elastic network interfaces for the specific AWS Region. The client should try to delete some elastic network interfaces or get the account limit raised. For more information, see Amazon VPC Limits (https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Appendix_Limits.html) in the Amazon VPC User Guide (see the Network interfaces per VPC entry in the table).

                                                        func (*NetworkInterfaceLimitExceeded) Error

                                                        func (*NetworkInterfaceLimitExceeded) ErrorCode

                                                        func (e *NetworkInterfaceLimitExceeded) ErrorCode() string

                                                        func (*NetworkInterfaceLimitExceeded) ErrorFault

                                                        func (*NetworkInterfaceLimitExceeded) ErrorMessage

                                                        func (e *NetworkInterfaceLimitExceeded) ErrorMessage() string

                                                        type NoFreeAddressesInSubnet

                                                        type NoFreeAddressesInSubnet struct {
                                                        	Message *string
                                                        
                                                        	ErrorCode_ *string
                                                        }

                                                          Returned if IpAddress was not specified in the request and there are no free IP addresses in the subnet.

                                                          func (*NoFreeAddressesInSubnet) Error

                                                          func (e *NoFreeAddressesInSubnet) Error() string

                                                          func (*NoFreeAddressesInSubnet) ErrorCode

                                                          func (e *NoFreeAddressesInSubnet) ErrorCode() string

                                                          func (*NoFreeAddressesInSubnet) ErrorFault

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

                                                          func (*NoFreeAddressesInSubnet) ErrorMessage

                                                          func (e *NoFreeAddressesInSubnet) ErrorMessage() string

                                                          type PerformanceMode

                                                          type PerformanceMode string
                                                          const (
                                                          	PerformanceModeGeneralPurpose PerformanceMode = "generalPurpose"
                                                          	PerformanceModeMaxIo          PerformanceMode = "maxIO"
                                                          )

                                                            Enum values for PerformanceMode

                                                            func (PerformanceMode) Values

                                                            func (PerformanceMode) Values() []PerformanceMode

                                                              Values returns all known values for PerformanceMode. 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 PolicyNotFound

                                                              type PolicyNotFound struct {
                                                              	Message *string
                                                              
                                                              	ErrorCode_ *string
                                                              }

                                                                Returned if the default file system policy is in effect for the EFS file system specified.

                                                                func (*PolicyNotFound) Error

                                                                func (e *PolicyNotFound) Error() string

                                                                func (*PolicyNotFound) ErrorCode

                                                                func (e *PolicyNotFound) ErrorCode() string

                                                                func (*PolicyNotFound) ErrorFault

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

                                                                func (*PolicyNotFound) ErrorMessage

                                                                func (e *PolicyNotFound) ErrorMessage() string

                                                                type PosixUser

                                                                type PosixUser struct {
                                                                
                                                                	// The POSIX group ID used for all file system operations using this access point.
                                                                	//
                                                                	// This member is required.
                                                                	Gid *int64
                                                                
                                                                	// The POSIX user ID used for all file system operations using this access point.
                                                                	//
                                                                	// This member is required.
                                                                	Uid *int64
                                                                
                                                                	// Secondary POSIX group IDs used for all file system operations using this access
                                                                	// point.
                                                                	SecondaryGids []int64
                                                                }

                                                                  The full POSIX identity, including the user ID, group ID, and any secondary group IDs, on the access point that is used for all file system operations performed by NFS clients using the access point.

                                                                  type RootDirectory

                                                                  type RootDirectory struct {
                                                                  
                                                                  	// (Optional) Specifies the POSIX IDs and permissions to apply to the access
                                                                  	// point's RootDirectory. If the RootDirectory > Path specified does not exist, EFS
                                                                  	// creates the root directory using the CreationInfo settings when a client
                                                                  	// connects to an access point. When specifying the CreationInfo, you must provide
                                                                  	// values for all properties. If you do not provide CreationInfo and the specified
                                                                  	// RootDirectory > Path does not exist, attempts to mount the file system using the
                                                                  	// access point will fail.
                                                                  	CreationInfo *CreationInfo
                                                                  
                                                                  	// Specifies the path on the EFS file system to expose as the root directory to NFS
                                                                  	// clients using the access point to access the EFS file system. A path can have up
                                                                  	// to four subdirectories. If the specified path does not exist, you are required
                                                                  	// to provide the CreationInfo.
                                                                  	Path *string
                                                                  }

                                                                    Specifies the directory on the Amazon EFS file system that the access point provides access to. The access point exposes the specified file system path as the root directory of your file system to applications using the access point. NFS clients using the access point can only access data in the access point's RootDirectory and it's subdirectories.

                                                                    type SecurityGroupLimitExceeded

                                                                    type SecurityGroupLimitExceeded struct {
                                                                    	Message *string
                                                                    
                                                                    	ErrorCode_ *string
                                                                    }

                                                                      Returned if the size of SecurityGroups specified in the request is greater than five.

                                                                      func (*SecurityGroupLimitExceeded) Error

                                                                      func (*SecurityGroupLimitExceeded) ErrorCode

                                                                      func (e *SecurityGroupLimitExceeded) ErrorCode() string

                                                                      func (*SecurityGroupLimitExceeded) ErrorFault

                                                                      func (*SecurityGroupLimitExceeded) ErrorMessage

                                                                      func (e *SecurityGroupLimitExceeded) ErrorMessage() string

                                                                      type SecurityGroupNotFound

                                                                      type SecurityGroupNotFound struct {
                                                                      	Message *string
                                                                      
                                                                      	ErrorCode_ *string
                                                                      }

                                                                        Returned if one of the specified security groups doesn't exist in the subnet's VPC.

                                                                        func (*SecurityGroupNotFound) Error

                                                                        func (e *SecurityGroupNotFound) Error() string

                                                                        func (*SecurityGroupNotFound) ErrorCode

                                                                        func (e *SecurityGroupNotFound) ErrorCode() string

                                                                        func (*SecurityGroupNotFound) ErrorFault

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

                                                                        func (*SecurityGroupNotFound) ErrorMessage

                                                                        func (e *SecurityGroupNotFound) ErrorMessage() string

                                                                        type Status

                                                                        type Status string
                                                                        const (
                                                                        	StatusEnabled   Status = "ENABLED"
                                                                        	StatusEnabling  Status = "ENABLING"
                                                                        	StatusDisabled  Status = "DISABLED"
                                                                        	StatusDisabling Status = "DISABLING"
                                                                        )

                                                                          Enum values for Status

                                                                          func (Status) Values

                                                                          func (Status) Values() []Status

                                                                            Values returns all known values for Status. 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 SubnetNotFound

                                                                            type SubnetNotFound struct {
                                                                            	Message *string
                                                                            
                                                                            	ErrorCode_ *string
                                                                            }

                                                                              Returned if there is no subnet with ID SubnetId provided in the request.

                                                                              func (*SubnetNotFound) Error

                                                                              func (e *SubnetNotFound) Error() string

                                                                              func (*SubnetNotFound) ErrorCode

                                                                              func (e *SubnetNotFound) ErrorCode() string

                                                                              func (*SubnetNotFound) ErrorFault

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

                                                                              func (*SubnetNotFound) ErrorMessage

                                                                              func (e *SubnetNotFound) ErrorMessage() string

                                                                              type Tag

                                                                              type Tag struct {
                                                                              
                                                                              	// The tag key (String). The key can't start with aws:.
                                                                              	//
                                                                              	// This member is required.
                                                                              	Key *string
                                                                              
                                                                              	// The value of the tag key.
                                                                              	//
                                                                              	// This member is required.
                                                                              	Value *string
                                                                              }

                                                                                A tag is a key-value pair. Allowed characters are letters, white space, and numbers that can be represented in UTF-8, and the following characters: + - = . _ : /

                                                                                type ThroughputLimitExceeded

                                                                                type ThroughputLimitExceeded struct {
                                                                                	Message *string
                                                                                
                                                                                	ErrorCode_ *string
                                                                                }

                                                                                  Returned if the throughput mode or amount of provisioned throughput can't be changed because the throughput limit of 1024 MiB/s has been reached.

                                                                                  func (*ThroughputLimitExceeded) Error

                                                                                  func (e *ThroughputLimitExceeded) Error() string

                                                                                  func (*ThroughputLimitExceeded) ErrorCode

                                                                                  func (e *ThroughputLimitExceeded) ErrorCode() string

                                                                                  func (*ThroughputLimitExceeded) ErrorFault

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

                                                                                  func (*ThroughputLimitExceeded) ErrorMessage

                                                                                  func (e *ThroughputLimitExceeded) ErrorMessage() string

                                                                                  type ThroughputMode

                                                                                  type ThroughputMode string
                                                                                  const (
                                                                                  	ThroughputModeBursting    ThroughputMode = "bursting"
                                                                                  	ThroughputModeProvisioned ThroughputMode = "provisioned"
                                                                                  )

                                                                                    Enum values for ThroughputMode

                                                                                    func (ThroughputMode) Values

                                                                                    func (ThroughputMode) Values() []ThroughputMode

                                                                                      Values returns all known values for ThroughputMode. 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 TooManyRequests

                                                                                      type TooManyRequests struct {
                                                                                      	Message *string
                                                                                      
                                                                                      	ErrorCode_ *string
                                                                                      }

                                                                                        Returned if you don’t wait at least 24 hours before changing the throughput mode, or decreasing the Provisioned Throughput value.

                                                                                        func (*TooManyRequests) Error

                                                                                        func (e *TooManyRequests) Error() string

                                                                                        func (*TooManyRequests) ErrorCode

                                                                                        func (e *TooManyRequests) ErrorCode() string

                                                                                        func (*TooManyRequests) ErrorFault

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

                                                                                        func (*TooManyRequests) ErrorMessage

                                                                                        func (e *TooManyRequests) ErrorMessage() string

                                                                                        type TransitionToIARules

                                                                                        type TransitionToIARules string
                                                                                        const (
                                                                                        	TransitionToIARulesAfter7Days  TransitionToIARules = "AFTER_7_DAYS"
                                                                                        	TransitionToIARulesAfter14Days TransitionToIARules = "AFTER_14_DAYS"
                                                                                        	TransitionToIARulesAfter30Days TransitionToIARules = "AFTER_30_DAYS"
                                                                                        	TransitionToIARulesAfter60Days TransitionToIARules = "AFTER_60_DAYS"
                                                                                        	TransitionToIARulesAfter90Days TransitionToIARules = "AFTER_90_DAYS"
                                                                                        )

                                                                                          Enum values for TransitionToIARules

                                                                                          func (TransitionToIARules) Values

                                                                                            Values returns all known values for TransitionToIARules. 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 UnsupportedAvailabilityZone

                                                                                            type UnsupportedAvailabilityZone struct {
                                                                                            	Message *string
                                                                                            
                                                                                            	ErrorCode_ *string
                                                                                            }

                                                                                            func (*UnsupportedAvailabilityZone) Error

                                                                                            func (*UnsupportedAvailabilityZone) ErrorCode

                                                                                            func (e *UnsupportedAvailabilityZone) ErrorCode() string

                                                                                            func (*UnsupportedAvailabilityZone) ErrorFault

                                                                                            func (*UnsupportedAvailabilityZone) ErrorMessage

                                                                                            func (e *UnsupportedAvailabilityZone) ErrorMessage() string

                                                                                            type ValidationException

                                                                                            type ValidationException struct {
                                                                                            	Message *string
                                                                                            
                                                                                            	ErrorCode_ *string
                                                                                            }

                                                                                              Returned if the AWS Backup service is not available in the region that the request was made.

                                                                                              func (*ValidationException) Error

                                                                                              func (e *ValidationException) Error() string

                                                                                              func (*ValidationException) ErrorCode

                                                                                              func (e *ValidationException) ErrorCode() string

                                                                                              func (*ValidationException) ErrorFault

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

                                                                                              func (*ValidationException) ErrorMessage

                                                                                              func (e *ValidationException) ErrorMessage() string