| 1 | package Paws::GreengrassV2; | ||
| 2 | use Moose; | ||
| 3 | sub service { 'greengrass' } | ||
| 4 | sub signing_name { 'greengrass' } | ||
| 5 | sub version { '2020-11-30' } | ||
| 6 | sub flattened_arrays { 0 } | ||
| 7 | has max_attempts => (is => 'ro', isa => 'Int', default => 5); | ||
| 8 | has retry => (is => 'ro', isa => 'HashRef', default => sub { | ||
| 9 | { base => 'rand', type => 'exponential', growth_factor => 2 } | ||
| 10 | }); | ||
| 11 | has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [ | ||
| 12 | ] }); | ||
| 13 | |||
| 14 | with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::RestJsonCaller'; | ||
| 15 | |||
| 16 | |||
| 17 | sub BatchAssociateClientDeviceWithCoreDevice { | ||
| 18 | my $self = shift; | ||
| 19 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::BatchAssociateClientDeviceWithCoreDevice', @_); | ||
| 20 | return $self->caller->do_call($self, $call_object); | ||
| 21 | } | ||
| 22 | sub BatchDisassociateClientDeviceFromCoreDevice { | ||
| 23 | my $self = shift; | ||
| 24 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::BatchDisassociateClientDeviceFromCoreDevice', @_); | ||
| 25 | return $self->caller->do_call($self, $call_object); | ||
| 26 | } | ||
| 27 | sub CancelDeployment { | ||
| 28 | my $self = shift; | ||
| 29 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::CancelDeployment', @_); | ||
| 30 | return $self->caller->do_call($self, $call_object); | ||
| 31 | } | ||
| 32 | sub CreateComponentVersion { | ||
| 33 | my $self = shift; | ||
| 34 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::CreateComponentVersion', @_); | ||
| 35 | return $self->caller->do_call($self, $call_object); | ||
| 36 | } | ||
| 37 | sub CreateDeployment { | ||
| 38 | my $self = shift; | ||
| 39 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::CreateDeployment', @_); | ||
| 40 | return $self->caller->do_call($self, $call_object); | ||
| 41 | } | ||
| 42 | sub DeleteComponent { | ||
| 43 | my $self = shift; | ||
| 44 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::DeleteComponent', @_); | ||
| 45 | return $self->caller->do_call($self, $call_object); | ||
| 46 | } | ||
| 47 | sub DeleteCoreDevice { | ||
| 48 | my $self = shift; | ||
| 49 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::DeleteCoreDevice', @_); | ||
| 50 | return $self->caller->do_call($self, $call_object); | ||
| 51 | } | ||
| 52 | sub DescribeComponent { | ||
| 53 | my $self = shift; | ||
| 54 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::DescribeComponent', @_); | ||
| 55 | return $self->caller->do_call($self, $call_object); | ||
| 56 | } | ||
| 57 | sub GetComponent { | ||
| 58 | my $self = shift; | ||
| 59 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::GetComponent', @_); | ||
| 60 | return $self->caller->do_call($self, $call_object); | ||
| 61 | } | ||
| 62 | sub GetComponentVersionArtifact { | ||
| 63 | my $self = shift; | ||
| 64 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::GetComponentVersionArtifact', @_); | ||
| 65 | return $self->caller->do_call($self, $call_object); | ||
| 66 | } | ||
| 67 | sub GetCoreDevice { | ||
| 68 | my $self = shift; | ||
| 69 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::GetCoreDevice', @_); | ||
| 70 | return $self->caller->do_call($self, $call_object); | ||
| 71 | } | ||
| 72 | sub GetDeployment { | ||
| 73 | my $self = shift; | ||
| 74 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::GetDeployment', @_); | ||
| 75 | return $self->caller->do_call($self, $call_object); | ||
| 76 | } | ||
| 77 | sub ListClientDevicesAssociatedWithCoreDevice { | ||
| 78 | my $self = shift; | ||
| 79 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::ListClientDevicesAssociatedWithCoreDevice', @_); | ||
| 80 | return $self->caller->do_call($self, $call_object); | ||
| 81 | } | ||
| 82 | sub ListComponents { | ||
| 83 | my $self = shift; | ||
| 84 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::ListComponents', @_); | ||
| 85 | return $self->caller->do_call($self, $call_object); | ||
| 86 | } | ||
| 87 | sub ListComponentVersions { | ||
| 88 | my $self = shift; | ||
| 89 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::ListComponentVersions', @_); | ||
| 90 | return $self->caller->do_call($self, $call_object); | ||
| 91 | } | ||
| 92 | sub ListCoreDevices { | ||
| 93 | my $self = shift; | ||
| 94 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::ListCoreDevices', @_); | ||
| 95 | return $self->caller->do_call($self, $call_object); | ||
| 96 | } | ||
| 97 | sub ListDeployments { | ||
| 98 | my $self = shift; | ||
| 99 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::ListDeployments', @_); | ||
| 100 | return $self->caller->do_call($self, $call_object); | ||
| 101 | } | ||
| 102 | sub ListEffectiveDeployments { | ||
| 103 | my $self = shift; | ||
| 104 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::ListEffectiveDeployments', @_); | ||
| 105 | return $self->caller->do_call($self, $call_object); | ||
| 106 | } | ||
| 107 | sub ListInstalledComponents { | ||
| 108 | my $self = shift; | ||
| 109 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::ListInstalledComponents', @_); | ||
| 110 | return $self->caller->do_call($self, $call_object); | ||
| 111 | } | ||
| 112 | sub ListTagsForResource { | ||
| 113 | my $self = shift; | ||
| 114 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::ListTagsForResource', @_); | ||
| 115 | return $self->caller->do_call($self, $call_object); | ||
| 116 | } | ||
| 117 | sub ResolveComponentCandidates { | ||
| 118 | my $self = shift; | ||
| 119 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::ResolveComponentCandidates', @_); | ||
| 120 | return $self->caller->do_call($self, $call_object); | ||
| 121 | } | ||
| 122 | sub TagResource { | ||
| 123 | my $self = shift; | ||
| 124 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::TagResource', @_); | ||
| 125 | return $self->caller->do_call($self, $call_object); | ||
| 126 | } | ||
| 127 | sub UntagResource { | ||
| 128 | my $self = shift; | ||
| 129 | my $call_object = $self->new_with_coercions('Paws::GreengrassV2::UntagResource', @_); | ||
| 130 | return $self->caller->do_call($self, $call_object); | ||
| 131 | } | ||
| 132 | |||
| 133 | sub ListAllClientDevicesAssociatedWithCoreDevice { | ||
| 134 | my $self = shift; | ||
| 135 | |||
| 136 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 137 | my $result = $self->ListClientDevicesAssociatedWithCoreDevice(@_); | ||
| 138 | my $next_result = $result; | ||
| 139 | |||
| 140 | if (not defined $callback) { | ||
| 141 | while ($next_result->nextToken) { | ||
| 142 | $next_result = $self->ListClientDevicesAssociatedWithCoreDevice(@_, nextToken => $next_result->nextToken); | ||
| 143 | push @{ $result->associatedClientDevices }, @{ $next_result->associatedClientDevices }; | ||
| 144 | } | ||
| 145 | return $result; | ||
| 146 | } else { | ||
| 147 | while ($result->nextToken) { | ||
| 148 | $callback->($_ => 'associatedClientDevices') foreach (@{ $result->associatedClientDevices }); | ||
| 149 | $result = $self->ListClientDevicesAssociatedWithCoreDevice(@_, nextToken => $result->nextToken); | ||
| 150 | } | ||
| 151 | $callback->($_ => 'associatedClientDevices') foreach (@{ $result->associatedClientDevices }); | ||
| 152 | } | ||
| 153 | |||
| 154 | return undef | ||
| 155 | } | ||
| 156 | sub ListAllComponents { | ||
| 157 | my $self = shift; | ||
| 158 | |||
| 159 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 160 | my $result = $self->ListComponents(@_); | ||
| 161 | my $next_result = $result; | ||
| 162 | |||
| 163 | if (not defined $callback) { | ||
| 164 | while ($next_result->nextToken) { | ||
| 165 | $next_result = $self->ListComponents(@_, nextToken => $next_result->nextToken); | ||
| 166 | push @{ $result->components }, @{ $next_result->components }; | ||
| 167 | } | ||
| 168 | return $result; | ||
| 169 | } else { | ||
| 170 | while ($result->nextToken) { | ||
| 171 | $callback->($_ => 'components') foreach (@{ $result->components }); | ||
| 172 | $result = $self->ListComponents(@_, nextToken => $result->nextToken); | ||
| 173 | } | ||
| 174 | $callback->($_ => 'components') foreach (@{ $result->components }); | ||
| 175 | } | ||
| 176 | |||
| 177 | return undef | ||
| 178 | } | ||
| 179 | sub ListAllComponentVersions { | ||
| 180 | my $self = shift; | ||
| 181 | |||
| 182 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 183 | my $result = $self->ListComponentVersions(@_); | ||
| 184 | my $next_result = $result; | ||
| 185 | |||
| 186 | if (not defined $callback) { | ||
| 187 | while ($next_result->nextToken) { | ||
| 188 | $next_result = $self->ListComponentVersions(@_, nextToken => $next_result->nextToken); | ||
| 189 | push @{ $result->componentVersions }, @{ $next_result->componentVersions }; | ||
| 190 | } | ||
| 191 | return $result; | ||
| 192 | } else { | ||
| 193 | while ($result->nextToken) { | ||
| 194 | $callback->($_ => 'componentVersions') foreach (@{ $result->componentVersions }); | ||
| 195 | $result = $self->ListComponentVersions(@_, nextToken => $result->nextToken); | ||
| 196 | } | ||
| 197 | $callback->($_ => 'componentVersions') foreach (@{ $result->componentVersions }); | ||
| 198 | } | ||
| 199 | |||
| 200 | return undef | ||
| 201 | } | ||
| 202 | sub ListAllCoreDevices { | ||
| 203 | my $self = shift; | ||
| 204 | |||
| 205 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 206 | my $result = $self->ListCoreDevices(@_); | ||
| 207 | my $next_result = $result; | ||
| 208 | |||
| 209 | if (not defined $callback) { | ||
| 210 | while ($next_result->nextToken) { | ||
| 211 | $next_result = $self->ListCoreDevices(@_, nextToken => $next_result->nextToken); | ||
| 212 | push @{ $result->coreDevices }, @{ $next_result->coreDevices }; | ||
| 213 | } | ||
| 214 | return $result; | ||
| 215 | } else { | ||
| 216 | while ($result->nextToken) { | ||
| 217 | $callback->($_ => 'coreDevices') foreach (@{ $result->coreDevices }); | ||
| 218 | $result = $self->ListCoreDevices(@_, nextToken => $result->nextToken); | ||
| 219 | } | ||
| 220 | $callback->($_ => 'coreDevices') foreach (@{ $result->coreDevices }); | ||
| 221 | } | ||
| 222 | |||
| 223 | return undef | ||
| 224 | } | ||
| 225 | sub ListAllDeployments { | ||
| 226 | my $self = shift; | ||
| 227 | |||
| 228 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 229 | my $result = $self->ListDeployments(@_); | ||
| 230 | my $next_result = $result; | ||
| 231 | |||
| 232 | if (not defined $callback) { | ||
| 233 | while ($next_result->nextToken) { | ||
| 234 | $next_result = $self->ListDeployments(@_, nextToken => $next_result->nextToken); | ||
| 235 | push @{ $result->deployments }, @{ $next_result->deployments }; | ||
| 236 | } | ||
| 237 | return $result; | ||
| 238 | } else { | ||
| 239 | while ($result->nextToken) { | ||
| 240 | $callback->($_ => 'deployments') foreach (@{ $result->deployments }); | ||
| 241 | $result = $self->ListDeployments(@_, nextToken => $result->nextToken); | ||
| 242 | } | ||
| 243 | $callback->($_ => 'deployments') foreach (@{ $result->deployments }); | ||
| 244 | } | ||
| 245 | |||
| 246 | return undef | ||
| 247 | } | ||
| 248 | sub ListAllEffectiveDeployments { | ||
| 249 | my $self = shift; | ||
| 250 | |||
| 251 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 252 | my $result = $self->ListEffectiveDeployments(@_); | ||
| 253 | my $next_result = $result; | ||
| 254 | |||
| 255 | if (not defined $callback) { | ||
| 256 | while ($next_result->nextToken) { | ||
| 257 | $next_result = $self->ListEffectiveDeployments(@_, nextToken => $next_result->nextToken); | ||
| 258 | push @{ $result->effectiveDeployments }, @{ $next_result->effectiveDeployments }; | ||
| 259 | } | ||
| 260 | return $result; | ||
| 261 | } else { | ||
| 262 | while ($result->nextToken) { | ||
| 263 | $callback->($_ => 'effectiveDeployments') foreach (@{ $result->effectiveDeployments }); | ||
| 264 | $result = $self->ListEffectiveDeployments(@_, nextToken => $result->nextToken); | ||
| 265 | } | ||
| 266 | $callback->($_ => 'effectiveDeployments') foreach (@{ $result->effectiveDeployments }); | ||
| 267 | } | ||
| 268 | |||
| 269 | return undef | ||
| 270 | } | ||
| 271 | sub ListAllInstalledComponents { | ||
| 272 | my $self = shift; | ||
| 273 | |||
| 274 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 275 | my $result = $self->ListInstalledComponents(@_); | ||
| 276 | my $next_result = $result; | ||
| 277 | |||
| 278 | if (not defined $callback) { | ||
| 279 | while ($next_result->nextToken) { | ||
| 280 | $next_result = $self->ListInstalledComponents(@_, nextToken => $next_result->nextToken); | ||
| 281 | push @{ $result->installedComponents }, @{ $next_result->installedComponents }; | ||
| 282 | } | ||
| 283 | return $result; | ||
| 284 | } else { | ||
| 285 | while ($result->nextToken) { | ||
| 286 | $callback->($_ => 'installedComponents') foreach (@{ $result->installedComponents }); | ||
| 287 | $result = $self->ListInstalledComponents(@_, nextToken => $result->nextToken); | ||
| 288 | } | ||
| 289 | $callback->($_ => 'installedComponents') foreach (@{ $result->installedComponents }); | ||
| 290 | } | ||
| 291 | |||
| 292 | return undef | ||
| 293 | } | ||
| 294 | |||
| 295 | |||
| 296 | sub operations { qw/BatchAssociateClientDeviceWithCoreDevice BatchDisassociateClientDeviceFromCoreDevice CancelDeployment CreateComponentVersion CreateDeployment DeleteComponent DeleteCoreDevice DescribeComponent GetComponent GetComponentVersionArtifact GetCoreDevice GetDeployment ListClientDevicesAssociatedWithCoreDevice ListComponents ListComponentVersions ListCoreDevices ListDeployments ListEffectiveDeployments ListInstalledComponents ListTagsForResource ResolveComponentCandidates TagResource UntagResource / } | ||
| 297 | |||
| 298 | 1; | ||
| 299 | |||
| 300 | ### main pod documentation begin ### | ||
| 301 | |||
| 302 | =head1 NAME | ||
| 303 | |||
| 304 | Paws::GreengrassV2 - Perl Interface to AWS AWS IoT Greengrass V2 | ||
| 305 | |||
| 306 | =head1 SYNOPSIS | ||
| 307 | |||
| 308 | use Paws; | ||
| 309 | |||
| 310 | my $obj = Paws->service('GreengrassV2'); | ||
| 311 | my $res = $obj->Method( | ||
| 312 | Arg1 => $val1, | ||
| 313 | Arg2 => [ 'V1', 'V2' ], | ||
| 314 | # if Arg3 is an object, the HashRef will be used as arguments to the constructor | ||
| 315 | # of the arguments type | ||
| 316 | Arg3 => { Att1 => 'Val1' }, | ||
| 317 | # if Arg4 is an array of objects, the HashRefs will be passed as arguments to | ||
| 318 | # the constructor of the arguments type | ||
| 319 | Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ], | ||
| 320 | ); | ||
| 321 | |||
| 322 | =head1 DESCRIPTION | ||
| 323 | |||
| 324 | AWS IoT Greengrass brings local compute, messaging, data management, | ||
| 325 | sync, and ML inference capabilities to edge devices. This enables | ||
| 326 | devices to collect and analyze data closer to the source of | ||
| 327 | information, react autonomously to local events, and communicate | ||
| 328 | securely with each other on local networks. Local devices can also | ||
| 329 | communicate securely with AWS IoT Core and export IoT data to the AWS | ||
| 330 | Cloud. AWS IoT Greengrass developers can use AWS Lambda functions and | ||
| 331 | components to create and deploy applications to fleets of edge devices | ||
| 332 | for local operation. | ||
| 333 | |||
| 334 | AWS IoT Greengrass Version 2 provides a new major version of the AWS | ||
| 335 | IoT Greengrass Core software, new APIs, and a new console. Use this API | ||
| 336 | reference to learn how to use the AWS IoT Greengrass V2 API operations | ||
| 337 | to manage components, manage deployments, and core devices. | ||
| 338 | |||
| 339 | For more information, see What is AWS IoT Greengrass? | ||
| 340 | (https://docs.aws.amazon.com/greengrass/v2/developerguide/what-is-iot-greengrass.html) | ||
| 341 | in the I<AWS IoT Greengrass V2 Developer Guide>. | ||
| 342 | |||
| 343 | For the AWS API documentation, see L<https://docs.aws.amazon.com/greengrass/> | ||
| 344 | |||
| 345 | |||
| 346 | =head1 METHODS | ||
| 347 | |||
| 348 | =head2 BatchAssociateClientDeviceWithCoreDevice | ||
| 349 | |||
| 350 | =over | ||
| 351 | |||
| 352 | =item CoreDeviceThingName => Str | ||
| 353 | |||
| 354 | =item [Entries => ArrayRef[L<Paws::GreengrassV2::AssociateClientDeviceWithCoreDeviceEntry>]] | ||
| 355 | |||
| 356 | |||
| 357 | =back | ||
| 358 | |||
| 359 | Each argument is described in detail in: L<Paws::GreengrassV2::BatchAssociateClientDeviceWithCoreDevice> | ||
| 360 | |||
| 361 | Returns: a L<Paws::GreengrassV2::BatchAssociateClientDeviceWithCoreDeviceResponse> instance | ||
| 362 | |||
| 363 | Associate a list of client devices with a core device. Use this API | ||
| 364 | operation to specify which client devices can discover a core device | ||
| 365 | through cloud discovery. With cloud discovery, client devices connect | ||
| 366 | to AWS IoT Greengrass to retrieve associated core devices' connectivity | ||
| 367 | information and certificates. For more information, see Configure cloud | ||
| 368 | discovery | ||
| 369 | (https://docs.aws.amazon.com/greengrass/v2/developerguide/configure-cloud-discovery.html) | ||
| 370 | in the I<AWS IoT Greengrass V2 Developer Guide>. | ||
| 371 | |||
| 372 | Client devices are local IoT devices that connect to and communicate | ||
| 373 | with an AWS IoT Greengrass core device over MQTT. You can connect | ||
| 374 | client devices to a core device to sync MQTT messages and data to AWS | ||
| 375 | IoT Core and interact with client devices in AWS IoT Greengrass | ||
| 376 | components. For more information, see Interact with local IoT devices | ||
| 377 | (https://docs.aws.amazon.com/greengrass/v2/developerguide/interact-with-local-iot-devices.html) | ||
| 378 | in the I<AWS IoT Greengrass V2 Developer Guide>. | ||
| 379 | |||
| 380 | |||
| 381 | =head2 BatchDisassociateClientDeviceFromCoreDevice | ||
| 382 | |||
| 383 | =over | ||
| 384 | |||
| 385 | =item CoreDeviceThingName => Str | ||
| 386 | |||
| 387 | =item [Entries => ArrayRef[L<Paws::GreengrassV2::DisassociateClientDeviceFromCoreDeviceEntry>]] | ||
| 388 | |||
| 389 | |||
| 390 | =back | ||
| 391 | |||
| 392 | Each argument is described in detail in: L<Paws::GreengrassV2::BatchDisassociateClientDeviceFromCoreDevice> | ||
| 393 | |||
| 394 | Returns: a L<Paws::GreengrassV2::BatchDisassociateClientDeviceFromCoreDeviceResponse> instance | ||
| 395 | |||
| 396 | Disassociate a list of client devices from a core device. After you | ||
| 397 | disassociate a client device from a core device, the client device | ||
| 398 | won't be able to use cloud discovery to retrieve the core device's | ||
| 399 | connectivity information and certificates. | ||
| 400 | |||
| 401 | |||
| 402 | =head2 CancelDeployment | ||
| 403 | |||
| 404 | =over | ||
| 405 | |||
| 406 | =item DeploymentId => Str | ||
| 407 | |||
| 408 | |||
| 409 | =back | ||
| 410 | |||
| 411 | Each argument is described in detail in: L<Paws::GreengrassV2::CancelDeployment> | ||
| 412 | |||
| 413 | Returns: a L<Paws::GreengrassV2::CancelDeploymentResponse> instance | ||
| 414 | |||
| 415 | Cancels a deployment. This operation cancels the deployment for devices | ||
| 416 | that haven't yet received it. If a device already received the | ||
| 417 | deployment, this operation doesn't change anything for that device. | ||
| 418 | |||
| 419 | |||
| 420 | =head2 CreateComponentVersion | ||
| 421 | |||
| 422 | =over | ||
| 423 | |||
| 424 | =item [InlineRecipe => Str] | ||
| 425 | |||
| 426 | =item [LambdaFunction => L<Paws::GreengrassV2::LambdaFunctionRecipeSource>] | ||
| 427 | |||
| 428 | =item [Tags => L<Paws::GreengrassV2::TagMap>] | ||
| 429 | |||
| 430 | |||
| 431 | =back | ||
| 432 | |||
| 433 | Each argument is described in detail in: L<Paws::GreengrassV2::CreateComponentVersion> | ||
| 434 | |||
| 435 | Returns: a L<Paws::GreengrassV2::CreateComponentVersionResponse> instance | ||
| 436 | |||
| 437 | Creates a component. Components are software that run on AWS IoT | ||
| 438 | Greengrass core devices. After you develop and test a component on your | ||
| 439 | core device, you can use this operation to upload your component to AWS | ||
| 440 | IoT Greengrass. Then, you can deploy the component to other core | ||
| 441 | devices. | ||
| 442 | |||
| 443 | You can use this operation to do the following: | ||
| 444 | |||
| 445 | =over | ||
| 446 | |||
| 447 | =item * | ||
| 448 | |||
| 449 | B<Create components from recipes> | ||
| 450 | |||
| 451 | Create a component from a recipe, which is a file that defines the | ||
| 452 | component's metadata, parameters, dependencies, lifecycle, artifacts, | ||
| 453 | and platform capability. For more information, see AWS IoT Greengrass | ||
| 454 | component recipe reference | ||
| 455 | (https://docs.aws.amazon.com/greengrass/v2/developerguide/component-recipe-reference.html) | ||
| 456 | in the I<AWS IoT Greengrass V2 Developer Guide>. | ||
| 457 | |||
| 458 | To create a component from a recipe, specify C<inlineRecipe> when you | ||
| 459 | call this operation. | ||
| 460 | |||
| 461 | =item * | ||
| 462 | |||
| 463 | B<Create components from Lambda functions> | ||
| 464 | |||
| 465 | Create a component from an AWS Lambda function that runs on AWS IoT | ||
| 466 | Greengrass. This creates a recipe and artifacts from the Lambda | ||
| 467 | function's deployment package. You can use this operation to migrate | ||
| 468 | Lambda functions from AWS IoT Greengrass V1 to AWS IoT Greengrass V2. | ||
| 469 | |||
| 470 | This function only accepts Lambda functions that use the following | ||
| 471 | runtimes: | ||
| 472 | |||
| 473 | =over | ||
| 474 | |||
| 475 | =item * | ||
| 476 | |||
| 477 | Python 2.7 E<ndash> C<python2.7> | ||
| 478 | |||
| 479 | =item * | ||
| 480 | |||
| 481 | Python 3.7 E<ndash> C<python3.7> | ||
| 482 | |||
| 483 | =item * | ||
| 484 | |||
| 485 | Python 3.8 E<ndash> C<python3.8> | ||
| 486 | |||
| 487 | =item * | ||
| 488 | |||
| 489 | Java 8 E<ndash> C<java8> | ||
| 490 | |||
| 491 | =item * | ||
| 492 | |||
| 493 | Node.js 10 E<ndash> C<nodejs10.x> | ||
| 494 | |||
| 495 | =item * | ||
| 496 | |||
| 497 | Node.js 12 E<ndash> C<nodejs12.x> | ||
| 498 | |||
| 499 | =back | ||
| 500 | |||
| 501 | To create a component from a Lambda function, specify C<lambdaFunction> | ||
| 502 | when you call this operation. | ||
| 503 | |||
| 504 | =back | ||
| 505 | |||
| 506 | |||
| 507 | |||
| 508 | =head2 CreateDeployment | ||
| 509 | |||
| 510 | =over | ||
| 511 | |||
| 512 | =item TargetArn => Str | ||
| 513 | |||
| 514 | =item [Components => L<Paws::GreengrassV2::ComponentDeploymentSpecifications>] | ||
| 515 | |||
| 516 | =item [DeploymentName => Str] | ||
| 517 | |||
| 518 | =item [DeploymentPolicies => L<Paws::GreengrassV2::DeploymentPolicies>] | ||
| 519 | |||
| 520 | =item [IotJobConfiguration => L<Paws::GreengrassV2::DeploymentIoTJobConfiguration>] | ||
| 521 | |||
| 522 | =item [Tags => L<Paws::GreengrassV2::TagMap>] | ||
| 523 | |||
| 524 | |||
| 525 | =back | ||
| 526 | |||
| 527 | Each argument is described in detail in: L<Paws::GreengrassV2::CreateDeployment> | ||
| 528 | |||
| 529 | Returns: a L<Paws::GreengrassV2::CreateDeploymentResponse> instance | ||
| 530 | |||
| 531 | Creates a continuous deployment for a target, which is a AWS IoT | ||
| 532 | Greengrass core device or group of core devices. When you add a new | ||
| 533 | core device to a group of core devices that has a deployment, AWS IoT | ||
| 534 | Greengrass deploys that group's deployment to the new device. | ||
| 535 | |||
| 536 | You can define one deployment for each target. When you create a new | ||
| 537 | deployment for a target that has an existing deployment, you replace | ||
| 538 | the previous deployment. AWS IoT Greengrass applies the new deployment | ||
| 539 | to the target devices. | ||
| 540 | |||
| 541 | Every deployment has a revision number that indicates how many | ||
| 542 | deployment revisions you define for a target. Use this operation to | ||
| 543 | create a new revision of an existing deployment. This operation returns | ||
| 544 | the revision number of the new deployment when you create it. | ||
| 545 | |||
| 546 | For more information, see the Create deployments | ||
| 547 | (https://docs.aws.amazon.com/greengrass/v2/developerguide/create-deployments.html) | ||
| 548 | in the I<AWS IoT Greengrass V2 Developer Guide>. | ||
| 549 | |||
| 550 | |||
| 551 | =head2 DeleteComponent | ||
| 552 | |||
| 553 | =over | ||
| 554 | |||
| 555 | =item Arn => Str | ||
| 556 | |||
| 557 | |||
| 558 | =back | ||
| 559 | |||
| 560 | Each argument is described in detail in: L<Paws::GreengrassV2::DeleteComponent> | ||
| 561 | |||
| 562 | Returns: nothing | ||
| 563 | |||
| 564 | Deletes a version of a component from AWS IoT Greengrass. | ||
| 565 | |||
| 566 | This operation deletes the component's recipe and artifacts. As a | ||
| 567 | result, deployments that refer to this component version will fail. If | ||
| 568 | you have deployments that use this component version, you can remove | ||
| 569 | the component from the deployment or update the deployment to use a | ||
| 570 | valid version. | ||
| 571 | |||
| 572 | |||
| 573 | =head2 DeleteCoreDevice | ||
| 574 | |||
| 575 | =over | ||
| 576 | |||
| 577 | =item CoreDeviceThingName => Str | ||
| 578 | |||
| 579 | |||
| 580 | =back | ||
| 581 | |||
| 582 | Each argument is described in detail in: L<Paws::GreengrassV2::DeleteCoreDevice> | ||
| 583 | |||
| 584 | Returns: nothing | ||
| 585 | |||
| 586 | Deletes a AWS IoT Greengrass core device, which is an AWS IoT thing. | ||
| 587 | This operation removes the core device from the list of core devices. | ||
| 588 | This operation doesn't delete the AWS IoT thing. For more information | ||
| 589 | about how to delete the AWS IoT thing, see DeleteThing | ||
| 590 | (https://docs.aws.amazon.com/iot/latest/apireference/API_DeleteThing.html) | ||
| 591 | in the I<AWS IoT API Reference>. | ||
| 592 | |||
| 593 | |||
| 594 | =head2 DescribeComponent | ||
| 595 | |||
| 596 | =over | ||
| 597 | |||
| 598 | =item Arn => Str | ||
| 599 | |||
| 600 | |||
| 601 | =back | ||
| 602 | |||
| 603 | Each argument is described in detail in: L<Paws::GreengrassV2::DescribeComponent> | ||
| 604 | |||
| 605 | Returns: a L<Paws::GreengrassV2::DescribeComponentResponse> instance | ||
| 606 | |||
| 607 | Retrieves metadata for a version of a component. | ||
| 608 | |||
| 609 | |||
| 610 | =head2 GetComponent | ||
| 611 | |||
| 612 | =over | ||
| 613 | |||
| 614 | =item Arn => Str | ||
| 615 | |||
| 616 | =item [RecipeOutputFormat => Str] | ||
| 617 | |||
| 618 | |||
| 619 | =back | ||
| 620 | |||
| 621 | Each argument is described in detail in: L<Paws::GreengrassV2::GetComponent> | ||
| 622 | |||
| 623 | Returns: a L<Paws::GreengrassV2::GetComponentResponse> instance | ||
| 624 | |||
| 625 | Gets the recipe for a version of a component. Core devices can call | ||
| 626 | this operation to identify the artifacts and requirements to install a | ||
| 627 | component. | ||
| 628 | |||
| 629 | |||
| 630 | =head2 GetComponentVersionArtifact | ||
| 631 | |||
| 632 | =over | ||
| 633 | |||
| 634 | =item Arn => Str | ||
| 635 | |||
| 636 | =item ArtifactName => Str | ||
| 637 | |||
| 638 | |||
| 639 | =back | ||
| 640 | |||
| 641 | Each argument is described in detail in: L<Paws::GreengrassV2::GetComponentVersionArtifact> | ||
| 642 | |||
| 643 | Returns: a L<Paws::GreengrassV2::GetComponentVersionArtifactResponse> instance | ||
| 644 | |||
| 645 | Gets the pre-signed URL to download a public component artifact. Core | ||
| 646 | devices call this operation to identify the URL that they can use to | ||
| 647 | download an artifact to install. | ||
| 648 | |||
| 649 | |||
| 650 | =head2 GetCoreDevice | ||
| 651 | |||
| 652 | =over | ||
| 653 | |||
| 654 | =item CoreDeviceThingName => Str | ||
| 655 | |||
| 656 | |||
| 657 | =back | ||
| 658 | |||
| 659 | Each argument is described in detail in: L<Paws::GreengrassV2::GetCoreDevice> | ||
| 660 | |||
| 661 | Returns: a L<Paws::GreengrassV2::GetCoreDeviceResponse> instance | ||
| 662 | |||
| 663 | Retrieves metadata for a AWS IoT Greengrass core device. | ||
| 664 | |||
| 665 | |||
| 666 | =head2 GetDeployment | ||
| 667 | |||
| 668 | =over | ||
| 669 | |||
| 670 | =item DeploymentId => Str | ||
| 671 | |||
| 672 | |||
| 673 | =back | ||
| 674 | |||
| 675 | Each argument is described in detail in: L<Paws::GreengrassV2::GetDeployment> | ||
| 676 | |||
| 677 | Returns: a L<Paws::GreengrassV2::GetDeploymentResponse> instance | ||
| 678 | |||
| 679 | Gets a deployment. Deployments define the components that run on AWS | ||
| 680 | IoT Greengrass core devices. | ||
| 681 | |||
| 682 | |||
| 683 | =head2 ListClientDevicesAssociatedWithCoreDevice | ||
| 684 | |||
| 685 | =over | ||
| 686 | |||
| 687 | =item CoreDeviceThingName => Str | ||
| 688 | |||
| 689 | =item [MaxResults => Int] | ||
| 690 | |||
| 691 | =item [NextToken => Str] | ||
| 692 | |||
| 693 | |||
| 694 | =back | ||
| 695 | |||
| 696 | Each argument is described in detail in: L<Paws::GreengrassV2::ListClientDevicesAssociatedWithCoreDevice> | ||
| 697 | |||
| 698 | Returns: a L<Paws::GreengrassV2::ListClientDevicesAssociatedWithCoreDeviceResponse> instance | ||
| 699 | |||
| 700 | Retrieves a paginated list of client devices that are associated with a | ||
| 701 | core device. | ||
| 702 | |||
| 703 | |||
| 704 | =head2 ListComponents | ||
| 705 | |||
| 706 | =over | ||
| 707 | |||
| 708 | =item [MaxResults => Int] | ||
| 709 | |||
| 710 | =item [NextToken => Str] | ||
| 711 | |||
| 712 | =item [Scope => Str] | ||
| 713 | |||
| 714 | |||
| 715 | =back | ||
| 716 | |||
| 717 | Each argument is described in detail in: L<Paws::GreengrassV2::ListComponents> | ||
| 718 | |||
| 719 | Returns: a L<Paws::GreengrassV2::ListComponentsResponse> instance | ||
| 720 | |||
| 721 | Retrieves a paginated list of component summaries. This list includes | ||
| 722 | components that you have permission to view. | ||
| 723 | |||
| 724 | |||
| 725 | =head2 ListComponentVersions | ||
| 726 | |||
| 727 | =over | ||
| 728 | |||
| 729 | =item Arn => Str | ||
| 730 | |||
| 731 | =item [MaxResults => Int] | ||
| 732 | |||
| 733 | =item [NextToken => Str] | ||
| 734 | |||
| 735 | |||
| 736 | =back | ||
| 737 | |||
| 738 | Each argument is described in detail in: L<Paws::GreengrassV2::ListComponentVersions> | ||
| 739 | |||
| 740 | Returns: a L<Paws::GreengrassV2::ListComponentVersionsResponse> instance | ||
| 741 | |||
| 742 | Retrieves a paginated list of all versions for a component. Greater | ||
| 743 | versions are listed first. | ||
| 744 | |||
| 745 | |||
| 746 | =head2 ListCoreDevices | ||
| 747 | |||
| 748 | =over | ||
| 749 | |||
| 750 | =item [MaxResults => Int] | ||
| 751 | |||
| 752 | =item [NextToken => Str] | ||
| 753 | |||
| 754 | =item [Status => Str] | ||
| 755 | |||
| 756 | =item [ThingGroupArn => Str] | ||
| 757 | |||
| 758 | |||
| 759 | =back | ||
| 760 | |||
| 761 | Each argument is described in detail in: L<Paws::GreengrassV2::ListCoreDevices> | ||
| 762 | |||
| 763 | Returns: a L<Paws::GreengrassV2::ListCoreDevicesResponse> instance | ||
| 764 | |||
| 765 | Retrieves a paginated list of AWS IoT Greengrass core devices. | ||
| 766 | |||
| 767 | |||
| 768 | =head2 ListDeployments | ||
| 769 | |||
| 770 | =over | ||
| 771 | |||
| 772 | =item [HistoryFilter => Str] | ||
| 773 | |||
| 774 | =item [MaxResults => Int] | ||
| 775 | |||
| 776 | =item [NextToken => Str] | ||
| 777 | |||
| 778 | =item [TargetArn => Str] | ||
| 779 | |||
| 780 | |||
| 781 | =back | ||
| 782 | |||
| 783 | Each argument is described in detail in: L<Paws::GreengrassV2::ListDeployments> | ||
| 784 | |||
| 785 | Returns: a L<Paws::GreengrassV2::ListDeploymentsResponse> instance | ||
| 786 | |||
| 787 | Retrieves a paginated list of deployments. | ||
| 788 | |||
| 789 | |||
| 790 | =head2 ListEffectiveDeployments | ||
| 791 | |||
| 792 | =over | ||
| 793 | |||
| 794 | =item CoreDeviceThingName => Str | ||
| 795 | |||
| 796 | =item [MaxResults => Int] | ||
| 797 | |||
| 798 | =item [NextToken => Str] | ||
| 799 | |||
| 800 | |||
| 801 | =back | ||
| 802 | |||
| 803 | Each argument is described in detail in: L<Paws::GreengrassV2::ListEffectiveDeployments> | ||
| 804 | |||
| 805 | Returns: a L<Paws::GreengrassV2::ListEffectiveDeploymentsResponse> instance | ||
| 806 | |||
| 807 | Retrieves a paginated list of deployment jobs that AWS IoT Greengrass | ||
| 808 | sends to AWS IoT Greengrass core devices. | ||
| 809 | |||
| 810 | |||
| 811 | =head2 ListInstalledComponents | ||
| 812 | |||
| 813 | =over | ||
| 814 | |||
| 815 | =item CoreDeviceThingName => Str | ||
| 816 | |||
| 817 | =item [MaxResults => Int] | ||
| 818 | |||
| 819 | =item [NextToken => Str] | ||
| 820 | |||
| 821 | |||
| 822 | =back | ||
| 823 | |||
| 824 | Each argument is described in detail in: L<Paws::GreengrassV2::ListInstalledComponents> | ||
| 825 | |||
| 826 | Returns: a L<Paws::GreengrassV2::ListInstalledComponentsResponse> instance | ||
| 827 | |||
| 828 | Retrieves a paginated list of the components that a AWS IoT Greengrass | ||
| 829 | core device runs. | ||
| 830 | |||
| 831 | |||
| 832 | =head2 ListTagsForResource | ||
| 833 | |||
| 834 | =over | ||
| 835 | |||
| 836 | =item ResourceArn => Str | ||
| 837 | |||
| 838 | |||
| 839 | =back | ||
| 840 | |||
| 841 | Each argument is described in detail in: L<Paws::GreengrassV2::ListTagsForResource> | ||
| 842 | |||
| 843 | Returns: a L<Paws::GreengrassV2::ListTagsForResourceResponse> instance | ||
| 844 | |||
| 845 | Retrieves the list of tags for an AWS IoT Greengrass resource. | ||
| 846 | |||
| 847 | |||
| 848 | =head2 ResolveComponentCandidates | ||
| 849 | |||
| 850 | =over | ||
| 851 | |||
| 852 | =item ComponentCandidates => ArrayRef[L<Paws::GreengrassV2::ComponentCandidate>] | ||
| 853 | |||
| 854 | =item Platform => L<Paws::GreengrassV2::ComponentPlatform> | ||
| 855 | |||
| 856 | |||
| 857 | =back | ||
| 858 | |||
| 859 | Each argument is described in detail in: L<Paws::GreengrassV2::ResolveComponentCandidates> | ||
| 860 | |||
| 861 | Returns: a L<Paws::GreengrassV2::ResolveComponentCandidatesResponse> instance | ||
| 862 | |||
| 863 | Retrieves a list of components that meet the component, version, and | ||
| 864 | platform requirements of a deployment. AWS IoT Greengrass core devices | ||
| 865 | call this operation when they receive a deployment to identify the | ||
| 866 | components to install. | ||
| 867 | |||
| 868 | This operation identifies components that meet all dependency | ||
| 869 | requirements for a deployment. If the requirements conflict, then this | ||
| 870 | operation returns an error and the deployment fails. For example, this | ||
| 871 | occurs if component C<A> requires version C<E<gt>2.0.0> and component | ||
| 872 | C<B> requires version C<E<lt>2.0.0> of a component dependency. | ||
| 873 | |||
| 874 | When you specify the component candidates to resolve, AWS IoT | ||
| 875 | Greengrass compares each component's digest from the core device with | ||
| 876 | the component's digest in the AWS Cloud. If the digests don't match, | ||
| 877 | then AWS IoT Greengrass specifies to use the version from the AWS | ||
| 878 | Cloud. | ||
| 879 | |||
| 880 | To use this operation, you must use the data plane API endpoint and | ||
| 881 | authenticate with an AWS IoT device certificate. For more information, | ||
| 882 | see AWS IoT Greengrass endpoints and quotas | ||
| 883 | (https://docs.aws.amazon.com/general/latest/gr/greengrass.html). | ||
| 884 | |||
| 885 | |||
| 886 | =head2 TagResource | ||
| 887 | |||
| 888 | =over | ||
| 889 | |||
| 890 | =item ResourceArn => Str | ||
| 891 | |||
| 892 | =item Tags => L<Paws::GreengrassV2::TagMap> | ||
| 893 | |||
| 894 | |||
| 895 | =back | ||
| 896 | |||
| 897 | Each argument is described in detail in: L<Paws::GreengrassV2::TagResource> | ||
| 898 | |||
| 899 | Returns: a L<Paws::GreengrassV2::TagResourceResponse> instance | ||
| 900 | |||
| 901 | Adds tags to an AWS IoT Greengrass resource. If a tag already exists | ||
| 902 | for the resource, this operation updates the tag's value. | ||
| 903 | |||
| 904 | |||
| 905 | =head2 UntagResource | ||
| 906 | |||
| 907 | =over | ||
| 908 | |||
| 909 | =item ResourceArn => Str | ||
| 910 | |||
| 911 | =item TagKeys => ArrayRef[Str|Undef] | ||
| 912 | |||
| 913 | |||
| 914 | =back | ||
| 915 | |||
| 916 | Each argument is described in detail in: L<Paws::GreengrassV2::UntagResource> | ||
| 917 | |||
| 918 | Returns: a L<Paws::GreengrassV2::UntagResourceResponse> instance | ||
| 919 | |||
| 920 | Removes a tag from an AWS IoT Greengrass resource. | ||
| 921 | |||
| 922 | |||
| 923 | |||
| 924 | |||
| 925 | =head1 PAGINATORS | ||
| 926 | |||
| 927 | Paginator methods are helpers that repetively call methods that return partial results | ||
| 928 | |||
| 929 | =head2 ListAllClientDevicesAssociatedWithCoreDevice(sub { },CoreDeviceThingName => Str, [MaxResults => Int, NextToken => Str]) | ||
| 930 | |||
| 931 | =head2 ListAllClientDevicesAssociatedWithCoreDevice(CoreDeviceThingName => Str, [MaxResults => Int, NextToken => Str]) | ||
| 932 | |||
| 933 | |||
| 934 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 935 | |||
| 936 | - associatedClientDevices, passing the object as the first parameter, and the string 'associatedClientDevices' as the second parameter | ||
| 937 | |||
| 938 | If not, it will return a a L<Paws::GreengrassV2::ListClientDevicesAssociatedWithCoreDeviceResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory. | ||
| 939 | |||
| 940 | |||
| 941 | =head2 ListAllComponents(sub { },[MaxResults => Int, NextToken => Str, Scope => Str]) | ||
| 942 | |||
| 943 | =head2 ListAllComponents([MaxResults => Int, NextToken => Str, Scope => Str]) | ||
| 944 | |||
| 945 | |||
| 946 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 947 | |||
| 948 | - components, passing the object as the first parameter, and the string 'components' as the second parameter | ||
| 949 | |||
| 950 | If not, it will return a a L<Paws::GreengrassV2::ListComponentsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory. | ||
| 951 | |||
| 952 | |||
| 953 | =head2 ListAllComponentVersions(sub { },Arn => Str, [MaxResults => Int, NextToken => Str]) | ||
| 954 | |||
| 955 | =head2 ListAllComponentVersions(Arn => Str, [MaxResults => Int, NextToken => Str]) | ||
| 956 | |||
| 957 | |||
| 958 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 959 | |||
| 960 | - componentVersions, passing the object as the first parameter, and the string 'componentVersions' as the second parameter | ||
| 961 | |||
| 962 | If not, it will return a a L<Paws::GreengrassV2::ListComponentVersionsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory. | ||
| 963 | |||
| 964 | |||
| 965 | =head2 ListAllCoreDevices(sub { },[MaxResults => Int, NextToken => Str, Status => Str, ThingGroupArn => Str]) | ||
| 966 | |||
| 967 | =head2 ListAllCoreDevices([MaxResults => Int, NextToken => Str, Status => Str, ThingGroupArn => Str]) | ||
| 968 | |||
| 969 | |||
| 970 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 971 | |||
| 972 | - coreDevices, passing the object as the first parameter, and the string 'coreDevices' as the second parameter | ||
| 973 | |||
| 974 | If not, it will return a a L<Paws::GreengrassV2::ListCoreDevicesResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory. | ||
| 975 | |||
| 976 | |||
| 977 | =head2 ListAllDeployments(sub { },[HistoryFilter => Str, MaxResults => Int, NextToken => Str, TargetArn => Str]) | ||
| 978 | |||
| 979 | =head2 ListAllDeployments([HistoryFilter => Str, MaxResults => Int, NextToken => Str, TargetArn => Str]) | ||
| 980 | |||
| 981 | |||
| 982 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 983 | |||
| 984 | - deployments, passing the object as the first parameter, and the string 'deployments' as the second parameter | ||
| 985 | |||
| 986 | If not, it will return a a L<Paws::GreengrassV2::ListDeploymentsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory. | ||
| 987 | |||
| 988 | |||
| 989 | =head2 ListAllEffectiveDeployments(sub { },CoreDeviceThingName => Str, [MaxResults => Int, NextToken => Str]) | ||
| 990 | |||
| 991 | =head2 ListAllEffectiveDeployments(CoreDeviceThingName => Str, [MaxResults => Int, NextToken => Str]) | ||
| 992 | |||
| 993 | |||
| 994 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 995 | |||
| 996 | - effectiveDeployments, passing the object as the first parameter, and the string 'effectiveDeployments' as the second parameter | ||
| 997 | |||
| 998 | If not, it will return a a L<Paws::GreengrassV2::ListEffectiveDeploymentsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory. | ||
| 999 | |||
| 1000 | |||
| 1001 | =head2 ListAllInstalledComponents(sub { },CoreDeviceThingName => Str, [MaxResults => Int, NextToken => Str]) | ||
| 1002 | |||
| 1003 | =head2 ListAllInstalledComponents(CoreDeviceThingName => Str, [MaxResults => Int, NextToken => Str]) | ||
| 1004 | |||
| 1005 | |||
| 1006 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 1007 | |||
| 1008 | - installedComponents, passing the object as the first parameter, and the string 'installedComponents' as the second parameter | ||
| 1009 | |||
| 1010 | If not, it will return a a L<Paws::GreengrassV2::ListInstalledComponentsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory. | ||
| 1011 | |||
| 1012 | |||
| 1013 | |||
| 1014 | |||
| 1015 | |||
| 1016 | =head1 SEE ALSO | ||
| 1017 | |||
| 1018 | This service class forms part of L<Paws> | ||
| 1019 | |||
| 1020 | =head1 BUGS and CONTRIBUTIONS | ||
| 1021 | |||
| 1022 | The source code is located here: L<https://github.com/pplu/aws-sdk-perl> | ||
| 1023 | |||
| 1024 | Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues> | ||
| 1025 | |||
| 1026 | =cut | ||
| 1027 |