@aws-sdk/client-efs 3.312.0 → 3.316.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/dist-cjs/EFS.js +34 -420
  2. package/dist-cjs/protocols/Aws_restJson1.js +495 -932
  3. package/dist-es/EFS.js +34 -420
  4. package/dist-es/protocols/Aws_restJson1.js +429 -866
  5. package/dist-types/EFS.d.ts +41 -588
  6. package/dist-types/ts3.4/EFS.d.ts +2 -1
  7. package/package.json +6 -6
package/dist-types/EFS.d.ts CHANGED
@@ -30,742 +30,195 @@ import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/Ta
30
30
  import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
31
31
  import { UpdateFileSystemCommandInput, UpdateFileSystemCommandOutput } from "./commands/UpdateFileSystemCommand";
32
32
  import { EFSClient } from "./EFSClient";
33
- /**
34
- * @public
35
- * <fullname>Amazon Elastic File System</fullname>
36
- * <p>Amazon Elastic File System (Amazon EFS) provides simple, scalable file storage for
37
- * use with Amazon EC2 Linux and Mac instances in the Amazon Web Services Cloud. With Amazon EFS, storage capacity is elastic, growing and shrinking automatically as you add and
38
- * remove files, so that your applications have the storage they need, when they need it. For
39
- * more information, see the <a href="https://docs.aws.amazon.com/efs/latest/ug/api-reference.html">Amazon Elastic File System API Reference</a> and the <a href="https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html">Amazon Elastic File System User Guide</a>.</p>
40
- */
41
- export declare class EFS extends EFSClient {
33
+ export interface EFS {
42
34
  /**
43
- * @public
44
- * <p>Creates an EFS access point. An access point is an application-specific view into an EFS
45
- * file system that applies an operating system user and group, and a file system path, to any
46
- * file system request made through the access point. The operating system user and group
47
- * override any identity information provided by the NFS client. The file system path is exposed
48
- * as the access point's root directory. Applications using the access point can only access data in
49
- * the application's own directory and any subdirectories. To learn more, see <a href="https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html">Mounting a file system using EFS access
50
- * points</a>.</p>
51
- * <note>
52
- * <p>If multiple requests to create access points on the same file system are sent in quick
53
- * succession, and the file system is near the limit of 1000 access points, you may experience
54
- * a throttling response for these requests. This is to ensure that the file system does not
55
- * exceed the stated access point limit.</p>
56
- * </note>
57
- * <p>This operation requires permissions for the <code>elasticfilesystem:CreateAccessPoint</code> action.</p>
35
+ * @see {@link CreateAccessPointCommand}
58
36
  */
59
37
  createAccessPoint(args: CreateAccessPointCommandInput, options?: __HttpHandlerOptions): Promise<CreateAccessPointCommandOutput>;
60
38
  createAccessPoint(args: CreateAccessPointCommandInput, cb: (err: any, data?: CreateAccessPointCommandOutput) => void): void;
61
39
  createAccessPoint(args: CreateAccessPointCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateAccessPointCommandOutput) => void): void;
62
40
  /**
63
- * @public
64
- * <p>Creates a new, empty file system. The operation requires a creation token in the
65
- * request that Amazon EFS uses to ensure idempotent creation (calling the operation with same
66
- * creation token has no effect). If a file system does not currently exist that is owned by the
67
- * caller's Amazon Web Services account with the specified creation token, this operation does the
68
- * following:</p>
69
- * <ul>
70
- * <li>
71
- * <p>Creates a new, empty file system. The file system will have an Amazon EFS assigned
72
- * ID, and an initial lifecycle state <code>creating</code>.</p>
73
- * </li>
74
- * <li>
75
- * <p>Returns with the description of the created file system.</p>
76
- * </li>
77
- * </ul>
78
- * <p>Otherwise, this operation returns a <code>FileSystemAlreadyExists</code> error with the
79
- * ID of the existing file system.</p>
80
- * <note>
81
- * <p>For basic use cases, you can use a randomly generated UUID for the creation
82
- * token.</p>
83
- * </note>
84
- * <p> The idempotent operation allows you to retry a <code>CreateFileSystem</code> call without
85
- * risk of creating an extra file system. This can happen when an initial call fails in a way
86
- * that leaves it uncertain whether or not a file system was actually created. An example might
87
- * be that a transport level timeout occurred or your connection was reset. As long as you use
88
- * the same creation token, if the initial call had succeeded in creating a file system, the
89
- * client can learn of its existence from the <code>FileSystemAlreadyExists</code> error.</p>
90
- * <p>For more information, see
91
- * <a href="https://docs.aws.amazon.com/efs/latest/ug/creating-using-create-fs.html#creating-using-create-fs-part1">Creating a file system</a>
92
- * in the <i>Amazon EFS User Guide</i>.</p>
93
- * <note>
94
- * <p>The <code>CreateFileSystem</code> call returns while the file system's lifecycle
95
- * state is still <code>creating</code>. You can check the file system creation status by
96
- * calling the <a>DescribeFileSystems</a> operation, which among other things returns the file
97
- * system state.</p>
98
- * </note>
99
- * <p>This operation accepts an optional <code>PerformanceMode</code> parameter that you
100
- * choose for your file system. We recommend <code>generalPurpose</code> performance mode for
101
- * most file systems. File systems using the <code>maxIO</code> performance mode can scale to
102
- * higher levels of aggregate throughput and operations per second with a tradeoff of slightly
103
- * higher latencies for most file operations. The performance mode can't be changed after
104
- * the file system has been created. For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/performance.html#performancemodes.html">Amazon EFS performance
105
- * modes</a>.</p>
106
- * <p>You can set the throughput mode for the file system using the <code>ThroughputMode</code> parameter.</p>
107
- * <p>After the file system is fully created, Amazon EFS sets its lifecycle state to
108
- * <code>available</code>, at which point you can create one or more mount targets for the file
109
- * system in your VPC. For more information, see <a>CreateMountTarget</a>. You mount your Amazon EFS file system on an EC2 instances in
110
- * your VPC by using the mount target. For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/how-it-works.html">Amazon EFS: How it Works</a>. </p>
111
- * <p> This operation requires permissions for the
112
- * <code>elasticfilesystem:CreateFileSystem</code> action. </p>
41
+ * @see {@link CreateFileSystemCommand}
113
42
  */
114
43
  createFileSystem(args: CreateFileSystemCommandInput, options?: __HttpHandlerOptions): Promise<CreateFileSystemCommandOutput>;
115
44
  createFileSystem(args: CreateFileSystemCommandInput, cb: (err: any, data?: CreateFileSystemCommandOutput) => void): void;
116
45
  createFileSystem(args: CreateFileSystemCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateFileSystemCommandOutput) => void): void;
117
46
  /**
118
- * @public
119
- * <p>Creates a mount target for a file system. You can then mount the file system on EC2
120
- * instances by using the mount target.</p>
121
- * <p>You can create one mount target in each Availability Zone in your VPC. All EC2
122
- * instances in a VPC within a given Availability Zone share a single mount target for a given
123
- * file system. If you have multiple subnets in an Availability Zone, you create a mount target
124
- * in one of the subnets. EC2 instances do not need to be in the same subnet as the mount target
125
- * in order to access their file system.</p>
126
- * <p>You can create only one mount target for an EFS file system using One Zone storage
127
- * classes. You must create that mount target in the same Availability Zone in which the file
128
- * system is located. Use the <code>AvailabilityZoneName</code> and
129
- * <code>AvailabiltyZoneId</code> properties in the <a>DescribeFileSystems</a>
130
- * response object to get this information. Use the <code>subnetId</code> associated with the
131
- * file system's Availability Zone when creating the mount target.</p>
132
- * <p>For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/how-it-works.html">Amazon EFS: How it Works</a>. </p>
133
- * <p>To create a mount target for a file system, the file system's lifecycle state must be
134
- * <code>available</code>. For more information, see <a>DescribeFileSystems</a>.</p>
135
- * <p>In the request, provide the following:</p>
136
- * <ul>
137
- * <li>
138
- * <p>The file system ID for which you are creating the mount
139
- * target.</p>
140
- * </li>
141
- * <li>
142
- * <p>A subnet ID, which determines the following:</p>
143
- * <ul>
144
- * <li>
145
- * <p>The VPC in which Amazon EFS creates the mount target</p>
146
- * </li>
147
- * <li>
148
- * <p>The Availability Zone in which Amazon EFS creates the mount target</p>
149
- * </li>
150
- * <li>
151
- * <p>The IP address range from which Amazon EFS selects the IP address of the mount target
152
- * (if you don't specify an IP address in the request)</p>
153
- * </li>
154
- * </ul>
155
- * </li>
156
- * </ul>
157
- * <p>After creating the mount target, Amazon EFS returns a response that includes, a
158
- * <code>MountTargetId</code> and an <code>IpAddress</code>. You use this IP address when
159
- * mounting the file system in an EC2 instance. You can also use the mount target's DNS name
160
- * when mounting the file system. The EC2 instance on which you mount the file system by using
161
- * the mount target can resolve the mount target's DNS name to its IP address. For more
162
- * information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/how-it-works.html#how-it-works-implementation">How it Works:
163
- * Implementation Overview</a>. </p>
164
- * <p>Note that you can create mount targets for a file system in only one VPC, and there can
165
- * be only one mount target per Availability Zone. That is, if the file system already has one or
166
- * more mount targets created for it, the subnet specified in the request to add another mount
167
- * target must meet the following requirements:</p>
168
- * <ul>
169
- * <li>
170
- * <p>Must belong to the same VPC as the subnets of the existing mount targets</p>
171
- * </li>
172
- * <li>
173
- * <p>Must not be in the same Availability Zone as any of the subnets of the existing
174
- * mount targets</p>
175
- * </li>
176
- * </ul>
177
- * <p>If the request satisfies the requirements, Amazon EFS does the following:</p>
178
- * <ul>
179
- * <li>
180
- * <p>Creates a new mount target in the specified subnet.</p>
181
- * </li>
182
- * <li>
183
- * <p>Also creates a new network interface in the subnet as follows:</p>
184
- * <ul>
185
- * <li>
186
- * <p>If the request provides an <code>IpAddress</code>, Amazon EFS assigns that IP
187
- * address to the network interface. Otherwise, Amazon EFS assigns a free address in the
188
- * subnet (in the same way that the Amazon EC2 <code>CreateNetworkInterface</code> call
189
- * does when a request does not specify a primary private IP address).</p>
190
- * </li>
191
- * <li>
192
- * <p>If the request provides <code>SecurityGroups</code>, this network interface is
193
- * associated with those security groups. Otherwise, it belongs to the default security
194
- * group for the subnet's VPC.</p>
195
- * </li>
196
- * <li>
197
- * <p>Assigns the description <code>Mount target <i>fsmt-id</i> for
198
- * file system <i>fs-id</i>
199
- * </code> where <code>
200
- * <i>fsmt-id</i>
201
- * </code> is the mount target ID, and <code>
202
- * <i>fs-id</i>
203
- * </code> is the <code>FileSystemId</code>.</p>
204
- * </li>
205
- * <li>
206
- * <p>Sets the <code>requesterManaged</code> property of the network interface to
207
- * <code>true</code>, and the <code>requesterId</code> value to
208
- * <code>EFS</code>.</p>
209
- * </li>
210
- * </ul>
211
- * <p>Each Amazon EFS mount target has one corresponding requester-managed EC2 network
212
- * interface. After the network interface is created, Amazon EFS sets the
213
- * <code>NetworkInterfaceId</code> field in the mount target's description to the
214
- * network interface ID, and the <code>IpAddress</code> field to its address. If network
215
- * interface creation fails, the entire <code>CreateMountTarget</code> operation
216
- * fails.</p>
217
- * </li>
218
- * </ul>
219
- * <note>
220
- * <p>The <code>CreateMountTarget</code> call returns only after creating the network
221
- * interface, but while the mount target state is still <code>creating</code>, you can check
222
- * the mount target creation status by calling the <a>DescribeMountTargets</a> operation, which among other things returns the mount
223
- * target state.</p>
224
- * </note>
225
- * <p>We recommend that you create a mount target in each of the Availability Zones. There
226
- * are cost considerations for using a file system in an Availability Zone through a mount target
227
- * created in another Availability Zone. For more information, see <a href="http://aws.amazon.com/efs/">Amazon EFS</a>. In addition, by always using a mount target local to the
228
- * instance's Availability Zone, you eliminate a partial failure scenario. If the
229
- * Availability Zone in which your mount target is created goes down, then you can't access
230
- * your file system through that mount target. </p>
231
- * <p>This operation requires permissions for the following action on the file
232
- * system:</p>
233
- * <ul>
234
- * <li>
235
- * <p>
236
- * <code>elasticfilesystem:CreateMountTarget</code>
237
- * </p>
238
- * </li>
239
- * </ul>
240
- * <p>This operation also requires permissions for the following Amazon EC2
241
- * actions:</p>
242
- * <ul>
243
- * <li>
244
- * <p>
245
- * <code>ec2:DescribeSubnets</code>
246
- * </p>
247
- * </li>
248
- * <li>
249
- * <p>
250
- * <code>ec2:DescribeNetworkInterfaces</code>
251
- * </p>
252
- * </li>
253
- * <li>
254
- * <p>
255
- * <code>ec2:CreateNetworkInterface</code>
256
- * </p>
257
- * </li>
258
- * </ul>
47
+ * @see {@link CreateMountTargetCommand}
259
48
  */
260
49
  createMountTarget(args: CreateMountTargetCommandInput, options?: __HttpHandlerOptions): Promise<CreateMountTargetCommandOutput>;
261
50
  createMountTarget(args: CreateMountTargetCommandInput, cb: (err: any, data?: CreateMountTargetCommandOutput) => void): void;
262
51
  createMountTarget(args: CreateMountTargetCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateMountTargetCommandOutput) => void): void;
263
52
  /**
264
- * @public
265
- * <p>Creates a replication configuration that replicates an existing EFS file system to a new,
266
- * read-only file system. For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/efs-replication.html">Amazon EFS replication</a> in the
267
- * <i>Amazon EFS User Guide</i>. The replication configuration
268
- * specifies the following:</p>
269
- * <ul>
270
- * <li>
271
- * <p>
272
- * <b>Source file system</b> - An existing EFS file system that you
273
- * want replicated. The source file system cannot be a destination file system in an existing
274
- * replication configuration.</p>
275
- * </li>
276
- * <li>
277
- * <p>
278
- * <b>Destination file system configuration</b> - The configuration of
279
- * the destination file system to which the source file system will be replicated. There can
280
- * only be one destination file system in a replication configuration. The destination file
281
- * system configuration consists of the following properties:</p>
282
- * <ul>
283
- * <li>
284
- * <p>
285
- * <b>Amazon Web Services Region</b> - The Amazon Web Services Region in
286
- * which the destination file system is created. Amazon EFS replication is
287
- * available in all Amazon Web Services Regions that Amazon EFS is available in,
288
- * except Africa (Cape Town), Asia Pacific (Hong Kong), Asia Pacific (Jakarta), Europe
289
- * (Milan), and Middle East (Bahrain).</p>
290
- * </li>
291
- * <li>
292
- * <p>
293
- * <b>Availability Zone</b> - If you want the destination file system
294
- * to use EFS One Zone availability and durability, you must specify the Availability
295
- * Zone to create the file system in. For more information about EFS storage classes, see
296
- * <a href="https://docs.aws.amazon.com/efs/latest/ug/storage-classes.html">
297
- * Amazon EFS storage classes</a> in the <i>Amazon EFS User
298
- * Guide</i>.</p>
299
- * </li>
300
- * <li>
301
- * <p>
302
- * <b>Encryption</b> - All destination file systems are created with
303
- * encryption at rest enabled. You can specify the Key Management Service (KMS) key that is used to encrypt the destination file system. If you don't
304
- * specify a KMS key, your service-managed KMS key for
305
- * Amazon EFS is used. </p>
306
- * <note>
307
- * <p>After the file system is created, you cannot change the KMS key.</p>
308
- * </note>
309
- * </li>
310
- * </ul>
311
- * </li>
312
- * </ul>
313
- * <p>The following properties are set by default:</p>
314
- * <ul>
315
- * <li>
316
- * <p>
317
- * <b>Performance mode</b> - The destination file system's performance
318
- * mode matches that of the source file system, unless the destination file system uses EFS
319
- * One Zone storage. In that case, the General Purpose performance mode is used. The
320
- * performance mode cannot be changed.</p>
321
- * </li>
322
- * <li>
323
- * <p>
324
- * <b>Throughput mode</b> - The destination file system's throughput
325
- * mode matches that of the source file system. After the file system is created, you can modify the
326
- * throughput mode.</p>
327
- * </li>
328
- * </ul>
329
- * <p>The following properties are turned off by default:</p>
330
- * <ul>
331
- * <li>
332
- * <p>
333
- * <b>Lifecycle management</b> - EFS lifecycle management and EFS
334
- * Intelligent-Tiering are not enabled on the destination file system. After the destination
335
- * file system is created, you can enable EFS lifecycle management and EFS
336
- * Intelligent-Tiering.</p>
337
- * </li>
338
- * <li>
339
- * <p>
340
- * <b>Automatic backups</b> - Automatic daily backups not enabled on
341
- * the destination file system. After the file system is created, you can change this
342
- * setting.</p>
343
- * </li>
344
- * </ul>
345
- * <p>For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/efs-replication.html">Amazon EFS replication</a> in the
346
- * <i>Amazon EFS User Guide</i>.</p>
53
+ * @see {@link CreateReplicationConfigurationCommand}
347
54
  */
348
55
  createReplicationConfiguration(args: CreateReplicationConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<CreateReplicationConfigurationCommandOutput>;
349
56
  createReplicationConfiguration(args: CreateReplicationConfigurationCommandInput, cb: (err: any, data?: CreateReplicationConfigurationCommandOutput) => void): void;
350
57
  createReplicationConfiguration(args: CreateReplicationConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateReplicationConfigurationCommandOutput) => void): void;
351
58
  /**
352
- * @public
353
- * @deprecated
354
- *
355
- * <note>
356
- * <p>DEPRECATED - <code>CreateTags</code> is deprecated and not maintained. To create tags for EFS
357
- * resources, use the API action.</p>
358
- * </note>
359
- * <p>Creates or overwrites tags associated with a file system. Each tag is a key-value pair. If
360
- * a tag key specified in the request already exists on the file system, this operation
361
- * overwrites its value with the value provided in the request. If you add the <code>Name</code>
362
- * tag to your file system, Amazon EFS returns it in the response to the <a>DescribeFileSystems</a> operation. </p>
363
- * <p>This operation requires permission for the <code>elasticfilesystem:CreateTags</code>
364
- * action.</p>
59
+ * @see {@link CreateTagsCommand}
365
60
  */
366
61
  createTags(args: CreateTagsCommandInput, options?: __HttpHandlerOptions): Promise<CreateTagsCommandOutput>;
367
62
  createTags(args: CreateTagsCommandInput, cb: (err: any, data?: CreateTagsCommandOutput) => void): void;
368
63
  createTags(args: CreateTagsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateTagsCommandOutput) => void): void;
369
64
  /**
370
- * @public
371
- * <p>Deletes the specified access point. After deletion is complete, new clients can no
372
- * longer connect to the access points. Clients connected to the access point at the time of
373
- * deletion will continue to function until they terminate their connection.</p>
374
- * <p>This operation requires permissions for the <code>elasticfilesystem:DeleteAccessPoint</code> action.</p>
65
+ * @see {@link DeleteAccessPointCommand}
375
66
  */
376
67
  deleteAccessPoint(args: DeleteAccessPointCommandInput, options?: __HttpHandlerOptions): Promise<DeleteAccessPointCommandOutput>;
377
68
  deleteAccessPoint(args: DeleteAccessPointCommandInput, cb: (err: any, data?: DeleteAccessPointCommandOutput) => void): void;
378
69
  deleteAccessPoint(args: DeleteAccessPointCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteAccessPointCommandOutput) => void): void;
379
70
  /**
380
- * @public
381
- * <p>Deletes a file system, permanently severing access to its contents. Upon return, the
382
- * file system no longer exists and you can't access any contents of the deleted file
383
- * system.</p>
384
- * <p>You need to manually delete mount targets attached to a file system before you can delete
385
- * an EFS file system. This step is performed for you when you use the Amazon Web Services console
386
- * to delete a file system.</p>
387
- * <note>
388
- * <p>You cannot delete a file system that is part of an EFS Replication configuration.
389
- * You need to delete the replication configuration first.</p>
390
- * </note>
391
- * <p> You can't delete a file system that is in use. That is, if the file system has
392
- * any mount targets, you must first delete them. For more information, see <a>DescribeMountTargets</a> and <a>DeleteMountTarget</a>. </p>
393
- * <note>
394
- * <p>The <code>DeleteFileSystem</code> call returns while the file system state is still
395
- * <code>deleting</code>. You can check the file system deletion status by calling the <a>DescribeFileSystems</a> operation, which returns a list of file systems in your
396
- * account. If you pass file system ID or creation token for the deleted file system, the <a>DescribeFileSystems</a> returns a <code>404 FileSystemNotFound</code>
397
- * error.</p>
398
- * </note>
399
- * <p>This operation requires permissions for the
400
- * <code>elasticfilesystem:DeleteFileSystem</code> action.</p>
71
+ * @see {@link DeleteFileSystemCommand}
401
72
  */
402
73
  deleteFileSystem(args: DeleteFileSystemCommandInput, options?: __HttpHandlerOptions): Promise<DeleteFileSystemCommandOutput>;
403
74
  deleteFileSystem(args: DeleteFileSystemCommandInput, cb: (err: any, data?: DeleteFileSystemCommandOutput) => void): void;
404
75
  deleteFileSystem(args: DeleteFileSystemCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteFileSystemCommandOutput) => void): void;
405
76
  /**
406
- * @public
407
- * <p>Deletes the <code>FileSystemPolicy</code> for the specified file system.
408
- * The default <code>FileSystemPolicy</code> goes into effect once the existing policy is deleted.
409
- * For more information about the default file system policy, see <a href="https://docs.aws.amazon.com/efs/latest/ug/res-based-policies-efs.html">Using Resource-based Policies with EFS</a>.</p>
410
- * <p>This operation requires permissions for the <code>elasticfilesystem:DeleteFileSystemPolicy</code> action.</p>
77
+ * @see {@link DeleteFileSystemPolicyCommand}
411
78
  */
412
79
  deleteFileSystemPolicy(args: DeleteFileSystemPolicyCommandInput, options?: __HttpHandlerOptions): Promise<DeleteFileSystemPolicyCommandOutput>;
413
80
  deleteFileSystemPolicy(args: DeleteFileSystemPolicyCommandInput, cb: (err: any, data?: DeleteFileSystemPolicyCommandOutput) => void): void;
414
81
  deleteFileSystemPolicy(args: DeleteFileSystemPolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteFileSystemPolicyCommandOutput) => void): void;
415
82
  /**
416
- * @public
417
- * <p>Deletes the specified mount target.</p>
418
- * <p>This operation forcibly breaks any mounts of the file system by using the mount target
419
- * that is being deleted, which might disrupt instances or applications using those mounts. To
420
- * avoid applications getting cut off abruptly, you might consider unmounting any mounts of the
421
- * mount target, if feasible. The operation also deletes the associated network interface.
422
- * Uncommitted writes might be lost, but breaking a mount target using this operation does not
423
- * corrupt the file system itself. The file system you created remains. You can mount an EC2
424
- * instance in your VPC by using another mount target.</p>
425
- * <p>This operation requires permissions for the following action on the file
426
- * system:</p>
427
- * <ul>
428
- * <li>
429
- * <p>
430
- * <code>elasticfilesystem:DeleteMountTarget</code>
431
- * </p>
432
- * </li>
433
- * </ul>
434
- * <note>
435
- * <p>The <code>DeleteMountTarget</code> call returns while the mount target state is still
436
- * <code>deleting</code>. You can check the mount target deletion by calling the <a>DescribeMountTargets</a> operation, which returns a list of mount target
437
- * descriptions for the given file system. </p>
438
- * </note>
439
- * <p>The operation also requires permissions for the following Amazon EC2 action on the
440
- * mount target's network interface:</p>
441
- * <ul>
442
- * <li>
443
- * <p>
444
- * <code>ec2:DeleteNetworkInterface</code>
445
- * </p>
446
- * </li>
447
- * </ul>
83
+ * @see {@link DeleteMountTargetCommand}
448
84
  */
449
85
  deleteMountTarget(args: DeleteMountTargetCommandInput, options?: __HttpHandlerOptions): Promise<DeleteMountTargetCommandOutput>;
450
86
  deleteMountTarget(args: DeleteMountTargetCommandInput, cb: (err: any, data?: DeleteMountTargetCommandOutput) => void): void;
451
87
  deleteMountTarget(args: DeleteMountTargetCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteMountTargetCommandOutput) => void): void;
452
88
  /**
453
- * @public
454
- * <p>Deletes an existing replication configuration. To delete a replication configuration, you
455
- * must make the request from the Amazon Web Services Region in which the destination file system
456
- * is located. Deleting a replication configuration ends the replication process. After a
457
- * replication configuration is deleted, the destination file system is no longer read-only. You
458
- * can write to the destination file system after its status becomes
459
- * <code>Writeable</code>.</p>
89
+ * @see {@link DeleteReplicationConfigurationCommand}
460
90
  */
461
91
  deleteReplicationConfiguration(args: DeleteReplicationConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<DeleteReplicationConfigurationCommandOutput>;
462
92
  deleteReplicationConfiguration(args: DeleteReplicationConfigurationCommandInput, cb: (err: any, data?: DeleteReplicationConfigurationCommandOutput) => void): void;
463
93
  deleteReplicationConfiguration(args: DeleteReplicationConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteReplicationConfigurationCommandOutput) => void): void;
464
94
  /**
465
- * @public
466
- * @deprecated
467
- *
468
- * <note>
469
- * <p>DEPRECATED - <code>DeleteTags</code> is deprecated and not maintained. To remove tags from EFS
470
- * resources, use the API action.</p>
471
- * </note>
472
- * <p>Deletes the specified tags from a file system. If the <code>DeleteTags</code> request
473
- * includes a tag key that doesn't exist, Amazon EFS ignores it and doesn't cause an
474
- * error. For more information about tags and related restrictions, see <a href="https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html">Tag restrictions</a> in the
475
- * <i>Billing and Cost Management User Guide</i>.</p>
476
- * <p>This operation requires permissions for the <code>elasticfilesystem:DeleteTags</code>
477
- * action.</p>
95
+ * @see {@link DeleteTagsCommand}
478
96
  */
479
97
  deleteTags(args: DeleteTagsCommandInput, options?: __HttpHandlerOptions): Promise<DeleteTagsCommandOutput>;
480
98
  deleteTags(args: DeleteTagsCommandInput, cb: (err: any, data?: DeleteTagsCommandOutput) => void): void;
481
99
  deleteTags(args: DeleteTagsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteTagsCommandOutput) => void): void;
482
100
  /**
483
- * @public
484
- * <p>Returns the description of a specific Amazon EFS access point if the <code>AccessPointId</code> is provided.
485
- * If you provide an EFS <code>FileSystemId</code>, it returns descriptions of all access points for that file system.
486
- * You can provide either an <code>AccessPointId</code> or a <code>FileSystemId</code> in the request, but not both. </p>
487
- * <p>This operation requires permissions for the <code>elasticfilesystem:DescribeAccessPoints</code> action.</p>
101
+ * @see {@link DescribeAccessPointsCommand}
488
102
  */
489
103
  describeAccessPoints(args: DescribeAccessPointsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeAccessPointsCommandOutput>;
490
104
  describeAccessPoints(args: DescribeAccessPointsCommandInput, cb: (err: any, data?: DescribeAccessPointsCommandOutput) => void): void;
491
105
  describeAccessPoints(args: DescribeAccessPointsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeAccessPointsCommandOutput) => void): void;
492
106
  /**
493
- * @public
494
- * <p>Returns the account preferences settings for the Amazon Web Services account associated with the user making the request, in the current Amazon Web Services Region.
495
- * For more information, see <a href="efs/latest/ug/manage-efs-resource-ids.html">Managing Amazon EFS resource IDs</a>.</p>
107
+ * @see {@link DescribeAccountPreferencesCommand}
496
108
  */
497
109
  describeAccountPreferences(args: DescribeAccountPreferencesCommandInput, options?: __HttpHandlerOptions): Promise<DescribeAccountPreferencesCommandOutput>;
498
110
  describeAccountPreferences(args: DescribeAccountPreferencesCommandInput, cb: (err: any, data?: DescribeAccountPreferencesCommandOutput) => void): void;
499
111
  describeAccountPreferences(args: DescribeAccountPreferencesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeAccountPreferencesCommandOutput) => void): void;
500
112
  /**
501
- * @public
502
- * <p>Returns the backup policy for the specified EFS file system.</p>
113
+ * @see {@link DescribeBackupPolicyCommand}
503
114
  */
504
115
  describeBackupPolicy(args: DescribeBackupPolicyCommandInput, options?: __HttpHandlerOptions): Promise<DescribeBackupPolicyCommandOutput>;
505
116
  describeBackupPolicy(args: DescribeBackupPolicyCommandInput, cb: (err: any, data?: DescribeBackupPolicyCommandOutput) => void): void;
506
117
  describeBackupPolicy(args: DescribeBackupPolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeBackupPolicyCommandOutput) => void): void;
507
118
  /**
508
- * @public
509
- * <p>Returns the <code>FileSystemPolicy</code> for the specified EFS file system.</p>
510
- * <p>This operation requires permissions for the <code>elasticfilesystem:DescribeFileSystemPolicy</code> action.</p>
119
+ * @see {@link DescribeFileSystemPolicyCommand}
511
120
  */
512
121
  describeFileSystemPolicy(args: DescribeFileSystemPolicyCommandInput, options?: __HttpHandlerOptions): Promise<DescribeFileSystemPolicyCommandOutput>;
513
122
  describeFileSystemPolicy(args: DescribeFileSystemPolicyCommandInput, cb: (err: any, data?: DescribeFileSystemPolicyCommandOutput) => void): void;
514
123
  describeFileSystemPolicy(args: DescribeFileSystemPolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeFileSystemPolicyCommandOutput) => void): void;
515
124
  /**
516
- * @public
517
- * <p>Returns the description of a specific Amazon EFS file system if either the file system
518
- * <code>CreationToken</code> or the <code>FileSystemId</code> is provided. Otherwise, it
519
- * returns descriptions of all file systems owned by the caller's Amazon Web Services account in the
520
- * Amazon Web Services Region of the endpoint that you're calling.</p>
521
- * <p>When retrieving all file system descriptions, you can optionally specify the
522
- * <code>MaxItems</code> parameter to limit the number of descriptions in a response.
523
- * This number is automatically set to 100. If more file system descriptions remain,
524
- * Amazon EFS returns a <code>NextMarker</code>, an opaque token, in the response. In this case,
525
- * you should send a subsequent request with the <code>Marker</code> request parameter set to the
526
- * value of <code>NextMarker</code>. </p>
527
- * <p>To retrieve a list of your file system descriptions, this operation is used in an
528
- * iterative process, where <code>DescribeFileSystems</code> is called first without the
529
- * <code>Marker</code> and then the operation continues to call it with the <code>Marker</code>
530
- * parameter set to the value of the <code>NextMarker</code> from the previous response until the
531
- * response has no <code>NextMarker</code>. </p>
532
- * <p> The order of file systems returned in the response of one
533
- * <code>DescribeFileSystems</code> call and the order of file systems returned across the
534
- * responses of a multi-call iteration is unspecified. </p>
535
- * <p> This operation requires permissions for the
536
- * <code>elasticfilesystem:DescribeFileSystems</code> action. </p>
125
+ * @see {@link DescribeFileSystemsCommand}
537
126
  */
538
127
  describeFileSystems(args: DescribeFileSystemsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeFileSystemsCommandOutput>;
539
128
  describeFileSystems(args: DescribeFileSystemsCommandInput, cb: (err: any, data?: DescribeFileSystemsCommandOutput) => void): void;
540
129
  describeFileSystems(args: DescribeFileSystemsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeFileSystemsCommandOutput) => void): void;
541
130
  /**
542
- * @public
543
- * <p>Returns the current <code>LifecycleConfiguration</code> object for the specified Amazon
544
- * EFS file system. EFS lifecycle management uses the <code>LifecycleConfiguration</code> object
545
- * to identify which files to move to the EFS Infrequent Access (IA) storage class. For a file system
546
- * without a <code>LifecycleConfiguration</code> object, the call returns an empty array in the
547
- * response.</p>
548
- * <p>When EFS Intelligent-Tiering is enabled, <code>TransitionToPrimaryStorageClass</code> has
549
- * a value of <code>AFTER_1_ACCESS</code>.</p>
550
- * <p>This operation requires permissions for the
551
- * <code>elasticfilesystem:DescribeLifecycleConfiguration</code> operation.</p>
131
+ * @see {@link DescribeLifecycleConfigurationCommand}
552
132
  */
553
133
  describeLifecycleConfiguration(args: DescribeLifecycleConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<DescribeLifecycleConfigurationCommandOutput>;
554
134
  describeLifecycleConfiguration(args: DescribeLifecycleConfigurationCommandInput, cb: (err: any, data?: DescribeLifecycleConfigurationCommandOutput) => void): void;
555
135
  describeLifecycleConfiguration(args: DescribeLifecycleConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeLifecycleConfigurationCommandOutput) => void): void;
556
136
  /**
557
- * @public
558
- * <p>Returns the descriptions of all the current mount targets, or a specific mount target,
559
- * for a file system. When requesting all of the current mount targets, the order of mount
560
- * targets returned in the response is unspecified.</p>
561
- * <p>This operation requires permissions for the
562
- * <code>elasticfilesystem:DescribeMountTargets</code> action, on either the file system ID
563
- * that you specify in <code>FileSystemId</code>, or on the file system of the mount target that
564
- * you specify in <code>MountTargetId</code>.</p>
137
+ * @see {@link DescribeMountTargetsCommand}
565
138
  */
566
139
  describeMountTargets(args: DescribeMountTargetsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeMountTargetsCommandOutput>;
567
140
  describeMountTargets(args: DescribeMountTargetsCommandInput, cb: (err: any, data?: DescribeMountTargetsCommandOutput) => void): void;
568
141
  describeMountTargets(args: DescribeMountTargetsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeMountTargetsCommandOutput) => void): void;
569
142
  /**
570
- * @public
571
- * <p>Returns the security groups currently in effect for a mount target. This operation
572
- * requires that the network interface of the mount target has been created and the lifecycle
573
- * state of the mount target is not <code>deleted</code>.</p>
574
- * <p>This operation requires permissions for the following actions:</p>
575
- * <ul>
576
- * <li>
577
- * <p>
578
- * <code>elasticfilesystem:DescribeMountTargetSecurityGroups</code> action on the mount
579
- * target's file system. </p>
580
- * </li>
581
- * <li>
582
- * <p>
583
- * <code>ec2:DescribeNetworkInterfaceAttribute</code> action on the mount target's
584
- * network interface. </p>
585
- * </li>
586
- * </ul>
143
+ * @see {@link DescribeMountTargetSecurityGroupsCommand}
587
144
  */
588
145
  describeMountTargetSecurityGroups(args: DescribeMountTargetSecurityGroupsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeMountTargetSecurityGroupsCommandOutput>;
589
146
  describeMountTargetSecurityGroups(args: DescribeMountTargetSecurityGroupsCommandInput, cb: (err: any, data?: DescribeMountTargetSecurityGroupsCommandOutput) => void): void;
590
147
  describeMountTargetSecurityGroups(args: DescribeMountTargetSecurityGroupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeMountTargetSecurityGroupsCommandOutput) => void): void;
591
148
  /**
592
- * @public
593
- * <p>Retrieves the replication configuration for a specific file system. If a file system is
594
- * not specified, all of the replication configurations for the Amazon Web Services account in an
595
- * Amazon Web Services Region are retrieved.</p>
149
+ * @see {@link DescribeReplicationConfigurationsCommand}
596
150
  */
597
151
  describeReplicationConfigurations(args: DescribeReplicationConfigurationsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeReplicationConfigurationsCommandOutput>;
598
152
  describeReplicationConfigurations(args: DescribeReplicationConfigurationsCommandInput, cb: (err: any, data?: DescribeReplicationConfigurationsCommandOutput) => void): void;
599
153
  describeReplicationConfigurations(args: DescribeReplicationConfigurationsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeReplicationConfigurationsCommandOutput) => void): void;
600
154
  /**
601
- * @public
602
- * @deprecated
603
- *
604
- * <note>
605
- * <p>DEPRECATED - The <code>DescribeTags</code> action is deprecated and not maintained. To view
606
- * tags associated with EFS resources, use the <code>ListTagsForResource</code> API
607
- * action.</p>
608
- * </note>
609
- * <p>Returns the tags associated with a file system. The order of tags returned in the
610
- * response of one <code>DescribeTags</code> call and the order of tags returned across the
611
- * responses of a multiple-call iteration (when using pagination) is unspecified. </p>
612
- * <p> This operation requires permissions for the
613
- * <code>elasticfilesystem:DescribeTags</code> action. </p>
155
+ * @see {@link DescribeTagsCommand}
614
156
  */
615
157
  describeTags(args: DescribeTagsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeTagsCommandOutput>;
616
158
  describeTags(args: DescribeTagsCommandInput, cb: (err: any, data?: DescribeTagsCommandOutput) => void): void;
617
159
  describeTags(args: DescribeTagsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeTagsCommandOutput) => void): void;
618
160
  /**
619
- * @public
620
- * <p>Lists all tags for a top-level EFS resource. You must provide the ID of the resource that you want to retrieve the tags for.</p>
621
- * <p>This operation requires permissions for the <code>elasticfilesystem:DescribeAccessPoints</code> action.</p>
161
+ * @see {@link ListTagsForResourceCommand}
622
162
  */
623
163
  listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsForResourceCommandOutput>;
624
164
  listTagsForResource(args: ListTagsForResourceCommandInput, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
625
165
  listTagsForResource(args: ListTagsForResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
626
166
  /**
627
- * @public
628
- * <p>Modifies the set of security groups in effect for a mount target.</p>
629
- * <p>When you create a mount target, Amazon EFS also creates a new network interface. For
630
- * more information, see <a>CreateMountTarget</a>. This operation replaces the security groups in effect for the
631
- * network interface associated with a mount target, with the <code>SecurityGroups</code>
632
- * provided in the request. This operation requires that the network interface of the mount
633
- * target has been created and the lifecycle state of the mount target is not
634
- * <code>deleted</code>. </p>
635
- * <p>The operation requires permissions for the following actions:</p>
636
- * <ul>
637
- * <li>
638
- * <p>
639
- * <code>elasticfilesystem:ModifyMountTargetSecurityGroups</code> action on the mount
640
- * target's file system. </p>
641
- * </li>
642
- * <li>
643
- * <p>
644
- * <code>ec2:ModifyNetworkInterfaceAttribute</code> action on the mount target's network
645
- * interface. </p>
646
- * </li>
647
- * </ul>
167
+ * @see {@link ModifyMountTargetSecurityGroupsCommand}
648
168
  */
649
169
  modifyMountTargetSecurityGroups(args: ModifyMountTargetSecurityGroupsCommandInput, options?: __HttpHandlerOptions): Promise<ModifyMountTargetSecurityGroupsCommandOutput>;
650
170
  modifyMountTargetSecurityGroups(args: ModifyMountTargetSecurityGroupsCommandInput, cb: (err: any, data?: ModifyMountTargetSecurityGroupsCommandOutput) => void): void;
651
171
  modifyMountTargetSecurityGroups(args: ModifyMountTargetSecurityGroupsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ModifyMountTargetSecurityGroupsCommandOutput) => void): void;
652
172
  /**
653
- * @public
654
- * <p>Use this operation to set the account preference in the current Amazon Web Services Region
655
- * to use long 17 character (63 bit) or short 8 character (32 bit) resource IDs for
656
- * new EFS file system and mount target resources. All existing resource IDs are not affected
657
- * by any changes you make. You can set the ID preference during the
658
- * opt-in period as EFS transitions to long resource IDs. For more information,
659
- * see <a href="https://docs.aws.amazon.com/efs/latest/ug/manage-efs-resource-ids.html">Managing Amazon EFS resource IDs</a>.</p>
660
- * <note>
661
- * <p>Starting in October, 2021, you will receive an error if you try to set the account preference
662
- * to use the short 8 character format resource ID. Contact Amazon Web Services support if you
663
- * receive an error and must use short IDs for file system and mount target resources.</p>
664
- * </note>
173
+ * @see {@link PutAccountPreferencesCommand}
665
174
  */
666
175
  putAccountPreferences(args: PutAccountPreferencesCommandInput, options?: __HttpHandlerOptions): Promise<PutAccountPreferencesCommandOutput>;
667
176
  putAccountPreferences(args: PutAccountPreferencesCommandInput, cb: (err: any, data?: PutAccountPreferencesCommandOutput) => void): void;
668
177
  putAccountPreferences(args: PutAccountPreferencesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutAccountPreferencesCommandOutput) => void): void;
669
178
  /**
670
- * @public
671
- * <p>Updates the file system's backup policy. Use this action to start or stop automatic backups of the file system. </p>
179
+ * @see {@link PutBackupPolicyCommand}
672
180
  */
673
181
  putBackupPolicy(args: PutBackupPolicyCommandInput, options?: __HttpHandlerOptions): Promise<PutBackupPolicyCommandOutput>;
674
182
  putBackupPolicy(args: PutBackupPolicyCommandInput, cb: (err: any, data?: PutBackupPolicyCommandOutput) => void): void;
675
183
  putBackupPolicy(args: PutBackupPolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutBackupPolicyCommandOutput) => void): void;
676
184
  /**
677
- * @public
678
- * <p>Applies an Amazon EFS <code>FileSystemPolicy</code> to an Amazon EFS file system.
679
- * A file system policy is an IAM resource-based policy and can contain multiple policy statements.
680
- * A file system always has exactly one file system policy, which can be the default policy or
681
- * an explicit policy set or updated using this API operation.
682
- * EFS file system policies have a 20,000 character limit.
683
- * When an explicit policy is set, it overrides the default policy. For more information about the default file system policy, see
684
- * <a href="https://docs.aws.amazon.com/efs/latest/ug/iam-access-control-nfs-efs.html#default-filesystempolicy">Default EFS File System Policy</a>.
685
- * </p>
686
- * <note>
687
- * <p>EFS file system policies have a 20,000 character limit.</p>
688
- * </note>
689
- * <p>This operation requires permissions for the <code>elasticfilesystem:PutFileSystemPolicy</code> action.</p>
185
+ * @see {@link PutFileSystemPolicyCommand}
690
186
  */
691
187
  putFileSystemPolicy(args: PutFileSystemPolicyCommandInput, options?: __HttpHandlerOptions): Promise<PutFileSystemPolicyCommandOutput>;
692
188
  putFileSystemPolicy(args: PutFileSystemPolicyCommandInput, cb: (err: any, data?: PutFileSystemPolicyCommandOutput) => void): void;
693
189
  putFileSystemPolicy(args: PutFileSystemPolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutFileSystemPolicyCommandOutput) => void): void;
694
190
  /**
695
- * @public
696
- * <p>Use this action to manage EFS lifecycle management and EFS Intelligent-Tiering. A
697
- * <code>LifecycleConfiguration</code> consists of one or more <code>LifecyclePolicy</code>
698
- * objects that define the following:</p>
699
- * <ul>
700
- * <li>
701
- * <p>
702
- * <b>EFS Lifecycle management</b> - When Amazon EFS
703
- * automatically transitions files in a file system into the lower-cost EFS Infrequent Access
704
- * (IA) storage class.</p>
705
- * <p>To enable EFS Lifecycle management, set the value of <code>TransitionToIA</code> to one of the available options.</p>
706
- * </li>
707
- * <li>
708
- * <p>
709
- * <b>EFS Intelligent-Tiering</b> - When Amazon EFS
710
- * automatically transitions files from IA back into the file system's primary storage class
711
- * (EFS Standard or EFS One Zone Standard).</p>
712
- * <p>To enable EFS Intelligent-Tiering, set the value of
713
- * <code>TransitionToPrimaryStorageClass</code> to <code>AFTER_1_ACCESS</code>.</p>
714
- * </li>
715
- * </ul>
716
- * <p>For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/lifecycle-management-efs.html">EFS Lifecycle Management</a>.</p>
717
- * <p>Each Amazon EFS file system supports one lifecycle configuration, which applies to
718
- * all files in the file system. If a <code>LifecycleConfiguration</code> object already exists
719
- * for the specified file system, a <code>PutLifecycleConfiguration</code> call modifies the
720
- * existing configuration. A <code>PutLifecycleConfiguration</code> call with an empty
721
- * <code>LifecyclePolicies</code> array in the request body deletes any existing
722
- * <code>LifecycleConfiguration</code> and turns off lifecycle management and EFS
723
- * Intelligent-Tiering for the file system.</p>
724
- * <p>In the request, specify the following: </p>
725
- * <ul>
726
- * <li>
727
- * <p>The ID for the file system for which you are enabling, disabling, or modifying
728
- * lifecycle management and EFS Intelligent-Tiering.</p>
729
- * </li>
730
- * <li>
731
- * <p>A <code>LifecyclePolicies</code> array of <code>LifecyclePolicy</code> objects that
732
- * define when files are moved into IA storage, and when they are moved back to Standard storage.</p>
733
- * <note>
734
- * <p>Amazon EFS requires that each <code>LifecyclePolicy</code>
735
- * object have only have a single transition, so the <code>LifecyclePolicies</code> array needs to be structured with separate
736
- * <code>LifecyclePolicy</code> objects. See the example requests in the following section for more information.</p>
737
- * </note>
738
- * </li>
739
- * </ul>
740
- * <p>This operation requires permissions for the <code>elasticfilesystem:PutLifecycleConfiguration</code> operation.</p>
741
- * <p>To apply a <code>LifecycleConfiguration</code> object to an encrypted file system, you
742
- * need the same Key Management Service permissions as when you created the encrypted file system.</p>
191
+ * @see {@link PutLifecycleConfigurationCommand}
743
192
  */
744
193
  putLifecycleConfiguration(args: PutLifecycleConfigurationCommandInput, options?: __HttpHandlerOptions): Promise<PutLifecycleConfigurationCommandOutput>;
745
194
  putLifecycleConfiguration(args: PutLifecycleConfigurationCommandInput, cb: (err: any, data?: PutLifecycleConfigurationCommandOutput) => void): void;
746
195
  putLifecycleConfiguration(args: PutLifecycleConfigurationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutLifecycleConfigurationCommandOutput) => void): void;
747
196
  /**
748
- * @public
749
- * <p>Creates a tag for an EFS resource. You can create tags for EFS file systems and access points using this API operation.</p>
750
- * <p>This operation requires permissions for the <code>elasticfilesystem:TagResource</code> action.</p>
197
+ * @see {@link TagResourceCommand}
751
198
  */
752
199
  tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
753
200
  tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
754
201
  tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
755
202
  /**
756
- * @public
757
- * <p>Removes tags from an EFS resource. You can remove tags from EFS file systems and access points using this API operation.</p>
758
- * <p>This operation requires permissions for the <code>elasticfilesystem:UntagResource</code> action.</p>
203
+ * @see {@link UntagResourceCommand}
759
204
  */
760
205
  untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Promise<UntagResourceCommandOutput>;
761
206
  untagResource(args: UntagResourceCommandInput, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
762
207
  untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
763
208
  /**
764
- * @public
765
- * <p>Updates the throughput mode or the amount of provisioned throughput of an existing file
766
- * system.</p>
209
+ * @see {@link UpdateFileSystemCommand}
767
210
  */
768
211
  updateFileSystem(args: UpdateFileSystemCommandInput, options?: __HttpHandlerOptions): Promise<UpdateFileSystemCommandOutput>;
769
212
  updateFileSystem(args: UpdateFileSystemCommandInput, cb: (err: any, data?: UpdateFileSystemCommandOutput) => void): void;
770
213
  updateFileSystem(args: UpdateFileSystemCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateFileSystemCommandOutput) => void): void;
771
214
  }
215
+ /**
216
+ * @public
217
+ * <fullname>Amazon Elastic File System</fullname>
218
+ * <p>Amazon Elastic File System (Amazon EFS) provides simple, scalable file storage for
219
+ * use with Amazon EC2 Linux and Mac instances in the Amazon Web Services Cloud. With Amazon EFS, storage capacity is elastic, growing and shrinking automatically as you add and
220
+ * remove files, so that your applications have the storage they need, when they need it. For
221
+ * more information, see the <a href="https://docs.aws.amazon.com/efs/latest/ug/api-reference.html">Amazon Elastic File System API Reference</a> and the <a href="https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html">Amazon Elastic File System User Guide</a>.</p>
222
+ */
223
+ export declare class EFS extends EFSClient implements EFS {
224
+ }