v1alpha1

type AccessPoint struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              AccessPointSpec   `json:"spec,omitempty"`
	Status            AccessPointStatus `json:"status,omitempty"`
}

type AccessPointDescription struct {
	AccessPointARN *string `json:"accessPointARN,omitempty"`
	AccessPointID  *string `json:"accessPointID,omitempty"`
	FileSystemID   *string `json:"fileSystemID,omitempty"`
	LifeCycleState *string `json:"lifeCycleState,omitempty"`
	Name           *string `json:"name,omitempty"`
	OwnerID        *string `json:"ownerID,omitempty"`
	// 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.
	PosixUser *PosixUser `json:"posixUser,omitempty"`
	// 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.
	RootDirectory *RootDirectory `json:"rootDirectory,omitempty"`
	Tags          []*Tag         `json:"tags,omitempty"`
}

type AccessPointList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []AccessPoint `json:"items"`
}

type AccessPointSpec struct {

	// The ID of the EFS file system that the access point provides access to.
	FileSystemID  *string                                  `json:"fileSystemID,omitempty"`
	FileSystemRef *ackv1alpha1.AWSResourceReferenceWrapper `json:"fileSystemRef,omitempty"`
	// The operating system user and group applied to all file system requests made
	// using the access point.
	PosixUser *PosixUser `json:"posixUser,omitempty"`
	// Specifies the directory on the EFS file system that the access point exposes
	// as the root directory of your file system to NFS clients using the access
	// point. The clients using the access point can only access the root directory
	// and below. If the RootDirectory > Path specified does not exist, Amazon EFS
	// creates it and applies the CreationInfo settings when a client connects to
	// an access point. When specifying a RootDirectory, you must provide the Path,
	// and the CreationInfo.
	//
	// Amazon EFS creates a root directory only if you have provided the CreationInfo:
	// OwnUid, OwnGID, and permissions for the directory. If you do not provide
	// this information, Amazon EFS does not create the root directory. If the root
	// directory does not exist, attempts to mount using the access point will fail.
	RootDirectory *RootDirectory `json:"rootDirectory,omitempty"`
	// Creates tags associated with the access point. Each tag is a key-value pair,
	// each key must be unique. For more information, see Tagging Amazon Web Services
	// resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)
	// in the Amazon Web Services General Reference Guide.
	Tags []*Tag `json:"tags,omitempty"`
}

type AccessPointStatus struct {
	// All CRs managed by ACK have a common `Status.ACKResourceMetadata` member
	// that is used to contain resource sync state, account ownership,
	// constructed ARN for the resource
	// +kubebuilder:validation:Optional
	ACKResourceMetadata *ackv1alpha1.ResourceMetadata `json:"ackResourceMetadata"`
	// All CRS managed by ACK have a common `Status.Conditions` member that
	// contains a collection of `ackv1alpha1.Condition` objects that describe
	// the various terminal states of the CR and its backend AWS service API
	// resource
	// +kubebuilder:validation:Optional
	Conditions []*ackv1alpha1.Condition `json:"conditions"`
	// The ID of the access point, assigned by Amazon EFS.
	// +kubebuilder:validation:Optional
	AccessPointID *string `json:"accessPointID,omitempty"`
	// Identifies the lifecycle phase of the access point.
	// +kubebuilder:validation:Optional
	LifeCycleState *string `json:"lifeCycleState,omitempty"`
	// The name of the access point. This is the value of the Name tag.
	// +kubebuilder:validation:Optional
	Name *string `json:"name,omitempty"`
	// Identifies the Amazon Web Services account that owns the access point resource.
	// +kubebuilder:validation:Optional
	OwnerID *string `json:"ownerID,omitempty"`
}

type BackupPolicy struct {
	Status *string `json:"status,omitempty"`
}

type CreationInfo struct {
	OwnerGID    *int64  `json:"ownerGID,omitempty"`
	OwnerUID    *int64  `json:"ownerUID,omitempty"`
	Permissions *string `json:"permissions,omitempty"`
}

type Destination struct {
	FileSystemID            *string      `json:"fileSystemID,omitempty"`
	LastReplicatedTimestamp *metav1.Time `json:"lastReplicatedTimestamp,omitempty"`
}

type DestinationToCreate struct {
	AvailabilityZoneName *string `json:"availabilityZoneName,omitempty"`
	FileSystemID         *string `json:"fileSystemID,omitempty"`
	KMSKeyID             *string `json:"kmsKeyID,omitempty"`
}

type FileSystem struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              FileSystemSpec   `json:"spec,omitempty"`
	Status            FileSystemStatus `json:"status,omitempty"`
}

type FileSystemDescription struct {
	AvailabilityZoneID   *string      `json:"availabilityZoneID,omitempty"`
	AvailabilityZoneName *string      `json:"availabilityZoneName,omitempty"`
	CreationTime         *metav1.Time `json:"creationTime,omitempty"`
	Encrypted            *bool        `json:"encrypted,omitempty"`
	FileSystemARN        *string      `json:"fileSystemARN,omitempty"`
	FileSystemID         *string      `json:"fileSystemID,omitempty"`
	// Describes the protection on a file system.
	FileSystemProtection         *FileSystemProtectionDescription `json:"fileSystemProtection,omitempty"`
	KMSKeyID                     *string                          `json:"kmsKeyID,omitempty"`
	LifeCycleState               *string                          `json:"lifeCycleState,omitempty"`
	Name                         *string                          `json:"name,omitempty"`
	NumberOfMountTargets         *int64                           `json:"numberOfMountTargets,omitempty"`
	OwnerID                      *string                          `json:"ownerID,omitempty"`
	PerformanceMode              *string                          `json:"performanceMode,omitempty"`
	ProvisionedThroughputInMiBps *float64                         `json:"provisionedThroughputInMiBps,omitempty"`
	// 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.
	SizeInBytes    *FileSystemSize `json:"sizeInBytes,omitempty"`
	Tags           []*Tag          `json:"tags,omitempty"`
	ThroughputMode *string         `json:"throughputMode,omitempty"`
}

type FileSystemList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []FileSystem `json:"items"`
}

type FileSystemProtectionDescription struct {
	ReplicationOverwriteProtection *string `json:"replicationOverwriteProtection,omitempty"`
}

type FileSystemSize struct {
	Timestamp       *metav1.Time `json:"timestamp,omitempty"`
	Value           *int64       `json:"value,omitempty"`
	ValueInArchive  *int64       `json:"valueInArchive,omitempty"`
	ValueInIA       *int64       `json:"valueInIA,omitempty"`
	ValueInStandard *int64       `json:"valueInStandard,omitempty"`
}

type FileSystemSpec struct {

	// Used to create a One Zone file system. It specifies the Amazon Web Services
	// Availability Zone in which to create the file system. Use the format us-east-1a
	// to specify the Availability Zone. For more information about One Zone file
	// systems, see Using EFS storage classes (https://docs.aws.amazon.com/efs/latest/ug/storage-classes.html)
	// in the Amazon EFS User Guide.
	//
	// One Zone file systems are not available in all Availability Zones in Amazon
	// Web Services Regions where Amazon EFS is available.
	AvailabilityZoneName *string `json:"availabilityZoneName,omitempty"`
	// Specifies whether automatic backups are enabled on the file system that you
	// are creating. Set the value to true to enable automatic backups. If you are
	// creating a One Zone file system, automatic backups are enabled by default.
	// For more information, see Automatic backups (https://docs.aws.amazon.com/efs/latest/ug/awsbackup.html#automatic-backups)
	// in the Amazon EFS User Guide.
	//
	// Default is false. However, if you specify an AvailabilityZoneName, the default
	// is true.
	//
	// Backup is not available in all Amazon Web Services Regions where Amazon EFS
	// is available.
	Backup *bool `json:"backup,omitempty"`
	// The backup policy included in the PutBackupPolicy request.
	BackupPolicy *BackupPolicy `json:"backupPolicy,omitempty"`
	// A Boolean value that, if true, creates an encrypted file system. When creating
	// an encrypted file system, you have the option of specifying an existing Key
	// Management Service key (KMS key). If you don't specify a KMS key, then the
	// default KMS key for Amazon EFS, /aws/elasticfilesystem, is used to protect
	// the encrypted file system.
	Encrypted            *bool                            `json:"encrypted,omitempty"`
	FileSystemProtection *UpdateFileSystemProtectionInput `json:"fileSystemProtection,omitempty"`
	// The ID of the KMS key that you want to use to protect the encrypted file
	// system. This parameter is required only if you want to use a non-default
	// KMS key. If this parameter is not specified, the default KMS key for Amazon
	// EFS is used. You can specify a KMS key ID using the following formats:
	//
	//   - Key ID - A unique identifier of the key, for example 1234abcd-12ab-34cd-56ef-1234567890ab.
	//
	//   - ARN - An Amazon Resource Name (ARN) for the key, for example arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab.
	//
	//   - Key alias - A previously created display name for a key, for example
	//     alias/projectKey1.
	//
	//   - Key alias ARN - An ARN for a key alias, for example arn:aws:kms:us-west-2:444455556666:alias/projectKey1.
	//
	// If you use KmsKeyId, you must set the CreateFileSystemRequest$Encrypted parameter
	// to true.
	//
	// EFS accepts only symmetric KMS keys. You cannot use asymmetric KMS keys with
	// Amazon EFS file systems.
	KMSKeyID  *string                                  `json:"kmsKeyID,omitempty"`
	KMSKeyRef *ackv1alpha1.AWSResourceReferenceWrapper `json:"kmsKeyRef,omitempty"`
	// An array of LifecyclePolicy objects that define the file system's LifecycleConfiguration
	// object. A LifecycleConfiguration object informs EFS Lifecycle management
	// of the following:
	//
	//   - TransitionToIA – When to move files in the file system from primary
	//     storage (Standard storage class) into the Infrequent Access (IA) storage.
	//
	//   - TransitionToArchive – When to move files in the file system from their
	//     current storage class (either IA or Standard storage) into the Archive
	//     storage. File systems cannot transition into Archive storage before transitioning
	//     into IA storage. Therefore, TransitionToArchive must either not be set
	//     or must be later than TransitionToIA. The Archive storage class is available
	//     only for file systems that use the Elastic Throughput mode and the General
	//     Purpose Performance mode.
	//
	//   - TransitionToPrimaryStorageClass – Whether to move files in the file
	//     system back to primary storage (Standard storage class) after they are
	//     accessed in IA or Archive storage.
	//
	// When using the put-lifecycle-configuration CLI command or the PutLifecycleConfiguration
	// API action, Amazon EFS requires that each LifecyclePolicy object have only
	// a single transition. This means that in a request body, LifecyclePolicies
	// must be structured as an array of LifecyclePolicy objects, one object for
	// each storage transition. See the example requests in the following section
	// for more information.
	LifecyclePolicies []*LifecyclePolicy `json:"lifecyclePolicies,omitempty"`
	// The Performance mode of the file system. We recommend generalPurpose performance
	// mode for all file systems. File systems using the maxIO performance mode
	// can scale to higher levels of aggregate throughput and operations per second
	// with a tradeoff of slightly higher latencies for most file operations. The
	// performance mode can't be changed after the file system has been created.
	// The maxIO mode is not supported on One Zone file systems.
	//
	// Due to the higher per-operation latencies with Max I/O, we recommend using
	// General Purpose performance mode for all file systems.
	//
	// Default is generalPurpose.
	PerformanceMode *string `json:"performanceMode,omitempty"`
	// The FileSystemPolicy that you're creating. Accepts a JSON formatted policy
	// definition. EFS file system policies have a 20,000 character limit. To find
	// out more about the elements that make up a file system policy, see EFS Resource-based
	// Policies (https://docs.aws.amazon.com/efs/latest/ug/access-control-overview.html#access-control-manage-access-intro-resource-policies).
	Policy *string `json:"policy,omitempty"`
	// The throughput, measured in mebibytes per second (MiBps), that you want to
	// provision for a file system that you're creating. Required if ThroughputMode
	// is set to provisioned. Valid values are 1-3414 MiBps, with the upper limit
	// depending on Region. To increase this limit, contact Amazon Web Services
	// Support. For more information, see Amazon EFS quotas that you can increase
	// (https://docs.aws.amazon.com/efs/latest/ug/limits.html#soft-limits) in the
	// Amazon EFS User Guide.
	ProvisionedThroughputInMiBps *float64 `json:"provisionedThroughputInMiBps,omitempty"`
	// Use to create one or more tags associated with the file system. Each tag
	// is a user-defined key-value pair. Name your file system on creation by including
	// a "Key":"Name","Value":"{value}" key-value pair. Each key must be unique.
	// For more information, see Tagging Amazon Web Services resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html)
	// in the Amazon Web Services General Reference Guide.
	Tags []*Tag `json:"tags,omitempty"`
	// Specifies the throughput mode for the file system. The mode can be bursting,
	// provisioned, or elastic. If you set ThroughputMode to provisioned, you must
	// also set a value for ProvisionedThroughputInMibps. After you create the file
	// system, you can decrease your file system's Provisioned throughput or change
	// between the throughput modes, with certain time restrictions. For more information,
	// see Specifying throughput with provisioned mode (https://docs.aws.amazon.com/efs/latest/ug/performance.html#provisioned-throughput)
	// in the Amazon EFS User Guide.
	//
	// Default is bursting.
	ThroughputMode *string `json:"throughputMode,omitempty"`
}

type FileSystemStatus struct {
	// All CRs managed by ACK have a common `Status.ACKResourceMetadata` member
	// that is used to contain resource sync state, account ownership,
	// constructed ARN for the resource
	// +kubebuilder:validation:Optional
	ACKResourceMetadata *ackv1alpha1.ResourceMetadata `json:"ackResourceMetadata"`
	// All CRS managed by ACK have a common `Status.Conditions` member that
	// contains a collection of `ackv1alpha1.Condition` objects that describe
	// the various terminal states of the CR and its backend AWS service API
	// resource
	// +kubebuilder:validation:Optional
	Conditions []*ackv1alpha1.Condition `json:"conditions"`
	// The unique and consistent identifier of the Availability Zone in which the
	// file system is located, and is valid only for One Zone file systems. For
	// example, use1-az1 is an Availability Zone ID for the us-east-1 Amazon Web
	// Services Region, and it has the same location in every Amazon Web Services
	// account.
	// +kubebuilder:validation:Optional
	AvailabilityZoneID *string `json:"availabilityZoneID,omitempty"`
	// The time that the file system was created, in seconds (since 1970-01-01T00:00:00Z).
	// +kubebuilder:validation:Optional
	CreationTime *metav1.Time `json:"creationTime,omitempty"`
	// The ID of the file system, assigned by Amazon EFS.
	// +kubebuilder:validation:Optional
	FileSystemID *string `json:"fileSystemID,omitempty"`
	// The lifecycle phase of the file system.
	// +kubebuilder:validation:Optional
	LifeCycleState *string `json:"lifeCycleState,omitempty"`
	// 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.
	// +kubebuilder:validation:Optional
	Name *string `json:"name,omitempty"`
	// The current number of mount targets that the file system has. For more information,
	// see CreateMountTarget.
	// +kubebuilder:validation:Optional
	NumberOfMountTargets *int64 `json:"numberOfMountTargets,omitempty"`
	// The Amazon Web Services account that created the file system.
	// +kubebuilder:validation:Optional
	OwnerID *string `json:"ownerID,omitempty"`
	// 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.
	// +kubebuilder:validation:Optional
	SizeInBytes *FileSystemSize `json:"sizeInBytes,omitempty"`
}

type LifeCycleState string

type LifecyclePolicy struct {
	TransitionToArchive             *string `json:"transitionToArchive,omitempty"`
	TransitionToIA                  *string `json:"transitionToIA,omitempty"`
	TransitionToPrimaryStorageClass *string `json:"transitionToPrimaryStorageClass,omitempty"`
}

type MountTarget struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              MountTargetSpec   `json:"spec,omitempty"`
	Status            MountTargetStatus `json:"status,omitempty"`
}

type MountTargetDescription struct {
	AvailabilityZoneID   *string `json:"availabilityZoneID,omitempty"`
	AvailabilityZoneName *string `json:"availabilityZoneName,omitempty"`
	FileSystemID         *string `json:"fileSystemID,omitempty"`
	IPAddress            *string `json:"ipAddress,omitempty"`
	LifeCycleState       *string `json:"lifeCycleState,omitempty"`
	MountTargetID        *string `json:"mountTargetID,omitempty"`
	NetworkInterfaceID   *string `json:"networkInterfaceID,omitempty"`
	OwnerID              *string `json:"ownerID,omitempty"`
	SubnetID             *string `json:"subnetID,omitempty"`
	VPCID                *string `json:"vpcID,omitempty"`
}

type MountTargetList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []MountTarget `json:"items"`
}

type MountTargetSpec struct {

	// The ID of the file system for which to create the mount target.
	FileSystemID  *string                                  `json:"fileSystemID,omitempty"`
	FileSystemRef *ackv1alpha1.AWSResourceReferenceWrapper `json:"fileSystemRef,omitempty"`
	// Valid IPv4 address within the address range of the specified subnet.
	IPAddress         *string                                    `json:"ipAddress,omitempty"`
	SecurityGroupRefs []*ackv1alpha1.AWSResourceReferenceWrapper `json:"securityGroupRefs,omitempty"`
	// Up to five VPC security group IDs, of the form sg-xxxxxxxx. These must be
	// for the same VPC as subnet specified.
	SecurityGroups []*string `json:"securityGroups,omitempty"`
	// The ID of the subnet to add the mount target in. For One Zone file systems,
	// use the subnet that is associated with the file system's Availability Zone.
	SubnetID  *string                                  `json:"subnetID,omitempty"`
	SubnetRef *ackv1alpha1.AWSResourceReferenceWrapper `json:"subnetRef,omitempty"`
}

type MountTargetStatus struct {
	// All CRs managed by ACK have a common `Status.ACKResourceMetadata` member
	// that is used to contain resource sync state, account ownership,
	// constructed ARN for the resource
	// +kubebuilder:validation:Optional
	ACKResourceMetadata *ackv1alpha1.ResourceMetadata `json:"ackResourceMetadata"`
	// All CRS managed by ACK have a common `Status.Conditions` member that
	// contains a collection of `ackv1alpha1.Condition` objects that describe
	// the various terminal states of the CR and its backend AWS service API
	// resource
	// +kubebuilder:validation:Optional
	Conditions []*ackv1alpha1.Condition `json:"conditions"`
	// The unique and consistent identifier of the Availability Zone 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 Amazon Web Services account.
	// +kubebuilder:validation:Optional
	AvailabilityZoneID *string `json:"availabilityZoneID,omitempty"`
	// The name of the Availability Zone in which the mount target is located. Availability
	// Zones are independently mapped to names for each Amazon Web Services account.
	// For example, the Availability Zone us-east-1a for your Amazon Web Services
	// account might not be the same location as us-east-1a for another Amazon Web
	// Services account.
	// +kubebuilder:validation:Optional
	AvailabilityZoneName *string `json:"availabilityZoneName,omitempty"`
	// Lifecycle state of the mount target.
	// +kubebuilder:validation:Optional
	LifeCycleState *string `json:"lifeCycleState,omitempty"`
	// System-assigned mount target ID.
	// +kubebuilder:validation:Optional
	MountTargetID *string `json:"mountTargetID,omitempty"`
	// The ID of the network interface that Amazon EFS created when it created the
	// mount target.
	// +kubebuilder:validation:Optional
	NetworkInterfaceID *string `json:"networkInterfaceID,omitempty"`
	// Amazon Web Services account ID that owns the resource.
	// +kubebuilder:validation:Optional
	OwnerID *string `json:"ownerID,omitempty"`
	// The virtual private cloud (VPC) ID that the mount target is configured in.
	// +kubebuilder:validation:Optional
	VPCID *string `json:"vpcID,omitempty"`
}

type PerformanceMode string

type PosixUser struct {
	GID           *int64   `json:"gid,omitempty"`
	SecondaryGIDs []*int64 `json:"secondaryGIDs,omitempty"`
	UID           *int64   `json:"uid,omitempty"`
}

type ReplicationConfigurationDescription struct {
	CreationTime                *metav1.Time `json:"creationTime,omitempty"`
	OriginalSourceFileSystemARN *string      `json:"originalSourceFileSystemARN,omitempty"`
	SourceFileSystemARN         *string      `json:"sourceFileSystemARN,omitempty"`
	SourceFileSystemID          *string      `json:"sourceFileSystemID,omitempty"`
}

type ReplicationOverwriteProtection string

type ReplicationStatus string

type Resource string

type ResourceIDType string

type RootDirectory struct {
	// 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.
	//
	// Amazon EFS creates a root directory only if you have provided the CreationInfo:
	// OwnUid, OwnGID, and permissions for the directory. If you do not provide
	// this information, Amazon EFS does not create the root directory. If the root
	// directory does not exist, attempts to mount using the access point will fail.
	//
	// 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.
	CreationInfo *CreationInfo `json:"creationInfo,omitempty"`
	Path         *string       `json:"path,omitempty"`
}

type Status string

type Tag struct {
	Key   *string `json:"key,omitempty"`
	Value *string `json:"value,omitempty"`
}

type ThroughputMode string

type TransitionToArchiveRules string

type TransitionToIARules string

type TransitionToPrimaryStorageClassRules string

type UpdateFileSystemProtectionInput struct {
	ReplicationOverwriteProtection *string `json:"replicationOverwriteProtection,omitempty"`
}