| 1 | package Paws::Greengrass; | ||
| 2 | use Moose; | ||
| 3 | sub service { 'greengrass' } | ||
| 4 | sub signing_name { 'greengrass' } | ||
| 5 | sub version { '2017-06-07' } | ||
| 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 AssociateRoleToGroup { | ||
| 18 | my $self = shift; | ||
| 19 | my $call_object = $self->new_with_coercions('Paws::Greengrass::AssociateRoleToGroup', @_); | ||
| 20 | return $self->caller->do_call($self, $call_object); | ||
| 21 | } | ||
| 22 | sub AssociateServiceRoleToAccount { | ||
| 23 | my $self = shift; | ||
| 24 | my $call_object = $self->new_with_coercions('Paws::Greengrass::AssociateServiceRoleToAccount', @_); | ||
| 25 | return $self->caller->do_call($self, $call_object); | ||
| 26 | } | ||
| 27 | sub CreateConnectorDefinition { | ||
| 28 | my $self = shift; | ||
| 29 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateConnectorDefinition', @_); | ||
| 30 | return $self->caller->do_call($self, $call_object); | ||
| 31 | } | ||
| 32 | sub CreateConnectorDefinitionVersion { | ||
| 33 | my $self = shift; | ||
| 34 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateConnectorDefinitionVersion', @_); | ||
| 35 | return $self->caller->do_call($self, $call_object); | ||
| 36 | } | ||
| 37 | sub CreateCoreDefinition { | ||
| 38 | my $self = shift; | ||
| 39 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateCoreDefinition', @_); | ||
| 40 | return $self->caller->do_call($self, $call_object); | ||
| 41 | } | ||
| 42 | sub CreateCoreDefinitionVersion { | ||
| 43 | my $self = shift; | ||
| 44 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateCoreDefinitionVersion', @_); | ||
| 45 | return $self->caller->do_call($self, $call_object); | ||
| 46 | } | ||
| 47 | sub CreateDeployment { | ||
| 48 | my $self = shift; | ||
| 49 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateDeployment', @_); | ||
| 50 | return $self->caller->do_call($self, $call_object); | ||
| 51 | } | ||
| 52 | sub CreateDeviceDefinition { | ||
| 53 | my $self = shift; | ||
| 54 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateDeviceDefinition', @_); | ||
| 55 | return $self->caller->do_call($self, $call_object); | ||
| 56 | } | ||
| 57 | sub CreateDeviceDefinitionVersion { | ||
| 58 | my $self = shift; | ||
| 59 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateDeviceDefinitionVersion', @_); | ||
| 60 | return $self->caller->do_call($self, $call_object); | ||
| 61 | } | ||
| 62 | sub CreateFunctionDefinition { | ||
| 63 | my $self = shift; | ||
| 64 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateFunctionDefinition', @_); | ||
| 65 | return $self->caller->do_call($self, $call_object); | ||
| 66 | } | ||
| 67 | sub CreateFunctionDefinitionVersion { | ||
| 68 | my $self = shift; | ||
| 69 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateFunctionDefinitionVersion', @_); | ||
| 70 | return $self->caller->do_call($self, $call_object); | ||
| 71 | } | ||
| 72 | sub CreateGroup { | ||
| 73 | my $self = shift; | ||
| 74 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateGroup', @_); | ||
| 75 | return $self->caller->do_call($self, $call_object); | ||
| 76 | } | ||
| 77 | sub CreateGroupCertificateAuthority { | ||
| 78 | my $self = shift; | ||
| 79 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateGroupCertificateAuthority', @_); | ||
| 80 | return $self->caller->do_call($self, $call_object); | ||
| 81 | } | ||
| 82 | sub CreateGroupVersion { | ||
| 83 | my $self = shift; | ||
| 84 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateGroupVersion', @_); | ||
| 85 | return $self->caller->do_call($self, $call_object); | ||
| 86 | } | ||
| 87 | sub CreateLoggerDefinition { | ||
| 88 | my $self = shift; | ||
| 89 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateLoggerDefinition', @_); | ||
| 90 | return $self->caller->do_call($self, $call_object); | ||
| 91 | } | ||
| 92 | sub CreateLoggerDefinitionVersion { | ||
| 93 | my $self = shift; | ||
| 94 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateLoggerDefinitionVersion', @_); | ||
| 95 | return $self->caller->do_call($self, $call_object); | ||
| 96 | } | ||
| 97 | sub CreateResourceDefinition { | ||
| 98 | my $self = shift; | ||
| 99 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateResourceDefinition', @_); | ||
| 100 | return $self->caller->do_call($self, $call_object); | ||
| 101 | } | ||
| 102 | sub CreateResourceDefinitionVersion { | ||
| 103 | my $self = shift; | ||
| 104 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateResourceDefinitionVersion', @_); | ||
| 105 | return $self->caller->do_call($self, $call_object); | ||
| 106 | } | ||
| 107 | sub CreateSoftwareUpdateJob { | ||
| 108 | my $self = shift; | ||
| 109 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateSoftwareUpdateJob', @_); | ||
| 110 | return $self->caller->do_call($self, $call_object); | ||
| 111 | } | ||
| 112 | sub CreateSubscriptionDefinition { | ||
| 113 | my $self = shift; | ||
| 114 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateSubscriptionDefinition', @_); | ||
| 115 | return $self->caller->do_call($self, $call_object); | ||
| 116 | } | ||
| 117 | sub CreateSubscriptionDefinitionVersion { | ||
| 118 | my $self = shift; | ||
| 119 | my $call_object = $self->new_with_coercions('Paws::Greengrass::CreateSubscriptionDefinitionVersion', @_); | ||
| 120 | return $self->caller->do_call($self, $call_object); | ||
| 121 | } | ||
| 122 | sub DeleteConnectorDefinition { | ||
| 123 | my $self = shift; | ||
| 124 | my $call_object = $self->new_with_coercions('Paws::Greengrass::DeleteConnectorDefinition', @_); | ||
| 125 | return $self->caller->do_call($self, $call_object); | ||
| 126 | } | ||
| 127 | sub DeleteCoreDefinition { | ||
| 128 | my $self = shift; | ||
| 129 | my $call_object = $self->new_with_coercions('Paws::Greengrass::DeleteCoreDefinition', @_); | ||
| 130 | return $self->caller->do_call($self, $call_object); | ||
| 131 | } | ||
| 132 | sub DeleteDeviceDefinition { | ||
| 133 | my $self = shift; | ||
| 134 | my $call_object = $self->new_with_coercions('Paws::Greengrass::DeleteDeviceDefinition', @_); | ||
| 135 | return $self->caller->do_call($self, $call_object); | ||
| 136 | } | ||
| 137 | sub DeleteFunctionDefinition { | ||
| 138 | my $self = shift; | ||
| 139 | my $call_object = $self->new_with_coercions('Paws::Greengrass::DeleteFunctionDefinition', @_); | ||
| 140 | return $self->caller->do_call($self, $call_object); | ||
| 141 | } | ||
| 142 | sub DeleteGroup { | ||
| 143 | my $self = shift; | ||
| 144 | my $call_object = $self->new_with_coercions('Paws::Greengrass::DeleteGroup', @_); | ||
| 145 | return $self->caller->do_call($self, $call_object); | ||
| 146 | } | ||
| 147 | sub DeleteLoggerDefinition { | ||
| 148 | my $self = shift; | ||
| 149 | my $call_object = $self->new_with_coercions('Paws::Greengrass::DeleteLoggerDefinition', @_); | ||
| 150 | return $self->caller->do_call($self, $call_object); | ||
| 151 | } | ||
| 152 | sub DeleteResourceDefinition { | ||
| 153 | my $self = shift; | ||
| 154 | my $call_object = $self->new_with_coercions('Paws::Greengrass::DeleteResourceDefinition', @_); | ||
| 155 | return $self->caller->do_call($self, $call_object); | ||
| 156 | } | ||
| 157 | sub DeleteSubscriptionDefinition { | ||
| 158 | my $self = shift; | ||
| 159 | my $call_object = $self->new_with_coercions('Paws::Greengrass::DeleteSubscriptionDefinition', @_); | ||
| 160 | return $self->caller->do_call($self, $call_object); | ||
| 161 | } | ||
| 162 | sub DisassociateRoleFromGroup { | ||
| 163 | my $self = shift; | ||
| 164 | my $call_object = $self->new_with_coercions('Paws::Greengrass::DisassociateRoleFromGroup', @_); | ||
| 165 | return $self->caller->do_call($self, $call_object); | ||
| 166 | } | ||
| 167 | sub DisassociateServiceRoleFromAccount { | ||
| 168 | my $self = shift; | ||
| 169 | my $call_object = $self->new_with_coercions('Paws::Greengrass::DisassociateServiceRoleFromAccount', @_); | ||
| 170 | return $self->caller->do_call($self, $call_object); | ||
| 171 | } | ||
| 172 | sub GetAssociatedRole { | ||
| 173 | my $self = shift; | ||
| 174 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetAssociatedRole', @_); | ||
| 175 | return $self->caller->do_call($self, $call_object); | ||
| 176 | } | ||
| 177 | sub GetBulkDeploymentStatus { | ||
| 178 | my $self = shift; | ||
| 179 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetBulkDeploymentStatus', @_); | ||
| 180 | return $self->caller->do_call($self, $call_object); | ||
| 181 | } | ||
| 182 | sub GetConnectivityInfo { | ||
| 183 | my $self = shift; | ||
| 184 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetConnectivityInfo', @_); | ||
| 185 | return $self->caller->do_call($self, $call_object); | ||
| 186 | } | ||
| 187 | sub GetConnectorDefinition { | ||
| 188 | my $self = shift; | ||
| 189 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetConnectorDefinition', @_); | ||
| 190 | return $self->caller->do_call($self, $call_object); | ||
| 191 | } | ||
| 192 | sub GetConnectorDefinitionVersion { | ||
| 193 | my $self = shift; | ||
| 194 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetConnectorDefinitionVersion', @_); | ||
| 195 | return $self->caller->do_call($self, $call_object); | ||
| 196 | } | ||
| 197 | sub GetCoreDefinition { | ||
| 198 | my $self = shift; | ||
| 199 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetCoreDefinition', @_); | ||
| 200 | return $self->caller->do_call($self, $call_object); | ||
| 201 | } | ||
| 202 | sub GetCoreDefinitionVersion { | ||
| 203 | my $self = shift; | ||
| 204 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetCoreDefinitionVersion', @_); | ||
| 205 | return $self->caller->do_call($self, $call_object); | ||
| 206 | } | ||
| 207 | sub GetDeploymentStatus { | ||
| 208 | my $self = shift; | ||
| 209 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetDeploymentStatus', @_); | ||
| 210 | return $self->caller->do_call($self, $call_object); | ||
| 211 | } | ||
| 212 | sub GetDeviceDefinition { | ||
| 213 | my $self = shift; | ||
| 214 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetDeviceDefinition', @_); | ||
| 215 | return $self->caller->do_call($self, $call_object); | ||
| 216 | } | ||
| 217 | sub GetDeviceDefinitionVersion { | ||
| 218 | my $self = shift; | ||
| 219 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetDeviceDefinitionVersion', @_); | ||
| 220 | return $self->caller->do_call($self, $call_object); | ||
| 221 | } | ||
| 222 | sub GetFunctionDefinition { | ||
| 223 | my $self = shift; | ||
| 224 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetFunctionDefinition', @_); | ||
| 225 | return $self->caller->do_call($self, $call_object); | ||
| 226 | } | ||
| 227 | sub GetFunctionDefinitionVersion { | ||
| 228 | my $self = shift; | ||
| 229 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetFunctionDefinitionVersion', @_); | ||
| 230 | return $self->caller->do_call($self, $call_object); | ||
| 231 | } | ||
| 232 | sub GetGroup { | ||
| 233 | my $self = shift; | ||
| 234 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetGroup', @_); | ||
| 235 | return $self->caller->do_call($self, $call_object); | ||
| 236 | } | ||
| 237 | sub GetGroupCertificateAuthority { | ||
| 238 | my $self = shift; | ||
| 239 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetGroupCertificateAuthority', @_); | ||
| 240 | return $self->caller->do_call($self, $call_object); | ||
| 241 | } | ||
| 242 | sub GetGroupCertificateConfiguration { | ||
| 243 | my $self = shift; | ||
| 244 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetGroupCertificateConfiguration', @_); | ||
| 245 | return $self->caller->do_call($self, $call_object); | ||
| 246 | } | ||
| 247 | sub GetGroupVersion { | ||
| 248 | my $self = shift; | ||
| 249 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetGroupVersion', @_); | ||
| 250 | return $self->caller->do_call($self, $call_object); | ||
| 251 | } | ||
| 252 | sub GetLoggerDefinition { | ||
| 253 | my $self = shift; | ||
| 254 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetLoggerDefinition', @_); | ||
| 255 | return $self->caller->do_call($self, $call_object); | ||
| 256 | } | ||
| 257 | sub GetLoggerDefinitionVersion { | ||
| 258 | my $self = shift; | ||
| 259 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetLoggerDefinitionVersion', @_); | ||
| 260 | return $self->caller->do_call($self, $call_object); | ||
| 261 | } | ||
| 262 | sub GetResourceDefinition { | ||
| 263 | my $self = shift; | ||
| 264 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetResourceDefinition', @_); | ||
| 265 | return $self->caller->do_call($self, $call_object); | ||
| 266 | } | ||
| 267 | sub GetResourceDefinitionVersion { | ||
| 268 | my $self = shift; | ||
| 269 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetResourceDefinitionVersion', @_); | ||
| 270 | return $self->caller->do_call($self, $call_object); | ||
| 271 | } | ||
| 272 | sub GetServiceRoleForAccount { | ||
| 273 | my $self = shift; | ||
| 274 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetServiceRoleForAccount', @_); | ||
| 275 | return $self->caller->do_call($self, $call_object); | ||
| 276 | } | ||
| 277 | sub GetSubscriptionDefinition { | ||
| 278 | my $self = shift; | ||
| 279 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetSubscriptionDefinition', @_); | ||
| 280 | return $self->caller->do_call($self, $call_object); | ||
| 281 | } | ||
| 282 | sub GetSubscriptionDefinitionVersion { | ||
| 283 | my $self = shift; | ||
| 284 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetSubscriptionDefinitionVersion', @_); | ||
| 285 | return $self->caller->do_call($self, $call_object); | ||
| 286 | } | ||
| 287 | sub GetThingRuntimeConfiguration { | ||
| 288 | my $self = shift; | ||
| 289 | my $call_object = $self->new_with_coercions('Paws::Greengrass::GetThingRuntimeConfiguration', @_); | ||
| 290 | return $self->caller->do_call($self, $call_object); | ||
| 291 | } | ||
| 292 | sub ListBulkDeploymentDetailedReports { | ||
| 293 | my $self = shift; | ||
| 294 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListBulkDeploymentDetailedReports', @_); | ||
| 295 | return $self->caller->do_call($self, $call_object); | ||
| 296 | } | ||
| 297 | sub ListBulkDeployments { | ||
| 298 | my $self = shift; | ||
| 299 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListBulkDeployments', @_); | ||
| 300 | return $self->caller->do_call($self, $call_object); | ||
| 301 | } | ||
| 302 | sub ListConnectorDefinitions { | ||
| 303 | my $self = shift; | ||
| 304 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListConnectorDefinitions', @_); | ||
| 305 | return $self->caller->do_call($self, $call_object); | ||
| 306 | } | ||
| 307 | sub ListConnectorDefinitionVersions { | ||
| 308 | my $self = shift; | ||
| 309 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListConnectorDefinitionVersions', @_); | ||
| 310 | return $self->caller->do_call($self, $call_object); | ||
| 311 | } | ||
| 312 | sub ListCoreDefinitions { | ||
| 313 | my $self = shift; | ||
| 314 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListCoreDefinitions', @_); | ||
| 315 | return $self->caller->do_call($self, $call_object); | ||
| 316 | } | ||
| 317 | sub ListCoreDefinitionVersions { | ||
| 318 | my $self = shift; | ||
| 319 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListCoreDefinitionVersions', @_); | ||
| 320 | return $self->caller->do_call($self, $call_object); | ||
| 321 | } | ||
| 322 | sub ListDeployments { | ||
| 323 | my $self = shift; | ||
| 324 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListDeployments', @_); | ||
| 325 | return $self->caller->do_call($self, $call_object); | ||
| 326 | } | ||
| 327 | sub ListDeviceDefinitions { | ||
| 328 | my $self = shift; | ||
| 329 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListDeviceDefinitions', @_); | ||
| 330 | return $self->caller->do_call($self, $call_object); | ||
| 331 | } | ||
| 332 | sub ListDeviceDefinitionVersions { | ||
| 333 | my $self = shift; | ||
| 334 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListDeviceDefinitionVersions', @_); | ||
| 335 | return $self->caller->do_call($self, $call_object); | ||
| 336 | } | ||
| 337 | sub ListFunctionDefinitions { | ||
| 338 | my $self = shift; | ||
| 339 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListFunctionDefinitions', @_); | ||
| 340 | return $self->caller->do_call($self, $call_object); | ||
| 341 | } | ||
| 342 | sub ListFunctionDefinitionVersions { | ||
| 343 | my $self = shift; | ||
| 344 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListFunctionDefinitionVersions', @_); | ||
| 345 | return $self->caller->do_call($self, $call_object); | ||
| 346 | } | ||
| 347 | sub ListGroupCertificateAuthorities { | ||
| 348 | my $self = shift; | ||
| 349 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListGroupCertificateAuthorities', @_); | ||
| 350 | return $self->caller->do_call($self, $call_object); | ||
| 351 | } | ||
| 352 | sub ListGroups { | ||
| 353 | my $self = shift; | ||
| 354 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListGroups', @_); | ||
| 355 | return $self->caller->do_call($self, $call_object); | ||
| 356 | } | ||
| 357 | sub ListGroupVersions { | ||
| 358 | my $self = shift; | ||
| 359 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListGroupVersions', @_); | ||
| 360 | return $self->caller->do_call($self, $call_object); | ||
| 361 | } | ||
| 362 | sub ListLoggerDefinitions { | ||
| 363 | my $self = shift; | ||
| 364 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListLoggerDefinitions', @_); | ||
| 365 | return $self->caller->do_call($self, $call_object); | ||
| 366 | } | ||
| 367 | sub ListLoggerDefinitionVersions { | ||
| 368 | my $self = shift; | ||
| 369 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListLoggerDefinitionVersions', @_); | ||
| 370 | return $self->caller->do_call($self, $call_object); | ||
| 371 | } | ||
| 372 | sub ListResourceDefinitions { | ||
| 373 | my $self = shift; | ||
| 374 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListResourceDefinitions', @_); | ||
| 375 | return $self->caller->do_call($self, $call_object); | ||
| 376 | } | ||
| 377 | sub ListResourceDefinitionVersions { | ||
| 378 | my $self = shift; | ||
| 379 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListResourceDefinitionVersions', @_); | ||
| 380 | return $self->caller->do_call($self, $call_object); | ||
| 381 | } | ||
| 382 | sub ListSubscriptionDefinitions { | ||
| 383 | my $self = shift; | ||
| 384 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListSubscriptionDefinitions', @_); | ||
| 385 | return $self->caller->do_call($self, $call_object); | ||
| 386 | } | ||
| 387 | sub ListSubscriptionDefinitionVersions { | ||
| 388 | my $self = shift; | ||
| 389 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListSubscriptionDefinitionVersions', @_); | ||
| 390 | return $self->caller->do_call($self, $call_object); | ||
| 391 | } | ||
| 392 | sub ListTagsForResource { | ||
| 393 | my $self = shift; | ||
| 394 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ListTagsForResource', @_); | ||
| 395 | return $self->caller->do_call($self, $call_object); | ||
| 396 | } | ||
| 397 | sub ResetDeployments { | ||
| 398 | my $self = shift; | ||
| 399 | my $call_object = $self->new_with_coercions('Paws::Greengrass::ResetDeployments', @_); | ||
| 400 | return $self->caller->do_call($self, $call_object); | ||
| 401 | } | ||
| 402 | sub StartBulkDeployment { | ||
| 403 | my $self = shift; | ||
| 404 | my $call_object = $self->new_with_coercions('Paws::Greengrass::StartBulkDeployment', @_); | ||
| 405 | return $self->caller->do_call($self, $call_object); | ||
| 406 | } | ||
| 407 | sub StopBulkDeployment { | ||
| 408 | my $self = shift; | ||
| 409 | my $call_object = $self->new_with_coercions('Paws::Greengrass::StopBulkDeployment', @_); | ||
| 410 | return $self->caller->do_call($self, $call_object); | ||
| 411 | } | ||
| 412 | sub TagResource { | ||
| 413 | my $self = shift; | ||
| 414 | my $call_object = $self->new_with_coercions('Paws::Greengrass::TagResource', @_); | ||
| 415 | return $self->caller->do_call($self, $call_object); | ||
| 416 | } | ||
| 417 | sub UntagResource { | ||
| 418 | my $self = shift; | ||
| 419 | my $call_object = $self->new_with_coercions('Paws::Greengrass::UntagResource', @_); | ||
| 420 | return $self->caller->do_call($self, $call_object); | ||
| 421 | } | ||
| 422 | sub UpdateConnectivityInfo { | ||
| 423 | my $self = shift; | ||
| 424 | my $call_object = $self->new_with_coercions('Paws::Greengrass::UpdateConnectivityInfo', @_); | ||
| 425 | return $self->caller->do_call($self, $call_object); | ||
| 426 | } | ||
| 427 | sub UpdateConnectorDefinition { | ||
| 428 | my $self = shift; | ||
| 429 | my $call_object = $self->new_with_coercions('Paws::Greengrass::UpdateConnectorDefinition', @_); | ||
| 430 | return $self->caller->do_call($self, $call_object); | ||
| 431 | } | ||
| 432 | sub UpdateCoreDefinition { | ||
| 433 | my $self = shift; | ||
| 434 | my $call_object = $self->new_with_coercions('Paws::Greengrass::UpdateCoreDefinition', @_); | ||
| 435 | return $self->caller->do_call($self, $call_object); | ||
| 436 | } | ||
| 437 | sub UpdateDeviceDefinition { | ||
| 438 | my $self = shift; | ||
| 439 | my $call_object = $self->new_with_coercions('Paws::Greengrass::UpdateDeviceDefinition', @_); | ||
| 440 | return $self->caller->do_call($self, $call_object); | ||
| 441 | } | ||
| 442 | sub UpdateFunctionDefinition { | ||
| 443 | my $self = shift; | ||
| 444 | my $call_object = $self->new_with_coercions('Paws::Greengrass::UpdateFunctionDefinition', @_); | ||
| 445 | return $self->caller->do_call($self, $call_object); | ||
| 446 | } | ||
| 447 | sub UpdateGroup { | ||
| 448 | my $self = shift; | ||
| 449 | my $call_object = $self->new_with_coercions('Paws::Greengrass::UpdateGroup', @_); | ||
| 450 | return $self->caller->do_call($self, $call_object); | ||
| 451 | } | ||
| 452 | sub UpdateGroupCertificateConfiguration { | ||
| 453 | my $self = shift; | ||
| 454 | my $call_object = $self->new_with_coercions('Paws::Greengrass::UpdateGroupCertificateConfiguration', @_); | ||
| 455 | return $self->caller->do_call($self, $call_object); | ||
| 456 | } | ||
| 457 | sub UpdateLoggerDefinition { | ||
| 458 | my $self = shift; | ||
| 459 | my $call_object = $self->new_with_coercions('Paws::Greengrass::UpdateLoggerDefinition', @_); | ||
| 460 | return $self->caller->do_call($self, $call_object); | ||
| 461 | } | ||
| 462 | sub UpdateResourceDefinition { | ||
| 463 | my $self = shift; | ||
| 464 | my $call_object = $self->new_with_coercions('Paws::Greengrass::UpdateResourceDefinition', @_); | ||
| 465 | return $self->caller->do_call($self, $call_object); | ||
| 466 | } | ||
| 467 | sub UpdateSubscriptionDefinition { | ||
| 468 | my $self = shift; | ||
| 469 | my $call_object = $self->new_with_coercions('Paws::Greengrass::UpdateSubscriptionDefinition', @_); | ||
| 470 | return $self->caller->do_call($self, $call_object); | ||
| 471 | } | ||
| 472 | sub UpdateThingRuntimeConfiguration { | ||
| 473 | my $self = shift; | ||
| 474 | my $call_object = $self->new_with_coercions('Paws::Greengrass::UpdateThingRuntimeConfiguration', @_); | ||
| 475 | return $self->caller->do_call($self, $call_object); | ||
| 476 | } | ||
| 477 | |||
| 478 | sub ListAllBulkDeploymentDetailedReports { | ||
| 479 | my $self = shift; | ||
| 480 | |||
| 481 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 482 | my $result = $self->ListBulkDeploymentDetailedReports(@_); | ||
| 483 | my $next_result = $result; | ||
| 484 | |||
| 485 | if (not defined $callback) { | ||
| 486 | while ($next_result->NextToken) { | ||
| 487 | $next_result = $self->ListBulkDeploymentDetailedReports(@_, NextToken => $next_result->NextToken); | ||
| 488 | push @{ $result->Deployments }, @{ $next_result->Deployments }; | ||
| 489 | } | ||
| 490 | return $result; | ||
| 491 | } else { | ||
| 492 | while ($result->NextToken) { | ||
| 493 | $callback->($_ => 'Deployments') foreach (@{ $result->Deployments }); | ||
| 494 | $result = $self->ListBulkDeploymentDetailedReports(@_, NextToken => $result->NextToken); | ||
| 495 | } | ||
| 496 | $callback->($_ => 'Deployments') foreach (@{ $result->Deployments }); | ||
| 497 | } | ||
| 498 | |||
| 499 | return undef | ||
| 500 | } | ||
| 501 | sub ListAllBulkDeployments { | ||
| 502 | my $self = shift; | ||
| 503 | |||
| 504 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 505 | my $result = $self->ListBulkDeployments(@_); | ||
| 506 | my $next_result = $result; | ||
| 507 | |||
| 508 | if (not defined $callback) { | ||
| 509 | while ($next_result->NextToken) { | ||
| 510 | $next_result = $self->ListBulkDeployments(@_, NextToken => $next_result->NextToken); | ||
| 511 | push @{ $result->BulkDeployments }, @{ $next_result->BulkDeployments }; | ||
| 512 | } | ||
| 513 | return $result; | ||
| 514 | } else { | ||
| 515 | while ($result->NextToken) { | ||
| 516 | $callback->($_ => 'BulkDeployments') foreach (@{ $result->BulkDeployments }); | ||
| 517 | $result = $self->ListBulkDeployments(@_, NextToken => $result->NextToken); | ||
| 518 | } | ||
| 519 | $callback->($_ => 'BulkDeployments') foreach (@{ $result->BulkDeployments }); | ||
| 520 | } | ||
| 521 | |||
| 522 | return undef | ||
| 523 | } | ||
| 524 | sub ListAllConnectorDefinitions { | ||
| 525 | my $self = shift; | ||
| 526 | |||
| 527 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 528 | my $result = $self->ListConnectorDefinitions(@_); | ||
| 529 | my $next_result = $result; | ||
| 530 | |||
| 531 | if (not defined $callback) { | ||
| 532 | while ($next_result->NextToken) { | ||
| 533 | $next_result = $self->ListConnectorDefinitions(@_, NextToken => $next_result->NextToken); | ||
| 534 | push @{ $result->Definitions }, @{ $next_result->Definitions }; | ||
| 535 | } | ||
| 536 | return $result; | ||
| 537 | } else { | ||
| 538 | while ($result->NextToken) { | ||
| 539 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 540 | $result = $self->ListConnectorDefinitions(@_, NextToken => $result->NextToken); | ||
| 541 | } | ||
| 542 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 543 | } | ||
| 544 | |||
| 545 | return undef | ||
| 546 | } | ||
| 547 | sub ListAllConnectorDefinitionVersions { | ||
| 548 | my $self = shift; | ||
| 549 | |||
| 550 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 551 | my $result = $self->ListConnectorDefinitionVersions(@_); | ||
| 552 | my $next_result = $result; | ||
| 553 | |||
| 554 | if (not defined $callback) { | ||
| 555 | while ($next_result->NextToken) { | ||
| 556 | $next_result = $self->ListConnectorDefinitionVersions(@_, NextToken => $next_result->NextToken); | ||
| 557 | push @{ $result->Versions }, @{ $next_result->Versions }; | ||
| 558 | } | ||
| 559 | return $result; | ||
| 560 | } else { | ||
| 561 | while ($result->NextToken) { | ||
| 562 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 563 | $result = $self->ListConnectorDefinitionVersions(@_, NextToken => $result->NextToken); | ||
| 564 | } | ||
| 565 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 566 | } | ||
| 567 | |||
| 568 | return undef | ||
| 569 | } | ||
| 570 | sub ListAllCoreDefinitions { | ||
| 571 | my $self = shift; | ||
| 572 | |||
| 573 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 574 | my $result = $self->ListCoreDefinitions(@_); | ||
| 575 | my $next_result = $result; | ||
| 576 | |||
| 577 | if (not defined $callback) { | ||
| 578 | while ($next_result->NextToken) { | ||
| 579 | $next_result = $self->ListCoreDefinitions(@_, NextToken => $next_result->NextToken); | ||
| 580 | push @{ $result->Definitions }, @{ $next_result->Definitions }; | ||
| 581 | } | ||
| 582 | return $result; | ||
| 583 | } else { | ||
| 584 | while ($result->NextToken) { | ||
| 585 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 586 | $result = $self->ListCoreDefinitions(@_, NextToken => $result->NextToken); | ||
| 587 | } | ||
| 588 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 589 | } | ||
| 590 | |||
| 591 | return undef | ||
| 592 | } | ||
| 593 | sub ListAllCoreDefinitionVersions { | ||
| 594 | my $self = shift; | ||
| 595 | |||
| 596 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 597 | my $result = $self->ListCoreDefinitionVersions(@_); | ||
| 598 | my $next_result = $result; | ||
| 599 | |||
| 600 | if (not defined $callback) { | ||
| 601 | while ($next_result->NextToken) { | ||
| 602 | $next_result = $self->ListCoreDefinitionVersions(@_, NextToken => $next_result->NextToken); | ||
| 603 | push @{ $result->Versions }, @{ $next_result->Versions }; | ||
| 604 | } | ||
| 605 | return $result; | ||
| 606 | } else { | ||
| 607 | while ($result->NextToken) { | ||
| 608 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 609 | $result = $self->ListCoreDefinitionVersions(@_, NextToken => $result->NextToken); | ||
| 610 | } | ||
| 611 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 612 | } | ||
| 613 | |||
| 614 | return undef | ||
| 615 | } | ||
| 616 | sub ListAllDeployments { | ||
| 617 | my $self = shift; | ||
| 618 | |||
| 619 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 620 | my $result = $self->ListDeployments(@_); | ||
| 621 | my $next_result = $result; | ||
| 622 | |||
| 623 | if (not defined $callback) { | ||
| 624 | while ($next_result->NextToken) { | ||
| 625 | $next_result = $self->ListDeployments(@_, NextToken => $next_result->NextToken); | ||
| 626 | push @{ $result->Deployments }, @{ $next_result->Deployments }; | ||
| 627 | } | ||
| 628 | return $result; | ||
| 629 | } else { | ||
| 630 | while ($result->NextToken) { | ||
| 631 | $callback->($_ => 'Deployments') foreach (@{ $result->Deployments }); | ||
| 632 | $result = $self->ListDeployments(@_, NextToken => $result->NextToken); | ||
| 633 | } | ||
| 634 | $callback->($_ => 'Deployments') foreach (@{ $result->Deployments }); | ||
| 635 | } | ||
| 636 | |||
| 637 | return undef | ||
| 638 | } | ||
| 639 | sub ListAllDeviceDefinitions { | ||
| 640 | my $self = shift; | ||
| 641 | |||
| 642 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 643 | my $result = $self->ListDeviceDefinitions(@_); | ||
| 644 | my $next_result = $result; | ||
| 645 | |||
| 646 | if (not defined $callback) { | ||
| 647 | while ($next_result->NextToken) { | ||
| 648 | $next_result = $self->ListDeviceDefinitions(@_, NextToken => $next_result->NextToken); | ||
| 649 | push @{ $result->Definitions }, @{ $next_result->Definitions }; | ||
| 650 | } | ||
| 651 | return $result; | ||
| 652 | } else { | ||
| 653 | while ($result->NextToken) { | ||
| 654 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 655 | $result = $self->ListDeviceDefinitions(@_, NextToken => $result->NextToken); | ||
| 656 | } | ||
| 657 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 658 | } | ||
| 659 | |||
| 660 | return undef | ||
| 661 | } | ||
| 662 | sub ListAllDeviceDefinitionVersions { | ||
| 663 | my $self = shift; | ||
| 664 | |||
| 665 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 666 | my $result = $self->ListDeviceDefinitionVersions(@_); | ||
| 667 | my $next_result = $result; | ||
| 668 | |||
| 669 | if (not defined $callback) { | ||
| 670 | while ($next_result->NextToken) { | ||
| 671 | $next_result = $self->ListDeviceDefinitionVersions(@_, NextToken => $next_result->NextToken); | ||
| 672 | push @{ $result->Versions }, @{ $next_result->Versions }; | ||
| 673 | } | ||
| 674 | return $result; | ||
| 675 | } else { | ||
| 676 | while ($result->NextToken) { | ||
| 677 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 678 | $result = $self->ListDeviceDefinitionVersions(@_, NextToken => $result->NextToken); | ||
| 679 | } | ||
| 680 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 681 | } | ||
| 682 | |||
| 683 | return undef | ||
| 684 | } | ||
| 685 | sub ListAllFunctionDefinitions { | ||
| 686 | my $self = shift; | ||
| 687 | |||
| 688 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 689 | my $result = $self->ListFunctionDefinitions(@_); | ||
| 690 | my $next_result = $result; | ||
| 691 | |||
| 692 | if (not defined $callback) { | ||
| 693 | while ($next_result->NextToken) { | ||
| 694 | $next_result = $self->ListFunctionDefinitions(@_, NextToken => $next_result->NextToken); | ||
| 695 | push @{ $result->Definitions }, @{ $next_result->Definitions }; | ||
| 696 | } | ||
| 697 | return $result; | ||
| 698 | } else { | ||
| 699 | while ($result->NextToken) { | ||
| 700 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 701 | $result = $self->ListFunctionDefinitions(@_, NextToken => $result->NextToken); | ||
| 702 | } | ||
| 703 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 704 | } | ||
| 705 | |||
| 706 | return undef | ||
| 707 | } | ||
| 708 | sub ListAllFunctionDefinitionVersions { | ||
| 709 | my $self = shift; | ||
| 710 | |||
| 711 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 712 | my $result = $self->ListFunctionDefinitionVersions(@_); | ||
| 713 | my $next_result = $result; | ||
| 714 | |||
| 715 | if (not defined $callback) { | ||
| 716 | while ($next_result->NextToken) { | ||
| 717 | $next_result = $self->ListFunctionDefinitionVersions(@_, NextToken => $next_result->NextToken); | ||
| 718 | push @{ $result->Versions }, @{ $next_result->Versions }; | ||
| 719 | } | ||
| 720 | return $result; | ||
| 721 | } else { | ||
| 722 | while ($result->NextToken) { | ||
| 723 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 724 | $result = $self->ListFunctionDefinitionVersions(@_, NextToken => $result->NextToken); | ||
| 725 | } | ||
| 726 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 727 | } | ||
| 728 | |||
| 729 | return undef | ||
| 730 | } | ||
| 731 | sub ListAllGroups { | ||
| 732 | my $self = shift; | ||
| 733 | |||
| 734 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 735 | my $result = $self->ListGroups(@_); | ||
| 736 | my $next_result = $result; | ||
| 737 | |||
| 738 | if (not defined $callback) { | ||
| 739 | while ($next_result->NextToken) { | ||
| 740 | $next_result = $self->ListGroups(@_, NextToken => $next_result->NextToken); | ||
| 741 | push @{ $result->Groups }, @{ $next_result->Groups }; | ||
| 742 | } | ||
| 743 | return $result; | ||
| 744 | } else { | ||
| 745 | while ($result->NextToken) { | ||
| 746 | $callback->($_ => 'Groups') foreach (@{ $result->Groups }); | ||
| 747 | $result = $self->ListGroups(@_, NextToken => $result->NextToken); | ||
| 748 | } | ||
| 749 | $callback->($_ => 'Groups') foreach (@{ $result->Groups }); | ||
| 750 | } | ||
| 751 | |||
| 752 | return undef | ||
| 753 | } | ||
| 754 | sub ListAllGroupVersions { | ||
| 755 | my $self = shift; | ||
| 756 | |||
| 757 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 758 | my $result = $self->ListGroupVersions(@_); | ||
| 759 | my $next_result = $result; | ||
| 760 | |||
| 761 | if (not defined $callback) { | ||
| 762 | while ($next_result->NextToken) { | ||
| 763 | $next_result = $self->ListGroupVersions(@_, NextToken => $next_result->NextToken); | ||
| 764 | push @{ $result->Versions }, @{ $next_result->Versions }; | ||
| 765 | } | ||
| 766 | return $result; | ||
| 767 | } else { | ||
| 768 | while ($result->NextToken) { | ||
| 769 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 770 | $result = $self->ListGroupVersions(@_, NextToken => $result->NextToken); | ||
| 771 | } | ||
| 772 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 773 | } | ||
| 774 | |||
| 775 | return undef | ||
| 776 | } | ||
| 777 | sub ListAllLoggerDefinitions { | ||
| 778 | my $self = shift; | ||
| 779 | |||
| 780 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 781 | my $result = $self->ListLoggerDefinitions(@_); | ||
| 782 | my $next_result = $result; | ||
| 783 | |||
| 784 | if (not defined $callback) { | ||
| 785 | while ($next_result->NextToken) { | ||
| 786 | $next_result = $self->ListLoggerDefinitions(@_, NextToken => $next_result->NextToken); | ||
| 787 | push @{ $result->Definitions }, @{ $next_result->Definitions }; | ||
| 788 | } | ||
| 789 | return $result; | ||
| 790 | } else { | ||
| 791 | while ($result->NextToken) { | ||
| 792 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 793 | $result = $self->ListLoggerDefinitions(@_, NextToken => $result->NextToken); | ||
| 794 | } | ||
| 795 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 796 | } | ||
| 797 | |||
| 798 | return undef | ||
| 799 | } | ||
| 800 | sub ListAllLoggerDefinitionVersions { | ||
| 801 | my $self = shift; | ||
| 802 | |||
| 803 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 804 | my $result = $self->ListLoggerDefinitionVersions(@_); | ||
| 805 | my $next_result = $result; | ||
| 806 | |||
| 807 | if (not defined $callback) { | ||
| 808 | while ($next_result->NextToken) { | ||
| 809 | $next_result = $self->ListLoggerDefinitionVersions(@_, NextToken => $next_result->NextToken); | ||
| 810 | push @{ $result->Versions }, @{ $next_result->Versions }; | ||
| 811 | } | ||
| 812 | return $result; | ||
| 813 | } else { | ||
| 814 | while ($result->NextToken) { | ||
| 815 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 816 | $result = $self->ListLoggerDefinitionVersions(@_, NextToken => $result->NextToken); | ||
| 817 | } | ||
| 818 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 819 | } | ||
| 820 | |||
| 821 | return undef | ||
| 822 | } | ||
| 823 | sub ListAllResourceDefinitions { | ||
| 824 | my $self = shift; | ||
| 825 | |||
| 826 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 827 | my $result = $self->ListResourceDefinitions(@_); | ||
| 828 | my $next_result = $result; | ||
| 829 | |||
| 830 | if (not defined $callback) { | ||
| 831 | while ($next_result->NextToken) { | ||
| 832 | $next_result = $self->ListResourceDefinitions(@_, NextToken => $next_result->NextToken); | ||
| 833 | push @{ $result->Definitions }, @{ $next_result->Definitions }; | ||
| 834 | } | ||
| 835 | return $result; | ||
| 836 | } else { | ||
| 837 | while ($result->NextToken) { | ||
| 838 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 839 | $result = $self->ListResourceDefinitions(@_, NextToken => $result->NextToken); | ||
| 840 | } | ||
| 841 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 842 | } | ||
| 843 | |||
| 844 | return undef | ||
| 845 | } | ||
| 846 | sub ListAllResourceDefinitionVersions { | ||
| 847 | my $self = shift; | ||
| 848 | |||
| 849 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 850 | my $result = $self->ListResourceDefinitionVersions(@_); | ||
| 851 | my $next_result = $result; | ||
| 852 | |||
| 853 | if (not defined $callback) { | ||
| 854 | while ($next_result->NextToken) { | ||
| 855 | $next_result = $self->ListResourceDefinitionVersions(@_, NextToken => $next_result->NextToken); | ||
| 856 | push @{ $result->Versions }, @{ $next_result->Versions }; | ||
| 857 | } | ||
| 858 | return $result; | ||
| 859 | } else { | ||
| 860 | while ($result->NextToken) { | ||
| 861 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 862 | $result = $self->ListResourceDefinitionVersions(@_, NextToken => $result->NextToken); | ||
| 863 | } | ||
| 864 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 865 | } | ||
| 866 | |||
| 867 | return undef | ||
| 868 | } | ||
| 869 | sub ListAllSubscriptionDefinitions { | ||
| 870 | my $self = shift; | ||
| 871 | |||
| 872 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 873 | my $result = $self->ListSubscriptionDefinitions(@_); | ||
| 874 | my $next_result = $result; | ||
| 875 | |||
| 876 | if (not defined $callback) { | ||
| 877 | while ($next_result->NextToken) { | ||
| 878 | $next_result = $self->ListSubscriptionDefinitions(@_, NextToken => $next_result->NextToken); | ||
| 879 | push @{ $result->Definitions }, @{ $next_result->Definitions }; | ||
| 880 | } | ||
| 881 | return $result; | ||
| 882 | } else { | ||
| 883 | while ($result->NextToken) { | ||
| 884 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 885 | $result = $self->ListSubscriptionDefinitions(@_, NextToken => $result->NextToken); | ||
| 886 | } | ||
| 887 | $callback->($_ => 'Definitions') foreach (@{ $result->Definitions }); | ||
| 888 | } | ||
| 889 | |||
| 890 | return undef | ||
| 891 | } | ||
| 892 | sub ListAllSubscriptionDefinitionVersions { | ||
| 893 | my $self = shift; | ||
| 894 | |||
| 895 | my $callback = shift @_ if (ref($_[0]) eq 'CODE'); | ||
| 896 | my $result = $self->ListSubscriptionDefinitionVersions(@_); | ||
| 897 | my $next_result = $result; | ||
| 898 | |||
| 899 | if (not defined $callback) { | ||
| 900 | while ($next_result->NextToken) { | ||
| 901 | $next_result = $self->ListSubscriptionDefinitionVersions(@_, NextToken => $next_result->NextToken); | ||
| 902 | push @{ $result->Versions }, @{ $next_result->Versions }; | ||
| 903 | } | ||
| 904 | return $result; | ||
| 905 | } else { | ||
| 906 | while ($result->NextToken) { | ||
| 907 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 908 | $result = $self->ListSubscriptionDefinitionVersions(@_, NextToken => $result->NextToken); | ||
| 909 | } | ||
| 910 | $callback->($_ => 'Versions') foreach (@{ $result->Versions }); | ||
| 911 | } | ||
| 912 | |||
| 913 | return undef | ||
| 914 | } | ||
| 915 | |||
| 916 | |||
| 917 | sub operations { qw/AssociateRoleToGroup AssociateServiceRoleToAccount CreateConnectorDefinition CreateConnectorDefinitionVersion CreateCoreDefinition CreateCoreDefinitionVersion CreateDeployment CreateDeviceDefinition CreateDeviceDefinitionVersion CreateFunctionDefinition CreateFunctionDefinitionVersion CreateGroup CreateGroupCertificateAuthority CreateGroupVersion CreateLoggerDefinition CreateLoggerDefinitionVersion CreateResourceDefinition CreateResourceDefinitionVersion CreateSoftwareUpdateJob CreateSubscriptionDefinition CreateSubscriptionDefinitionVersion DeleteConnectorDefinition DeleteCoreDefinition DeleteDeviceDefinition DeleteFunctionDefinition DeleteGroup DeleteLoggerDefinition DeleteResourceDefinition DeleteSubscriptionDefinition DisassociateRoleFromGroup DisassociateServiceRoleFromAccount GetAssociatedRole GetBulkDeploymentStatus GetConnectivityInfo GetConnectorDefinition GetConnectorDefinitionVersion GetCoreDefinition GetCoreDefinitionVersion GetDeploymentStatus GetDeviceDefinition GetDeviceDefinitionVersion GetFunctionDefinition GetFunctionDefinitionVersion GetGroup GetGroupCertificateAuthority GetGroupCertificateConfiguration GetGroupVersion GetLoggerDefinition GetLoggerDefinitionVersion GetResourceDefinition GetResourceDefinitionVersion GetServiceRoleForAccount GetSubscriptionDefinition GetSubscriptionDefinitionVersion GetThingRuntimeConfiguration ListBulkDeploymentDetailedReports ListBulkDeployments ListConnectorDefinitions ListConnectorDefinitionVersions ListCoreDefinitions ListCoreDefinitionVersions ListDeployments ListDeviceDefinitions ListDeviceDefinitionVersions ListFunctionDefinitions ListFunctionDefinitionVersions ListGroupCertificateAuthorities ListGroups ListGroupVersions ListLoggerDefinitions ListLoggerDefinitionVersions ListResourceDefinitions ListResourceDefinitionVersions ListSubscriptionDefinitions ListSubscriptionDefinitionVersions ListTagsForResource ResetDeployments StartBulkDeployment StopBulkDeployment TagResource UntagResource UpdateConnectivityInfo UpdateConnectorDefinition UpdateCoreDefinition UpdateDeviceDefinition UpdateFunctionDefinition UpdateGroup UpdateGroupCertificateConfiguration UpdateLoggerDefinition UpdateResourceDefinition UpdateSubscriptionDefinition UpdateThingRuntimeConfiguration / } | ||
| 918 | |||
| 919 | 1; | ||
| 920 | |||
| 921 | ### main pod documentation begin ### | ||
| 922 | |||
| 923 | =head1 NAME | ||
| 924 | |||
| 925 | Paws::Greengrass - Perl Interface to AWS AWS Greengrass | ||
| 926 | |||
| 927 | =head1 SYNOPSIS | ||
| 928 | |||
| 929 | use Paws; | ||
| 930 | |||
| 931 | my $obj = Paws->service('Greengrass'); | ||
| 932 | my $res = $obj->Method( | ||
| 933 | Arg1 => $val1, | ||
| 934 | Arg2 => [ 'V1', 'V2' ], | ||
| 935 | # if Arg3 is an object, the HashRef will be used as arguments to the constructor | ||
| 936 | # of the arguments type | ||
| 937 | Arg3 => { Att1 => 'Val1' }, | ||
| 938 | # if Arg4 is an array of objects, the HashRefs will be passed as arguments to | ||
| 939 | # the constructor of the arguments type | ||
| 940 | Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ], | ||
| 941 | ); | ||
| 942 | |||
| 943 | =head1 DESCRIPTION | ||
| 944 | |||
| 945 | AWS IoT Greengrass seamlessly extends AWS onto physical devices so they | ||
| 946 | can act locally on the data they generate, while still using the cloud | ||
| 947 | for management, analytics, and durable storage. AWS IoT Greengrass | ||
| 948 | ensures your devices can respond quickly to local events and operate | ||
| 949 | with intermittent connectivity. AWS IoT Greengrass minimizes the cost | ||
| 950 | of transmitting data to the cloud by allowing you to author AWS Lambda | ||
| 951 | functions that execute locally. | ||
| 952 | |||
| 953 | For the AWS API documentation, see L<https://docs.aws.amazon.com/greengrass/> | ||
| 954 | |||
| 955 | |||
| 956 | =head1 METHODS | ||
| 957 | |||
| 958 | =head2 AssociateRoleToGroup | ||
| 959 | |||
| 960 | =over | ||
| 961 | |||
| 962 | =item GroupId => Str | ||
| 963 | |||
| 964 | =item RoleArn => Str | ||
| 965 | |||
| 966 | |||
| 967 | =back | ||
| 968 | |||
| 969 | Each argument is described in detail in: L<Paws::Greengrass::AssociateRoleToGroup> | ||
| 970 | |||
| 971 | Returns: a L<Paws::Greengrass::AssociateRoleToGroupResponse> instance | ||
| 972 | |||
| 973 | Associates a role with a group. Your Greengrass core will use the role | ||
| 974 | to access AWS cloud services. The role's permissions should allow | ||
| 975 | Greengrass core Lambda functions to perform actions against the cloud. | ||
| 976 | |||
| 977 | |||
| 978 | =head2 AssociateServiceRoleToAccount | ||
| 979 | |||
| 980 | =over | ||
| 981 | |||
| 982 | =item RoleArn => Str | ||
| 983 | |||
| 984 | |||
| 985 | =back | ||
| 986 | |||
| 987 | Each argument is described in detail in: L<Paws::Greengrass::AssociateServiceRoleToAccount> | ||
| 988 | |||
| 989 | Returns: a L<Paws::Greengrass::AssociateServiceRoleToAccountResponse> instance | ||
| 990 | |||
| 991 | Associates a role with your account. AWS IoT Greengrass will use the | ||
| 992 | role to access your Lambda functions and AWS IoT resources. This is | ||
| 993 | necessary for deployments to succeed. The role must have at least | ||
| 994 | minimum permissions in the policy | ||
| 995 | ''AWSGreengrassResourceAccessRolePolicy''. | ||
| 996 | |||
| 997 | |||
| 998 | =head2 CreateConnectorDefinition | ||
| 999 | |||
| 1000 | =over | ||
| 1001 | |||
| 1002 | =item [AmznClientToken => Str] | ||
| 1003 | |||
| 1004 | =item [InitialVersion => L<Paws::Greengrass::ConnectorDefinitionVersion>] | ||
| 1005 | |||
| 1006 | =item [Name => Str] | ||
| 1007 | |||
| 1008 | =item [Tags => L<Paws::Greengrass::Tags>] | ||
| 1009 | |||
| 1010 | |||
| 1011 | =back | ||
| 1012 | |||
| 1013 | Each argument is described in detail in: L<Paws::Greengrass::CreateConnectorDefinition> | ||
| 1014 | |||
| 1015 | Returns: a L<Paws::Greengrass::CreateConnectorDefinitionResponse> instance | ||
| 1016 | |||
| 1017 | Creates a connector definition. You may provide the initial version of | ||
| 1018 | the connector definition now or use | ||
| 1019 | ''CreateConnectorDefinitionVersion'' at a later time. | ||
| 1020 | |||
| 1021 | |||
| 1022 | =head2 CreateConnectorDefinitionVersion | ||
| 1023 | |||
| 1024 | =over | ||
| 1025 | |||
| 1026 | =item ConnectorDefinitionId => Str | ||
| 1027 | |||
| 1028 | =item [AmznClientToken => Str] | ||
| 1029 | |||
| 1030 | =item [Connectors => ArrayRef[L<Paws::Greengrass::Connector>]] | ||
| 1031 | |||
| 1032 | |||
| 1033 | =back | ||
| 1034 | |||
| 1035 | Each argument is described in detail in: L<Paws::Greengrass::CreateConnectorDefinitionVersion> | ||
| 1036 | |||
| 1037 | Returns: a L<Paws::Greengrass::CreateConnectorDefinitionVersionResponse> instance | ||
| 1038 | |||
| 1039 | Creates a version of a connector definition which has already been | ||
| 1040 | defined. | ||
| 1041 | |||
| 1042 | |||
| 1043 | =head2 CreateCoreDefinition | ||
| 1044 | |||
| 1045 | =over | ||
| 1046 | |||
| 1047 | =item [AmznClientToken => Str] | ||
| 1048 | |||
| 1049 | =item [InitialVersion => L<Paws::Greengrass::CoreDefinitionVersion>] | ||
| 1050 | |||
| 1051 | =item [Name => Str] | ||
| 1052 | |||
| 1053 | =item [Tags => L<Paws::Greengrass::Tags>] | ||
| 1054 | |||
| 1055 | |||
| 1056 | =back | ||
| 1057 | |||
| 1058 | Each argument is described in detail in: L<Paws::Greengrass::CreateCoreDefinition> | ||
| 1059 | |||
| 1060 | Returns: a L<Paws::Greengrass::CreateCoreDefinitionResponse> instance | ||
| 1061 | |||
| 1062 | Creates a core definition. You may provide the initial version of the | ||
| 1063 | core definition now or use ''CreateCoreDefinitionVersion'' at a later | ||
| 1064 | time. Greengrass groups must each contain exactly one Greengrass core. | ||
| 1065 | |||
| 1066 | |||
| 1067 | =head2 CreateCoreDefinitionVersion | ||
| 1068 | |||
| 1069 | =over | ||
| 1070 | |||
| 1071 | =item CoreDefinitionId => Str | ||
| 1072 | |||
| 1073 | =item [AmznClientToken => Str] | ||
| 1074 | |||
| 1075 | =item [Cores => ArrayRef[L<Paws::Greengrass::Core>]] | ||
| 1076 | |||
| 1077 | |||
| 1078 | =back | ||
| 1079 | |||
| 1080 | Each argument is described in detail in: L<Paws::Greengrass::CreateCoreDefinitionVersion> | ||
| 1081 | |||
| 1082 | Returns: a L<Paws::Greengrass::CreateCoreDefinitionVersionResponse> instance | ||
| 1083 | |||
| 1084 | Creates a version of a core definition that has already been defined. | ||
| 1085 | Greengrass groups must each contain exactly one Greengrass core. | ||
| 1086 | |||
| 1087 | |||
| 1088 | =head2 CreateDeployment | ||
| 1089 | |||
| 1090 | =over | ||
| 1091 | |||
| 1092 | =item DeploymentType => Str | ||
| 1093 | |||
| 1094 | =item GroupId => Str | ||
| 1095 | |||
| 1096 | =item [AmznClientToken => Str] | ||
| 1097 | |||
| 1098 | =item [DeploymentId => Str] | ||
| 1099 | |||
| 1100 | =item [GroupVersionId => Str] | ||
| 1101 | |||
| 1102 | |||
| 1103 | =back | ||
| 1104 | |||
| 1105 | Each argument is described in detail in: L<Paws::Greengrass::CreateDeployment> | ||
| 1106 | |||
| 1107 | Returns: a L<Paws::Greengrass::CreateDeploymentResponse> instance | ||
| 1108 | |||
| 1109 | Creates a deployment. ''CreateDeployment'' requests are idempotent with | ||
| 1110 | respect to the ''X-Amzn-Client-Token'' token and the request | ||
| 1111 | parameters. | ||
| 1112 | |||
| 1113 | |||
| 1114 | =head2 CreateDeviceDefinition | ||
| 1115 | |||
| 1116 | =over | ||
| 1117 | |||
| 1118 | =item [AmznClientToken => Str] | ||
| 1119 | |||
| 1120 | =item [InitialVersion => L<Paws::Greengrass::DeviceDefinitionVersion>] | ||
| 1121 | |||
| 1122 | =item [Name => Str] | ||
| 1123 | |||
| 1124 | =item [Tags => L<Paws::Greengrass::Tags>] | ||
| 1125 | |||
| 1126 | |||
| 1127 | =back | ||
| 1128 | |||
| 1129 | Each argument is described in detail in: L<Paws::Greengrass::CreateDeviceDefinition> | ||
| 1130 | |||
| 1131 | Returns: a L<Paws::Greengrass::CreateDeviceDefinitionResponse> instance | ||
| 1132 | |||
| 1133 | Creates a device definition. You may provide the initial version of the | ||
| 1134 | device definition now or use ''CreateDeviceDefinitionVersion'' at a | ||
| 1135 | later time. | ||
| 1136 | |||
| 1137 | |||
| 1138 | =head2 CreateDeviceDefinitionVersion | ||
| 1139 | |||
| 1140 | =over | ||
| 1141 | |||
| 1142 | =item DeviceDefinitionId => Str | ||
| 1143 | |||
| 1144 | =item [AmznClientToken => Str] | ||
| 1145 | |||
| 1146 | =item [Devices => ArrayRef[L<Paws::Greengrass::Device>]] | ||
| 1147 | |||
| 1148 | |||
| 1149 | =back | ||
| 1150 | |||
| 1151 | Each argument is described in detail in: L<Paws::Greengrass::CreateDeviceDefinitionVersion> | ||
| 1152 | |||
| 1153 | Returns: a L<Paws::Greengrass::CreateDeviceDefinitionVersionResponse> instance | ||
| 1154 | |||
| 1155 | Creates a version of a device definition that has already been defined. | ||
| 1156 | |||
| 1157 | |||
| 1158 | =head2 CreateFunctionDefinition | ||
| 1159 | |||
| 1160 | =over | ||
| 1161 | |||
| 1162 | =item [AmznClientToken => Str] | ||
| 1163 | |||
| 1164 | =item [InitialVersion => L<Paws::Greengrass::FunctionDefinitionVersion>] | ||
| 1165 | |||
| 1166 | =item [Name => Str] | ||
| 1167 | |||
| 1168 | =item [Tags => L<Paws::Greengrass::Tags>] | ||
| 1169 | |||
| 1170 | |||
| 1171 | =back | ||
| 1172 | |||
| 1173 | Each argument is described in detail in: L<Paws::Greengrass::CreateFunctionDefinition> | ||
| 1174 | |||
| 1175 | Returns: a L<Paws::Greengrass::CreateFunctionDefinitionResponse> instance | ||
| 1176 | |||
| 1177 | Creates a Lambda function definition which contains a list of Lambda | ||
| 1178 | functions and their configurations to be used in a group. You can | ||
| 1179 | create an initial version of the definition by providing a list of | ||
| 1180 | Lambda functions and their configurations now, or use | ||
| 1181 | ''CreateFunctionDefinitionVersion'' later. | ||
| 1182 | |||
| 1183 | |||
| 1184 | =head2 CreateFunctionDefinitionVersion | ||
| 1185 | |||
| 1186 | =over | ||
| 1187 | |||
| 1188 | =item FunctionDefinitionId => Str | ||
| 1189 | |||
| 1190 | =item [AmznClientToken => Str] | ||
| 1191 | |||
| 1192 | =item [DefaultConfig => L<Paws::Greengrass::FunctionDefaultConfig>] | ||
| 1193 | |||
| 1194 | =item [Functions => ArrayRef[L<Paws::Greengrass::Function>]] | ||
| 1195 | |||
| 1196 | |||
| 1197 | =back | ||
| 1198 | |||
| 1199 | Each argument is described in detail in: L<Paws::Greengrass::CreateFunctionDefinitionVersion> | ||
| 1200 | |||
| 1201 | Returns: a L<Paws::Greengrass::CreateFunctionDefinitionVersionResponse> instance | ||
| 1202 | |||
| 1203 | Creates a version of a Lambda function definition that has already been | ||
| 1204 | defined. | ||
| 1205 | |||
| 1206 | |||
| 1207 | =head2 CreateGroup | ||
| 1208 | |||
| 1209 | =over | ||
| 1210 | |||
| 1211 | =item Name => Str | ||
| 1212 | |||
| 1213 | =item [AmznClientToken => Str] | ||
| 1214 | |||
| 1215 | =item [InitialVersion => L<Paws::Greengrass::GroupVersion>] | ||
| 1216 | |||
| 1217 | =item [Tags => L<Paws::Greengrass::Tags>] | ||
| 1218 | |||
| 1219 | |||
| 1220 | =back | ||
| 1221 | |||
| 1222 | Each argument is described in detail in: L<Paws::Greengrass::CreateGroup> | ||
| 1223 | |||
| 1224 | Returns: a L<Paws::Greengrass::CreateGroupResponse> instance | ||
| 1225 | |||
| 1226 | Creates a group. You may provide the initial version of the group or | ||
| 1227 | use ''CreateGroupVersion'' at a later time. Tip: You can use the | ||
| 1228 | ''gg_group_setup'' package | ||
| 1229 | (https://github.com/awslabs/aws-greengrass-group-setup) as a library or | ||
| 1230 | command-line application to create and deploy Greengrass groups. | ||
| 1231 | |||
| 1232 | |||
| 1233 | =head2 CreateGroupCertificateAuthority | ||
| 1234 | |||
| 1235 | =over | ||
| 1236 | |||
| 1237 | =item GroupId => Str | ||
| 1238 | |||
| 1239 | =item [AmznClientToken => Str] | ||
| 1240 | |||
| 1241 | |||
| 1242 | =back | ||
| 1243 | |||
| 1244 | Each argument is described in detail in: L<Paws::Greengrass::CreateGroupCertificateAuthority> | ||
| 1245 | |||
| 1246 | Returns: a L<Paws::Greengrass::CreateGroupCertificateAuthorityResponse> instance | ||
| 1247 | |||
| 1248 | Creates a CA for the group. If a CA already exists, it will rotate the | ||
| 1249 | existing CA. | ||
| 1250 | |||
| 1251 | |||
| 1252 | =head2 CreateGroupVersion | ||
| 1253 | |||
| 1254 | =over | ||
| 1255 | |||
| 1256 | =item GroupId => Str | ||
| 1257 | |||
| 1258 | =item [AmznClientToken => Str] | ||
| 1259 | |||
| 1260 | =item [ConnectorDefinitionVersionArn => Str] | ||
| 1261 | |||
| 1262 | =item [CoreDefinitionVersionArn => Str] | ||
| 1263 | |||
| 1264 | =item [DeviceDefinitionVersionArn => Str] | ||
| 1265 | |||
| 1266 | =item [FunctionDefinitionVersionArn => Str] | ||
| 1267 | |||
| 1268 | =item [LoggerDefinitionVersionArn => Str] | ||
| 1269 | |||
| 1270 | =item [ResourceDefinitionVersionArn => Str] | ||
| 1271 | |||
| 1272 | =item [SubscriptionDefinitionVersionArn => Str] | ||
| 1273 | |||
| 1274 | |||
| 1275 | =back | ||
| 1276 | |||
| 1277 | Each argument is described in detail in: L<Paws::Greengrass::CreateGroupVersion> | ||
| 1278 | |||
| 1279 | Returns: a L<Paws::Greengrass::CreateGroupVersionResponse> instance | ||
| 1280 | |||
| 1281 | Creates a version of a group which has already been defined. | ||
| 1282 | |||
| 1283 | |||
| 1284 | =head2 CreateLoggerDefinition | ||
| 1285 | |||
| 1286 | =over | ||
| 1287 | |||
| 1288 | =item [AmznClientToken => Str] | ||
| 1289 | |||
| 1290 | =item [InitialVersion => L<Paws::Greengrass::LoggerDefinitionVersion>] | ||
| 1291 | |||
| 1292 | =item [Name => Str] | ||
| 1293 | |||
| 1294 | =item [Tags => L<Paws::Greengrass::Tags>] | ||
| 1295 | |||
| 1296 | |||
| 1297 | =back | ||
| 1298 | |||
| 1299 | Each argument is described in detail in: L<Paws::Greengrass::CreateLoggerDefinition> | ||
| 1300 | |||
| 1301 | Returns: a L<Paws::Greengrass::CreateLoggerDefinitionResponse> instance | ||
| 1302 | |||
| 1303 | Creates a logger definition. You may provide the initial version of the | ||
| 1304 | logger definition now or use ''CreateLoggerDefinitionVersion'' at a | ||
| 1305 | later time. | ||
| 1306 | |||
| 1307 | |||
| 1308 | =head2 CreateLoggerDefinitionVersion | ||
| 1309 | |||
| 1310 | =over | ||
| 1311 | |||
| 1312 | =item LoggerDefinitionId => Str | ||
| 1313 | |||
| 1314 | =item [AmznClientToken => Str] | ||
| 1315 | |||
| 1316 | =item [Loggers => ArrayRef[L<Paws::Greengrass::Logger>]] | ||
| 1317 | |||
| 1318 | |||
| 1319 | =back | ||
| 1320 | |||
| 1321 | Each argument is described in detail in: L<Paws::Greengrass::CreateLoggerDefinitionVersion> | ||
| 1322 | |||
| 1323 | Returns: a L<Paws::Greengrass::CreateLoggerDefinitionVersionResponse> instance | ||
| 1324 | |||
| 1325 | Creates a version of a logger definition that has already been defined. | ||
| 1326 | |||
| 1327 | |||
| 1328 | =head2 CreateResourceDefinition | ||
| 1329 | |||
| 1330 | =over | ||
| 1331 | |||
| 1332 | =item [AmznClientToken => Str] | ||
| 1333 | |||
| 1334 | =item [InitialVersion => L<Paws::Greengrass::ResourceDefinitionVersion>] | ||
| 1335 | |||
| 1336 | =item [Name => Str] | ||
| 1337 | |||
| 1338 | =item [Tags => L<Paws::Greengrass::Tags>] | ||
| 1339 | |||
| 1340 | |||
| 1341 | =back | ||
| 1342 | |||
| 1343 | Each argument is described in detail in: L<Paws::Greengrass::CreateResourceDefinition> | ||
| 1344 | |||
| 1345 | Returns: a L<Paws::Greengrass::CreateResourceDefinitionResponse> instance | ||
| 1346 | |||
| 1347 | Creates a resource definition which contains a list of resources to be | ||
| 1348 | used in a group. You can create an initial version of the definition by | ||
| 1349 | providing a list of resources now, or use | ||
| 1350 | ''CreateResourceDefinitionVersion'' later. | ||
| 1351 | |||
| 1352 | |||
| 1353 | =head2 CreateResourceDefinitionVersion | ||
| 1354 | |||
| 1355 | =over | ||
| 1356 | |||
| 1357 | =item ResourceDefinitionId => Str | ||
| 1358 | |||
| 1359 | =item [AmznClientToken => Str] | ||
| 1360 | |||
| 1361 | =item [Resources => ArrayRef[L<Paws::Greengrass::Resource>]] | ||
| 1362 | |||
| 1363 | |||
| 1364 | =back | ||
| 1365 | |||
| 1366 | Each argument is described in detail in: L<Paws::Greengrass::CreateResourceDefinitionVersion> | ||
| 1367 | |||
| 1368 | Returns: a L<Paws::Greengrass::CreateResourceDefinitionVersionResponse> instance | ||
| 1369 | |||
| 1370 | Creates a version of a resource definition that has already been | ||
| 1371 | defined. | ||
| 1372 | |||
| 1373 | |||
| 1374 | =head2 CreateSoftwareUpdateJob | ||
| 1375 | |||
| 1376 | =over | ||
| 1377 | |||
| 1378 | =item S3UrlSignerRole => Str | ||
| 1379 | |||
| 1380 | =item SoftwareToUpdate => Str | ||
| 1381 | |||
| 1382 | =item UpdateTargets => ArrayRef[Str|Undef] | ||
| 1383 | |||
| 1384 | =item UpdateTargetsArchitecture => Str | ||
| 1385 | |||
| 1386 | =item UpdateTargetsOperatingSystem => Str | ||
| 1387 | |||
| 1388 | =item [AmznClientToken => Str] | ||
| 1389 | |||
| 1390 | =item [UpdateAgentLogLevel => Str] | ||
| 1391 | |||
| 1392 | |||
| 1393 | =back | ||
| 1394 | |||
| 1395 | Each argument is described in detail in: L<Paws::Greengrass::CreateSoftwareUpdateJob> | ||
| 1396 | |||
| 1397 | Returns: a L<Paws::Greengrass::CreateSoftwareUpdateJobResponse> instance | ||
| 1398 | |||
| 1399 | Creates a software update for a core or group of cores (specified as an | ||
| 1400 | IoT thing group.) Use this to update the OTA Agent as well as the | ||
| 1401 | Greengrass core software. It makes use of the IoT Jobs feature which | ||
| 1402 | provides additional commands to manage a Greengrass core software | ||
| 1403 | update job. | ||
| 1404 | |||
| 1405 | |||
| 1406 | =head2 CreateSubscriptionDefinition | ||
| 1407 | |||
| 1408 | =over | ||
| 1409 | |||
| 1410 | =item [AmznClientToken => Str] | ||
| 1411 | |||
| 1412 | =item [InitialVersion => L<Paws::Greengrass::SubscriptionDefinitionVersion>] | ||
| 1413 | |||
| 1414 | =item [Name => Str] | ||
| 1415 | |||
| 1416 | =item [Tags => L<Paws::Greengrass::Tags>] | ||
| 1417 | |||
| 1418 | |||
| 1419 | =back | ||
| 1420 | |||
| 1421 | Each argument is described in detail in: L<Paws::Greengrass::CreateSubscriptionDefinition> | ||
| 1422 | |||
| 1423 | Returns: a L<Paws::Greengrass::CreateSubscriptionDefinitionResponse> instance | ||
| 1424 | |||
| 1425 | Creates a subscription definition. You may provide the initial version | ||
| 1426 | of the subscription definition now or use | ||
| 1427 | ''CreateSubscriptionDefinitionVersion'' at a later time. | ||
| 1428 | |||
| 1429 | |||
| 1430 | =head2 CreateSubscriptionDefinitionVersion | ||
| 1431 | |||
| 1432 | =over | ||
| 1433 | |||
| 1434 | =item SubscriptionDefinitionId => Str | ||
| 1435 | |||
| 1436 | =item [AmznClientToken => Str] | ||
| 1437 | |||
| 1438 | =item [Subscriptions => ArrayRef[L<Paws::Greengrass::Subscription>]] | ||
| 1439 | |||
| 1440 | |||
| 1441 | =back | ||
| 1442 | |||
| 1443 | Each argument is described in detail in: L<Paws::Greengrass::CreateSubscriptionDefinitionVersion> | ||
| 1444 | |||
| 1445 | Returns: a L<Paws::Greengrass::CreateSubscriptionDefinitionVersionResponse> instance | ||
| 1446 | |||
| 1447 | Creates a version of a subscription definition which has already been | ||
| 1448 | defined. | ||
| 1449 | |||
| 1450 | |||
| 1451 | =head2 DeleteConnectorDefinition | ||
| 1452 | |||
| 1453 | =over | ||
| 1454 | |||
| 1455 | =item ConnectorDefinitionId => Str | ||
| 1456 | |||
| 1457 | |||
| 1458 | =back | ||
| 1459 | |||
| 1460 | Each argument is described in detail in: L<Paws::Greengrass::DeleteConnectorDefinition> | ||
| 1461 | |||
| 1462 | Returns: a L<Paws::Greengrass::DeleteConnectorDefinitionResponse> instance | ||
| 1463 | |||
| 1464 | Deletes a connector definition. | ||
| 1465 | |||
| 1466 | |||
| 1467 | =head2 DeleteCoreDefinition | ||
| 1468 | |||
| 1469 | =over | ||
| 1470 | |||
| 1471 | =item CoreDefinitionId => Str | ||
| 1472 | |||
| 1473 | |||
| 1474 | =back | ||
| 1475 | |||
| 1476 | Each argument is described in detail in: L<Paws::Greengrass::DeleteCoreDefinition> | ||
| 1477 | |||
| 1478 | Returns: a L<Paws::Greengrass::DeleteCoreDefinitionResponse> instance | ||
| 1479 | |||
| 1480 | Deletes a core definition. | ||
| 1481 | |||
| 1482 | |||
| 1483 | =head2 DeleteDeviceDefinition | ||
| 1484 | |||
| 1485 | =over | ||
| 1486 | |||
| 1487 | =item DeviceDefinitionId => Str | ||
| 1488 | |||
| 1489 | |||
| 1490 | =back | ||
| 1491 | |||
| 1492 | Each argument is described in detail in: L<Paws::Greengrass::DeleteDeviceDefinition> | ||
| 1493 | |||
| 1494 | Returns: a L<Paws::Greengrass::DeleteDeviceDefinitionResponse> instance | ||
| 1495 | |||
| 1496 | Deletes a device definition. | ||
| 1497 | |||
| 1498 | |||
| 1499 | =head2 DeleteFunctionDefinition | ||
| 1500 | |||
| 1501 | =over | ||
| 1502 | |||
| 1503 | =item FunctionDefinitionId => Str | ||
| 1504 | |||
| 1505 | |||
| 1506 | =back | ||
| 1507 | |||
| 1508 | Each argument is described in detail in: L<Paws::Greengrass::DeleteFunctionDefinition> | ||
| 1509 | |||
| 1510 | Returns: a L<Paws::Greengrass::DeleteFunctionDefinitionResponse> instance | ||
| 1511 | |||
| 1512 | Deletes a Lambda function definition. | ||
| 1513 | |||
| 1514 | |||
| 1515 | =head2 DeleteGroup | ||
| 1516 | |||
| 1517 | =over | ||
| 1518 | |||
| 1519 | =item GroupId => Str | ||
| 1520 | |||
| 1521 | |||
| 1522 | =back | ||
| 1523 | |||
| 1524 | Each argument is described in detail in: L<Paws::Greengrass::DeleteGroup> | ||
| 1525 | |||
| 1526 | Returns: a L<Paws::Greengrass::DeleteGroupResponse> instance | ||
| 1527 | |||
| 1528 | Deletes a group. | ||
| 1529 | |||
| 1530 | |||
| 1531 | =head2 DeleteLoggerDefinition | ||
| 1532 | |||
| 1533 | =over | ||
| 1534 | |||
| 1535 | =item LoggerDefinitionId => Str | ||
| 1536 | |||
| 1537 | |||
| 1538 | =back | ||
| 1539 | |||
| 1540 | Each argument is described in detail in: L<Paws::Greengrass::DeleteLoggerDefinition> | ||
| 1541 | |||
| 1542 | Returns: a L<Paws::Greengrass::DeleteLoggerDefinitionResponse> instance | ||
| 1543 | |||
| 1544 | Deletes a logger definition. | ||
| 1545 | |||
| 1546 | |||
| 1547 | =head2 DeleteResourceDefinition | ||
| 1548 | |||
| 1549 | =over | ||
| 1550 | |||
| 1551 | =item ResourceDefinitionId => Str | ||
| 1552 | |||
| 1553 | |||
| 1554 | =back | ||
| 1555 | |||
| 1556 | Each argument is described in detail in: L<Paws::Greengrass::DeleteResourceDefinition> | ||
| 1557 | |||
| 1558 | Returns: a L<Paws::Greengrass::DeleteResourceDefinitionResponse> instance | ||
| 1559 | |||
| 1560 | Deletes a resource definition. | ||
| 1561 | |||
| 1562 | |||
| 1563 | =head2 DeleteSubscriptionDefinition | ||
| 1564 | |||
| 1565 | =over | ||
| 1566 | |||
| 1567 | =item SubscriptionDefinitionId => Str | ||
| 1568 | |||
| 1569 | |||
| 1570 | =back | ||
| 1571 | |||
| 1572 | Each argument is described in detail in: L<Paws::Greengrass::DeleteSubscriptionDefinition> | ||
| 1573 | |||
| 1574 | Returns: a L<Paws::Greengrass::DeleteSubscriptionDefinitionResponse> instance | ||
| 1575 | |||
| 1576 | Deletes a subscription definition. | ||
| 1577 | |||
| 1578 | |||
| 1579 | =head2 DisassociateRoleFromGroup | ||
| 1580 | |||
| 1581 | =over | ||
| 1582 | |||
| 1583 | =item GroupId => Str | ||
| 1584 | |||
| 1585 | |||
| 1586 | =back | ||
| 1587 | |||
| 1588 | Each argument is described in detail in: L<Paws::Greengrass::DisassociateRoleFromGroup> | ||
| 1589 | |||
| 1590 | Returns: a L<Paws::Greengrass::DisassociateRoleFromGroupResponse> instance | ||
| 1591 | |||
| 1592 | Disassociates the role from a group. | ||
| 1593 | |||
| 1594 | |||
| 1595 | =head2 DisassociateServiceRoleFromAccount | ||
| 1596 | |||
| 1597 | |||
| 1598 | |||
| 1599 | |||
| 1600 | |||
| 1601 | |||
| 1602 | Each argument is described in detail in: L<Paws::Greengrass::DisassociateServiceRoleFromAccount> | ||
| 1603 | |||
| 1604 | Returns: a L<Paws::Greengrass::DisassociateServiceRoleFromAccountResponse> instance | ||
| 1605 | |||
| 1606 | Disassociates the service role from your account. Without a service | ||
| 1607 | role, deployments will not work. | ||
| 1608 | |||
| 1609 | |||
| 1610 | =head2 GetAssociatedRole | ||
| 1611 | |||
| 1612 | =over | ||
| 1613 | |||
| 1614 | =item GroupId => Str | ||
| 1615 | |||
| 1616 | |||
| 1617 | =back | ||
| 1618 | |||
| 1619 | Each argument is described in detail in: L<Paws::Greengrass::GetAssociatedRole> | ||
| 1620 | |||
| 1621 | Returns: a L<Paws::Greengrass::GetAssociatedRoleResponse> instance | ||
| 1622 | |||
| 1623 | Retrieves the role associated with a particular group. | ||
| 1624 | |||
| 1625 | |||
| 1626 | =head2 GetBulkDeploymentStatus | ||
| 1627 | |||
| 1628 | =over | ||
| 1629 | |||
| 1630 | =item BulkDeploymentId => Str | ||
| 1631 | |||
| 1632 | |||
| 1633 | =back | ||
| 1634 | |||
| 1635 | Each argument is described in detail in: L<Paws::Greengrass::GetBulkDeploymentStatus> | ||
| 1636 | |||
| 1637 | Returns: a L<Paws::Greengrass::GetBulkDeploymentStatusResponse> instance | ||
| 1638 | |||
| 1639 | Returns the status of a bulk deployment. | ||
| 1640 | |||
| 1641 | |||
| 1642 | =head2 GetConnectivityInfo | ||
| 1643 | |||
| 1644 | =over | ||
| 1645 | |||
| 1646 | =item ThingName => Str | ||
| 1647 | |||
| 1648 | |||
| 1649 | =back | ||
| 1650 | |||
| 1651 | Each argument is described in detail in: L<Paws::Greengrass::GetConnectivityInfo> | ||
| 1652 | |||
| 1653 | Returns: a L<Paws::Greengrass::GetConnectivityInfoResponse> instance | ||
| 1654 | |||
| 1655 | Retrieves the connectivity information for a core. | ||
| 1656 | |||
| 1657 | |||
| 1658 | =head2 GetConnectorDefinition | ||
| 1659 | |||
| 1660 | =over | ||
| 1661 | |||
| 1662 | =item ConnectorDefinitionId => Str | ||
| 1663 | |||
| 1664 | |||
| 1665 | =back | ||
| 1666 | |||
| 1667 | Each argument is described in detail in: L<Paws::Greengrass::GetConnectorDefinition> | ||
| 1668 | |||
| 1669 | Returns: a L<Paws::Greengrass::GetConnectorDefinitionResponse> instance | ||
| 1670 | |||
| 1671 | Retrieves information about a connector definition. | ||
| 1672 | |||
| 1673 | |||
| 1674 | =head2 GetConnectorDefinitionVersion | ||
| 1675 | |||
| 1676 | =over | ||
| 1677 | |||
| 1678 | =item ConnectorDefinitionId => Str | ||
| 1679 | |||
| 1680 | =item ConnectorDefinitionVersionId => Str | ||
| 1681 | |||
| 1682 | =item [NextToken => Str] | ||
| 1683 | |||
| 1684 | |||
| 1685 | =back | ||
| 1686 | |||
| 1687 | Each argument is described in detail in: L<Paws::Greengrass::GetConnectorDefinitionVersion> | ||
| 1688 | |||
| 1689 | Returns: a L<Paws::Greengrass::GetConnectorDefinitionVersionResponse> instance | ||
| 1690 | |||
| 1691 | Retrieves information about a connector definition version, including | ||
| 1692 | the connectors that the version contains. Connectors are prebuilt | ||
| 1693 | modules that interact with local infrastructure, device protocols, AWS, | ||
| 1694 | and other cloud services. | ||
| 1695 | |||
| 1696 | |||
| 1697 | =head2 GetCoreDefinition | ||
| 1698 | |||
| 1699 | =over | ||
| 1700 | |||
| 1701 | =item CoreDefinitionId => Str | ||
| 1702 | |||
| 1703 | |||
| 1704 | =back | ||
| 1705 | |||
| 1706 | Each argument is described in detail in: L<Paws::Greengrass::GetCoreDefinition> | ||
| 1707 | |||
| 1708 | Returns: a L<Paws::Greengrass::GetCoreDefinitionResponse> instance | ||
| 1709 | |||
| 1710 | Retrieves information about a core definition version. | ||
| 1711 | |||
| 1712 | |||
| 1713 | =head2 GetCoreDefinitionVersion | ||
| 1714 | |||
| 1715 | =over | ||
| 1716 | |||
| 1717 | =item CoreDefinitionId => Str | ||
| 1718 | |||
| 1719 | =item CoreDefinitionVersionId => Str | ||
| 1720 | |||
| 1721 | |||
| 1722 | =back | ||
| 1723 | |||
| 1724 | Each argument is described in detail in: L<Paws::Greengrass::GetCoreDefinitionVersion> | ||
| 1725 | |||
| 1726 | Returns: a L<Paws::Greengrass::GetCoreDefinitionVersionResponse> instance | ||
| 1727 | |||
| 1728 | Retrieves information about a core definition version. | ||
| 1729 | |||
| 1730 | |||
| 1731 | =head2 GetDeploymentStatus | ||
| 1732 | |||
| 1733 | =over | ||
| 1734 | |||
| 1735 | =item DeploymentId => Str | ||
| 1736 | |||
| 1737 | =item GroupId => Str | ||
| 1738 | |||
| 1739 | |||
| 1740 | =back | ||
| 1741 | |||
| 1742 | Each argument is described in detail in: L<Paws::Greengrass::GetDeploymentStatus> | ||
| 1743 | |||
| 1744 | Returns: a L<Paws::Greengrass::GetDeploymentStatusResponse> instance | ||
| 1745 | |||
| 1746 | Returns the status of a deployment. | ||
| 1747 | |||
| 1748 | |||
| 1749 | =head2 GetDeviceDefinition | ||
| 1750 | |||
| 1751 | =over | ||
| 1752 | |||
| 1753 | =item DeviceDefinitionId => Str | ||
| 1754 | |||
| 1755 | |||
| 1756 | =back | ||
| 1757 | |||
| 1758 | Each argument is described in detail in: L<Paws::Greengrass::GetDeviceDefinition> | ||
| 1759 | |||
| 1760 | Returns: a L<Paws::Greengrass::GetDeviceDefinitionResponse> instance | ||
| 1761 | |||
| 1762 | Retrieves information about a device definition. | ||
| 1763 | |||
| 1764 | |||
| 1765 | =head2 GetDeviceDefinitionVersion | ||
| 1766 | |||
| 1767 | =over | ||
| 1768 | |||
| 1769 | =item DeviceDefinitionId => Str | ||
| 1770 | |||
| 1771 | =item DeviceDefinitionVersionId => Str | ||
| 1772 | |||
| 1773 | =item [NextToken => Str] | ||
| 1774 | |||
| 1775 | |||
| 1776 | =back | ||
| 1777 | |||
| 1778 | Each argument is described in detail in: L<Paws::Greengrass::GetDeviceDefinitionVersion> | ||
| 1779 | |||
| 1780 | Returns: a L<Paws::Greengrass::GetDeviceDefinitionVersionResponse> instance | ||
| 1781 | |||
| 1782 | Retrieves information about a device definition version. | ||
| 1783 | |||
| 1784 | |||
| 1785 | =head2 GetFunctionDefinition | ||
| 1786 | |||
| 1787 | =over | ||
| 1788 | |||
| 1789 | =item FunctionDefinitionId => Str | ||
| 1790 | |||
| 1791 | |||
| 1792 | =back | ||
| 1793 | |||
| 1794 | Each argument is described in detail in: L<Paws::Greengrass::GetFunctionDefinition> | ||
| 1795 | |||
| 1796 | Returns: a L<Paws::Greengrass::GetFunctionDefinitionResponse> instance | ||
| 1797 | |||
| 1798 | Retrieves information about a Lambda function definition, including its | ||
| 1799 | creation time and latest version. | ||
| 1800 | |||
| 1801 | |||
| 1802 | =head2 GetFunctionDefinitionVersion | ||
| 1803 | |||
| 1804 | =over | ||
| 1805 | |||
| 1806 | =item FunctionDefinitionId => Str | ||
| 1807 | |||
| 1808 | =item FunctionDefinitionVersionId => Str | ||
| 1809 | |||
| 1810 | =item [NextToken => Str] | ||
| 1811 | |||
| 1812 | |||
| 1813 | =back | ||
| 1814 | |||
| 1815 | Each argument is described in detail in: L<Paws::Greengrass::GetFunctionDefinitionVersion> | ||
| 1816 | |||
| 1817 | Returns: a L<Paws::Greengrass::GetFunctionDefinitionVersionResponse> instance | ||
| 1818 | |||
| 1819 | Retrieves information about a Lambda function definition version, | ||
| 1820 | including which Lambda functions are included in the version and their | ||
| 1821 | configurations. | ||
| 1822 | |||
| 1823 | |||
| 1824 | =head2 GetGroup | ||
| 1825 | |||
| 1826 | =over | ||
| 1827 | |||
| 1828 | =item GroupId => Str | ||
| 1829 | |||
| 1830 | |||
| 1831 | =back | ||
| 1832 | |||
| 1833 | Each argument is described in detail in: L<Paws::Greengrass::GetGroup> | ||
| 1834 | |||
| 1835 | Returns: a L<Paws::Greengrass::GetGroupResponse> instance | ||
| 1836 | |||
| 1837 | Retrieves information about a group. | ||
| 1838 | |||
| 1839 | |||
| 1840 | =head2 GetGroupCertificateAuthority | ||
| 1841 | |||
| 1842 | =over | ||
| 1843 | |||
| 1844 | =item CertificateAuthorityId => Str | ||
| 1845 | |||
| 1846 | =item GroupId => Str | ||
| 1847 | |||
| 1848 | |||
| 1849 | =back | ||
| 1850 | |||
| 1851 | Each argument is described in detail in: L<Paws::Greengrass::GetGroupCertificateAuthority> | ||
| 1852 | |||
| 1853 | Returns: a L<Paws::Greengrass::GetGroupCertificateAuthorityResponse> instance | ||
| 1854 | |||
| 1855 | Retreives the CA associated with a group. Returns the public key of the | ||
| 1856 | CA. | ||
| 1857 | |||
| 1858 | |||
| 1859 | =head2 GetGroupCertificateConfiguration | ||
| 1860 | |||
| 1861 | =over | ||
| 1862 | |||
| 1863 | =item GroupId => Str | ||
| 1864 | |||
| 1865 | |||
| 1866 | =back | ||
| 1867 | |||
| 1868 | Each argument is described in detail in: L<Paws::Greengrass::GetGroupCertificateConfiguration> | ||
| 1869 | |||
| 1870 | Returns: a L<Paws::Greengrass::GetGroupCertificateConfigurationResponse> instance | ||
| 1871 | |||
| 1872 | Retrieves the current configuration for the CA used by the group. | ||
| 1873 | |||
| 1874 | |||
| 1875 | =head2 GetGroupVersion | ||
| 1876 | |||
| 1877 | =over | ||
| 1878 | |||
| 1879 | =item GroupId => Str | ||
| 1880 | |||
| 1881 | =item GroupVersionId => Str | ||
| 1882 | |||
| 1883 | |||
| 1884 | =back | ||
| 1885 | |||
| 1886 | Each argument is described in detail in: L<Paws::Greengrass::GetGroupVersion> | ||
| 1887 | |||
| 1888 | Returns: a L<Paws::Greengrass::GetGroupVersionResponse> instance | ||
| 1889 | |||
| 1890 | Retrieves information about a group version. | ||
| 1891 | |||
| 1892 | |||
| 1893 | =head2 GetLoggerDefinition | ||
| 1894 | |||
| 1895 | =over | ||
| 1896 | |||
| 1897 | =item LoggerDefinitionId => Str | ||
| 1898 | |||
| 1899 | |||
| 1900 | =back | ||
| 1901 | |||
| 1902 | Each argument is described in detail in: L<Paws::Greengrass::GetLoggerDefinition> | ||
| 1903 | |||
| 1904 | Returns: a L<Paws::Greengrass::GetLoggerDefinitionResponse> instance | ||
| 1905 | |||
| 1906 | Retrieves information about a logger definition. | ||
| 1907 | |||
| 1908 | |||
| 1909 | =head2 GetLoggerDefinitionVersion | ||
| 1910 | |||
| 1911 | =over | ||
| 1912 | |||
| 1913 | =item LoggerDefinitionId => Str | ||
| 1914 | |||
| 1915 | =item LoggerDefinitionVersionId => Str | ||
| 1916 | |||
| 1917 | =item [NextToken => Str] | ||
| 1918 | |||
| 1919 | |||
| 1920 | =back | ||
| 1921 | |||
| 1922 | Each argument is described in detail in: L<Paws::Greengrass::GetLoggerDefinitionVersion> | ||
| 1923 | |||
| 1924 | Returns: a L<Paws::Greengrass::GetLoggerDefinitionVersionResponse> instance | ||
| 1925 | |||
| 1926 | Retrieves information about a logger definition version. | ||
| 1927 | |||
| 1928 | |||
| 1929 | =head2 GetResourceDefinition | ||
| 1930 | |||
| 1931 | =over | ||
| 1932 | |||
| 1933 | =item ResourceDefinitionId => Str | ||
| 1934 | |||
| 1935 | |||
| 1936 | =back | ||
| 1937 | |||
| 1938 | Each argument is described in detail in: L<Paws::Greengrass::GetResourceDefinition> | ||
| 1939 | |||
| 1940 | Returns: a L<Paws::Greengrass::GetResourceDefinitionResponse> instance | ||
| 1941 | |||
| 1942 | Retrieves information about a resource definition, including its | ||
| 1943 | creation time and latest version. | ||
| 1944 | |||
| 1945 | |||
| 1946 | =head2 GetResourceDefinitionVersion | ||
| 1947 | |||
| 1948 | =over | ||
| 1949 | |||
| 1950 | =item ResourceDefinitionId => Str | ||
| 1951 | |||
| 1952 | =item ResourceDefinitionVersionId => Str | ||
| 1953 | |||
| 1954 | |||
| 1955 | =back | ||
| 1956 | |||
| 1957 | Each argument is described in detail in: L<Paws::Greengrass::GetResourceDefinitionVersion> | ||
| 1958 | |||
| 1959 | Returns: a L<Paws::Greengrass::GetResourceDefinitionVersionResponse> instance | ||
| 1960 | |||
| 1961 | Retrieves information about a resource definition version, including | ||
| 1962 | which resources are included in the version. | ||
| 1963 | |||
| 1964 | |||
| 1965 | =head2 GetServiceRoleForAccount | ||
| 1966 | |||
| 1967 | |||
| 1968 | |||
| 1969 | |||
| 1970 | |||
| 1971 | |||
| 1972 | Each argument is described in detail in: L<Paws::Greengrass::GetServiceRoleForAccount> | ||
| 1973 | |||
| 1974 | Returns: a L<Paws::Greengrass::GetServiceRoleForAccountResponse> instance | ||
| 1975 | |||
| 1976 | Retrieves the service role that is attached to your account. | ||
| 1977 | |||
| 1978 | |||
| 1979 | =head2 GetSubscriptionDefinition | ||
| 1980 | |||
| 1981 | =over | ||
| 1982 | |||
| 1983 | =item SubscriptionDefinitionId => Str | ||
| 1984 | |||
| 1985 | |||
| 1986 | =back | ||
| 1987 | |||
| 1988 | Each argument is described in detail in: L<Paws::Greengrass::GetSubscriptionDefinition> | ||
| 1989 | |||
| 1990 | Returns: a L<Paws::Greengrass::GetSubscriptionDefinitionResponse> instance | ||
| 1991 | |||
| 1992 | Retrieves information about a subscription definition. | ||
| 1993 | |||
| 1994 | |||
| 1995 | =head2 GetSubscriptionDefinitionVersion | ||
| 1996 | |||
| 1997 | =over | ||
| 1998 | |||
| 1999 | =item SubscriptionDefinitionId => Str | ||
| 2000 | |||
| 2001 | =item SubscriptionDefinitionVersionId => Str | ||
| 2002 | |||
| 2003 | =item [NextToken => Str] | ||
| 2004 | |||
| 2005 | |||
| 2006 | =back | ||
| 2007 | |||
| 2008 | Each argument is described in detail in: L<Paws::Greengrass::GetSubscriptionDefinitionVersion> | ||
| 2009 | |||
| 2010 | Returns: a L<Paws::Greengrass::GetSubscriptionDefinitionVersionResponse> instance | ||
| 2011 | |||
| 2012 | Retrieves information about a subscription definition version. | ||
| 2013 | |||
| 2014 | |||
| 2015 | =head2 GetThingRuntimeConfiguration | ||
| 2016 | |||
| 2017 | =over | ||
| 2018 | |||
| 2019 | =item ThingName => Str | ||
| 2020 | |||
| 2021 | |||
| 2022 | =back | ||
| 2023 | |||
| 2024 | Each argument is described in detail in: L<Paws::Greengrass::GetThingRuntimeConfiguration> | ||
| 2025 | |||
| 2026 | Returns: a L<Paws::Greengrass::GetThingRuntimeConfigurationResponse> instance | ||
| 2027 | |||
| 2028 | Get the runtime configuration of a thing. | ||
| 2029 | |||
| 2030 | |||
| 2031 | =head2 ListBulkDeploymentDetailedReports | ||
| 2032 | |||
| 2033 | =over | ||
| 2034 | |||
| 2035 | =item BulkDeploymentId => Str | ||
| 2036 | |||
| 2037 | =item [MaxResults => Str] | ||
| 2038 | |||
| 2039 | =item [NextToken => Str] | ||
| 2040 | |||
| 2041 | |||
| 2042 | =back | ||
| 2043 | |||
| 2044 | Each argument is described in detail in: L<Paws::Greengrass::ListBulkDeploymentDetailedReports> | ||
| 2045 | |||
| 2046 | Returns: a L<Paws::Greengrass::ListBulkDeploymentDetailedReportsResponse> instance | ||
| 2047 | |||
| 2048 | Gets a paginated list of the deployments that have been started in a | ||
| 2049 | bulk deployment operation, and their current deployment status. | ||
| 2050 | |||
| 2051 | |||
| 2052 | =head2 ListBulkDeployments | ||
| 2053 | |||
| 2054 | =over | ||
| 2055 | |||
| 2056 | =item [MaxResults => Str] | ||
| 2057 | |||
| 2058 | =item [NextToken => Str] | ||
| 2059 | |||
| 2060 | |||
| 2061 | =back | ||
| 2062 | |||
| 2063 | Each argument is described in detail in: L<Paws::Greengrass::ListBulkDeployments> | ||
| 2064 | |||
| 2065 | Returns: a L<Paws::Greengrass::ListBulkDeploymentsResponse> instance | ||
| 2066 | |||
| 2067 | Returns a list of bulk deployments. | ||
| 2068 | |||
| 2069 | |||
| 2070 | =head2 ListConnectorDefinitions | ||
| 2071 | |||
| 2072 | =over | ||
| 2073 | |||
| 2074 | =item [MaxResults => Str] | ||
| 2075 | |||
| 2076 | =item [NextToken => Str] | ||
| 2077 | |||
| 2078 | |||
| 2079 | =back | ||
| 2080 | |||
| 2081 | Each argument is described in detail in: L<Paws::Greengrass::ListConnectorDefinitions> | ||
| 2082 | |||
| 2083 | Returns: a L<Paws::Greengrass::ListConnectorDefinitionsResponse> instance | ||
| 2084 | |||
| 2085 | Retrieves a list of connector definitions. | ||
| 2086 | |||
| 2087 | |||
| 2088 | =head2 ListConnectorDefinitionVersions | ||
| 2089 | |||
| 2090 | =over | ||
| 2091 | |||
| 2092 | =item ConnectorDefinitionId => Str | ||
| 2093 | |||
| 2094 | =item [MaxResults => Str] | ||
| 2095 | |||
| 2096 | =item [NextToken => Str] | ||
| 2097 | |||
| 2098 | |||
| 2099 | =back | ||
| 2100 | |||
| 2101 | Each argument is described in detail in: L<Paws::Greengrass::ListConnectorDefinitionVersions> | ||
| 2102 | |||
| 2103 | Returns: a L<Paws::Greengrass::ListConnectorDefinitionVersionsResponse> instance | ||
| 2104 | |||
| 2105 | Lists the versions of a connector definition, which are containers for | ||
| 2106 | connectors. Connectors run on the Greengrass core and contain built-in | ||
| 2107 | integration with local infrastructure, device protocols, AWS, and other | ||
| 2108 | cloud services. | ||
| 2109 | |||
| 2110 | |||
| 2111 | =head2 ListCoreDefinitions | ||
| 2112 | |||
| 2113 | =over | ||
| 2114 | |||
| 2115 | =item [MaxResults => Str] | ||
| 2116 | |||
| 2117 | =item [NextToken => Str] | ||
| 2118 | |||
| 2119 | |||
| 2120 | =back | ||
| 2121 | |||
| 2122 | Each argument is described in detail in: L<Paws::Greengrass::ListCoreDefinitions> | ||
| 2123 | |||
| 2124 | Returns: a L<Paws::Greengrass::ListCoreDefinitionsResponse> instance | ||
| 2125 | |||
| 2126 | Retrieves a list of core definitions. | ||
| 2127 | |||
| 2128 | |||
| 2129 | =head2 ListCoreDefinitionVersions | ||
| 2130 | |||
| 2131 | =over | ||
| 2132 | |||
| 2133 | =item CoreDefinitionId => Str | ||
| 2134 | |||
| 2135 | =item [MaxResults => Str] | ||
| 2136 | |||
| 2137 | =item [NextToken => Str] | ||
| 2138 | |||
| 2139 | |||
| 2140 | =back | ||
| 2141 | |||
| 2142 | Each argument is described in detail in: L<Paws::Greengrass::ListCoreDefinitionVersions> | ||
| 2143 | |||
| 2144 | Returns: a L<Paws::Greengrass::ListCoreDefinitionVersionsResponse> instance | ||
| 2145 | |||
| 2146 | Lists the versions of a core definition. | ||
| 2147 | |||
| 2148 | |||
| 2149 | =head2 ListDeployments | ||
| 2150 | |||
| 2151 | =over | ||
| 2152 | |||
| 2153 | =item GroupId => Str | ||
| 2154 | |||
| 2155 | =item [MaxResults => Str] | ||
| 2156 | |||
| 2157 | =item [NextToken => Str] | ||
| 2158 | |||
| 2159 | |||
| 2160 | =back | ||
| 2161 | |||
| 2162 | Each argument is described in detail in: L<Paws::Greengrass::ListDeployments> | ||
| 2163 | |||
| 2164 | Returns: a L<Paws::Greengrass::ListDeploymentsResponse> instance | ||
| 2165 | |||
| 2166 | Returns a history of deployments for the group. | ||
| 2167 | |||
| 2168 | |||
| 2169 | =head2 ListDeviceDefinitions | ||
| 2170 | |||
| 2171 | =over | ||
| 2172 | |||
| 2173 | =item [MaxResults => Str] | ||
| 2174 | |||
| 2175 | =item [NextToken => Str] | ||
| 2176 | |||
| 2177 | |||
| 2178 | =back | ||
| 2179 | |||
| 2180 | Each argument is described in detail in: L<Paws::Greengrass::ListDeviceDefinitions> | ||
| 2181 | |||
| 2182 | Returns: a L<Paws::Greengrass::ListDeviceDefinitionsResponse> instance | ||
| 2183 | |||
| 2184 | Retrieves a list of device definitions. | ||
| 2185 | |||
| 2186 | |||
| 2187 | =head2 ListDeviceDefinitionVersions | ||
| 2188 | |||
| 2189 | =over | ||
| 2190 | |||
| 2191 | =item DeviceDefinitionId => Str | ||
| 2192 | |||
| 2193 | =item [MaxResults => Str] | ||
| 2194 | |||
| 2195 | =item [NextToken => Str] | ||
| 2196 | |||
| 2197 | |||
| 2198 | =back | ||
| 2199 | |||
| 2200 | Each argument is described in detail in: L<Paws::Greengrass::ListDeviceDefinitionVersions> | ||
| 2201 | |||
| 2202 | Returns: a L<Paws::Greengrass::ListDeviceDefinitionVersionsResponse> instance | ||
| 2203 | |||
| 2204 | Lists the versions of a device definition. | ||
| 2205 | |||
| 2206 | |||
| 2207 | =head2 ListFunctionDefinitions | ||
| 2208 | |||
| 2209 | =over | ||
| 2210 | |||
| 2211 | =item [MaxResults => Str] | ||
| 2212 | |||
| 2213 | =item [NextToken => Str] | ||
| 2214 | |||
| 2215 | |||
| 2216 | =back | ||
| 2217 | |||
| 2218 | Each argument is described in detail in: L<Paws::Greengrass::ListFunctionDefinitions> | ||
| 2219 | |||
| 2220 | Returns: a L<Paws::Greengrass::ListFunctionDefinitionsResponse> instance | ||
| 2221 | |||
| 2222 | Retrieves a list of Lambda function definitions. | ||
| 2223 | |||
| 2224 | |||
| 2225 | =head2 ListFunctionDefinitionVersions | ||
| 2226 | |||
| 2227 | =over | ||
| 2228 | |||
| 2229 | =item FunctionDefinitionId => Str | ||
| 2230 | |||
| 2231 | =item [MaxResults => Str] | ||
| 2232 | |||
| 2233 | =item [NextToken => Str] | ||
| 2234 | |||
| 2235 | |||
| 2236 | =back | ||
| 2237 | |||
| 2238 | Each argument is described in detail in: L<Paws::Greengrass::ListFunctionDefinitionVersions> | ||
| 2239 | |||
| 2240 | Returns: a L<Paws::Greengrass::ListFunctionDefinitionVersionsResponse> instance | ||
| 2241 | |||
| 2242 | Lists the versions of a Lambda function definition. | ||
| 2243 | |||
| 2244 | |||
| 2245 | =head2 ListGroupCertificateAuthorities | ||
| 2246 | |||
| 2247 | =over | ||
| 2248 | |||
| 2249 | =item GroupId => Str | ||
| 2250 | |||
| 2251 | |||
| 2252 | =back | ||
| 2253 | |||
| 2254 | Each argument is described in detail in: L<Paws::Greengrass::ListGroupCertificateAuthorities> | ||
| 2255 | |||
| 2256 | Returns: a L<Paws::Greengrass::ListGroupCertificateAuthoritiesResponse> instance | ||
| 2257 | |||
| 2258 | Retrieves the current CAs for a group. | ||
| 2259 | |||
| 2260 | |||
| 2261 | =head2 ListGroups | ||
| 2262 | |||
| 2263 | =over | ||
| 2264 | |||
| 2265 | =item [MaxResults => Str] | ||
| 2266 | |||
| 2267 | =item [NextToken => Str] | ||
| 2268 | |||
| 2269 | |||
| 2270 | =back | ||
| 2271 | |||
| 2272 | Each argument is described in detail in: L<Paws::Greengrass::ListGroups> | ||
| 2273 | |||
| 2274 | Returns: a L<Paws::Greengrass::ListGroupsResponse> instance | ||
| 2275 | |||
| 2276 | Retrieves a list of groups. | ||
| 2277 | |||
| 2278 | |||
| 2279 | =head2 ListGroupVersions | ||
| 2280 | |||
| 2281 | =over | ||
| 2282 | |||
| 2283 | =item GroupId => Str | ||
| 2284 | |||
| 2285 | =item [MaxResults => Str] | ||
| 2286 | |||
| 2287 | =item [NextToken => Str] | ||
| 2288 | |||
| 2289 | |||
| 2290 | =back | ||
| 2291 | |||
| 2292 | Each argument is described in detail in: L<Paws::Greengrass::ListGroupVersions> | ||
| 2293 | |||
| 2294 | Returns: a L<Paws::Greengrass::ListGroupVersionsResponse> instance | ||
| 2295 | |||
| 2296 | Lists the versions of a group. | ||
| 2297 | |||
| 2298 | |||
| 2299 | =head2 ListLoggerDefinitions | ||
| 2300 | |||
| 2301 | =over | ||
| 2302 | |||
| 2303 | =item [MaxResults => Str] | ||
| 2304 | |||
| 2305 | =item [NextToken => Str] | ||
| 2306 | |||
| 2307 | |||
| 2308 | =back | ||
| 2309 | |||
| 2310 | Each argument is described in detail in: L<Paws::Greengrass::ListLoggerDefinitions> | ||
| 2311 | |||
| 2312 | Returns: a L<Paws::Greengrass::ListLoggerDefinitionsResponse> instance | ||
| 2313 | |||
| 2314 | Retrieves a list of logger definitions. | ||
| 2315 | |||
| 2316 | |||
| 2317 | =head2 ListLoggerDefinitionVersions | ||
| 2318 | |||
| 2319 | =over | ||
| 2320 | |||
| 2321 | =item LoggerDefinitionId => Str | ||
| 2322 | |||
| 2323 | =item [MaxResults => Str] | ||
| 2324 | |||
| 2325 | =item [NextToken => Str] | ||
| 2326 | |||
| 2327 | |||
| 2328 | =back | ||
| 2329 | |||
| 2330 | Each argument is described in detail in: L<Paws::Greengrass::ListLoggerDefinitionVersions> | ||
| 2331 | |||
| 2332 | Returns: a L<Paws::Greengrass::ListLoggerDefinitionVersionsResponse> instance | ||
| 2333 | |||
| 2334 | Lists the versions of a logger definition. | ||
| 2335 | |||
| 2336 | |||
| 2337 | =head2 ListResourceDefinitions | ||
| 2338 | |||
| 2339 | =over | ||
| 2340 | |||
| 2341 | =item [MaxResults => Str] | ||
| 2342 | |||
| 2343 | =item [NextToken => Str] | ||
| 2344 | |||
| 2345 | |||
| 2346 | =back | ||
| 2347 | |||
| 2348 | Each argument is described in detail in: L<Paws::Greengrass::ListResourceDefinitions> | ||
| 2349 | |||
| 2350 | Returns: a L<Paws::Greengrass::ListResourceDefinitionsResponse> instance | ||
| 2351 | |||
| 2352 | Retrieves a list of resource definitions. | ||
| 2353 | |||
| 2354 | |||
| 2355 | =head2 ListResourceDefinitionVersions | ||
| 2356 | |||
| 2357 | =over | ||
| 2358 | |||
| 2359 | =item ResourceDefinitionId => Str | ||
| 2360 | |||
| 2361 | =item [MaxResults => Str] | ||
| 2362 | |||
| 2363 | =item [NextToken => Str] | ||
| 2364 | |||
| 2365 | |||
| 2366 | =back | ||
| 2367 | |||
| 2368 | Each argument is described in detail in: L<Paws::Greengrass::ListResourceDefinitionVersions> | ||
| 2369 | |||
| 2370 | Returns: a L<Paws::Greengrass::ListResourceDefinitionVersionsResponse> instance | ||
| 2371 | |||
| 2372 | Lists the versions of a resource definition. | ||
| 2373 | |||
| 2374 | |||
| 2375 | =head2 ListSubscriptionDefinitions | ||
| 2376 | |||
| 2377 | =over | ||
| 2378 | |||
| 2379 | =item [MaxResults => Str] | ||
| 2380 | |||
| 2381 | =item [NextToken => Str] | ||
| 2382 | |||
| 2383 | |||
| 2384 | =back | ||
| 2385 | |||
| 2386 | Each argument is described in detail in: L<Paws::Greengrass::ListSubscriptionDefinitions> | ||
| 2387 | |||
| 2388 | Returns: a L<Paws::Greengrass::ListSubscriptionDefinitionsResponse> instance | ||
| 2389 | |||
| 2390 | Retrieves a list of subscription definitions. | ||
| 2391 | |||
| 2392 | |||
| 2393 | =head2 ListSubscriptionDefinitionVersions | ||
| 2394 | |||
| 2395 | =over | ||
| 2396 | |||
| 2397 | =item SubscriptionDefinitionId => Str | ||
| 2398 | |||
| 2399 | =item [MaxResults => Str] | ||
| 2400 | |||
| 2401 | =item [NextToken => Str] | ||
| 2402 | |||
| 2403 | |||
| 2404 | =back | ||
| 2405 | |||
| 2406 | Each argument is described in detail in: L<Paws::Greengrass::ListSubscriptionDefinitionVersions> | ||
| 2407 | |||
| 2408 | Returns: a L<Paws::Greengrass::ListSubscriptionDefinitionVersionsResponse> instance | ||
| 2409 | |||
| 2410 | Lists the versions of a subscription definition. | ||
| 2411 | |||
| 2412 | |||
| 2413 | =head2 ListTagsForResource | ||
| 2414 | |||
| 2415 | =over | ||
| 2416 | |||
| 2417 | =item ResourceArn => Str | ||
| 2418 | |||
| 2419 | |||
| 2420 | =back | ||
| 2421 | |||
| 2422 | Each argument is described in detail in: L<Paws::Greengrass::ListTagsForResource> | ||
| 2423 | |||
| 2424 | Returns: a L<Paws::Greengrass::ListTagsForResourceResponse> instance | ||
| 2425 | |||
| 2426 | Retrieves a list of resource tags for a resource arn. | ||
| 2427 | |||
| 2428 | |||
| 2429 | =head2 ResetDeployments | ||
| 2430 | |||
| 2431 | =over | ||
| 2432 | |||
| 2433 | =item GroupId => Str | ||
| 2434 | |||
| 2435 | =item [AmznClientToken => Str] | ||
| 2436 | |||
| 2437 | =item [Force => Bool] | ||
| 2438 | |||
| 2439 | |||
| 2440 | =back | ||
| 2441 | |||
| 2442 | Each argument is described in detail in: L<Paws::Greengrass::ResetDeployments> | ||
| 2443 | |||
| 2444 | Returns: a L<Paws::Greengrass::ResetDeploymentsResponse> instance | ||
| 2445 | |||
| 2446 | Resets a group's deployments. | ||
| 2447 | |||
| 2448 | |||
| 2449 | =head2 StartBulkDeployment | ||
| 2450 | |||
| 2451 | =over | ||
| 2452 | |||
| 2453 | =item ExecutionRoleArn => Str | ||
| 2454 | |||
| 2455 | =item InputFileUri => Str | ||
| 2456 | |||
| 2457 | =item [AmznClientToken => Str] | ||
| 2458 | |||
| 2459 | =item [Tags => L<Paws::Greengrass::Tags>] | ||
| 2460 | |||
| 2461 | |||
| 2462 | =back | ||
| 2463 | |||
| 2464 | Each argument is described in detail in: L<Paws::Greengrass::StartBulkDeployment> | ||
| 2465 | |||
| 2466 | Returns: a L<Paws::Greengrass::StartBulkDeploymentResponse> instance | ||
| 2467 | |||
| 2468 | Deploys multiple groups in one operation. This action starts the bulk | ||
| 2469 | deployment of a specified set of group versions. Each group version | ||
| 2470 | deployment will be triggered with an adaptive rate that has a fixed | ||
| 2471 | upper limit. We recommend that you include an ''X-Amzn-Client-Token'' | ||
| 2472 | token in every ''StartBulkDeployment'' request. These requests are | ||
| 2473 | idempotent with respect to the token and the request parameters. | ||
| 2474 | |||
| 2475 | |||
| 2476 | =head2 StopBulkDeployment | ||
| 2477 | |||
| 2478 | =over | ||
| 2479 | |||
| 2480 | =item BulkDeploymentId => Str | ||
| 2481 | |||
| 2482 | |||
| 2483 | =back | ||
| 2484 | |||
| 2485 | Each argument is described in detail in: L<Paws::Greengrass::StopBulkDeployment> | ||
| 2486 | |||
| 2487 | Returns: a L<Paws::Greengrass::StopBulkDeploymentResponse> instance | ||
| 2488 | |||
| 2489 | Stops the execution of a bulk deployment. This action returns a status | ||
| 2490 | of ''Stopping'' until the deployment is stopped. You cannot start a new | ||
| 2491 | bulk deployment while a previous deployment is in the ''Stopping'' | ||
| 2492 | state. This action doesn't rollback completed deployments or cancel | ||
| 2493 | pending deployments. | ||
| 2494 | |||
| 2495 | |||
| 2496 | =head2 TagResource | ||
| 2497 | |||
| 2498 | =over | ||
| 2499 | |||
| 2500 | =item ResourceArn => Str | ||
| 2501 | |||
| 2502 | =item [Tags => L<Paws::Greengrass::Tags>] | ||
| 2503 | |||
| 2504 | |||
| 2505 | =back | ||
| 2506 | |||
| 2507 | Each argument is described in detail in: L<Paws::Greengrass::TagResource> | ||
| 2508 | |||
| 2509 | Returns: nothing | ||
| 2510 | |||
| 2511 | Adds tags to a Greengrass resource. Valid resources are 'Group', | ||
| 2512 | 'ConnectorDefinition', 'CoreDefinition', 'DeviceDefinition', | ||
| 2513 | 'FunctionDefinition', 'LoggerDefinition', 'SubscriptionDefinition', | ||
| 2514 | 'ResourceDefinition', and 'BulkDeployment'. | ||
| 2515 | |||
| 2516 | |||
| 2517 | =head2 UntagResource | ||
| 2518 | |||
| 2519 | =over | ||
| 2520 | |||
| 2521 | =item ResourceArn => Str | ||
| 2522 | |||
| 2523 | =item TagKeys => ArrayRef[Str|Undef] | ||
| 2524 | |||
| 2525 | |||
| 2526 | =back | ||
| 2527 | |||
| 2528 | Each argument is described in detail in: L<Paws::Greengrass::UntagResource> | ||
| 2529 | |||
| 2530 | Returns: nothing | ||
| 2531 | |||
| 2532 | Remove resource tags from a Greengrass Resource. | ||
| 2533 | |||
| 2534 | |||
| 2535 | =head2 UpdateConnectivityInfo | ||
| 2536 | |||
| 2537 | =over | ||
| 2538 | |||
| 2539 | =item ThingName => Str | ||
| 2540 | |||
| 2541 | =item [ConnectivityInfo => ArrayRef[L<Paws::Greengrass::ConnectivityInfo>]] | ||
| 2542 | |||
| 2543 | |||
| 2544 | =back | ||
| 2545 | |||
| 2546 | Each argument is described in detail in: L<Paws::Greengrass::UpdateConnectivityInfo> | ||
| 2547 | |||
| 2548 | Returns: a L<Paws::Greengrass::UpdateConnectivityInfoResponse> instance | ||
| 2549 | |||
| 2550 | Updates the connectivity information for the core. Any devices that | ||
| 2551 | belong to the group which has this core will receive this information | ||
| 2552 | in order to find the location of the core and connect to it. | ||
| 2553 | |||
| 2554 | |||
| 2555 | =head2 UpdateConnectorDefinition | ||
| 2556 | |||
| 2557 | =over | ||
| 2558 | |||
| 2559 | =item ConnectorDefinitionId => Str | ||
| 2560 | |||
| 2561 | =item [Name => Str] | ||
| 2562 | |||
| 2563 | |||
| 2564 | =back | ||
| 2565 | |||
| 2566 | Each argument is described in detail in: L<Paws::Greengrass::UpdateConnectorDefinition> | ||
| 2567 | |||
| 2568 | Returns: a L<Paws::Greengrass::UpdateConnectorDefinitionResponse> instance | ||
| 2569 | |||
| 2570 | Updates a connector definition. | ||
| 2571 | |||
| 2572 | |||
| 2573 | =head2 UpdateCoreDefinition | ||
| 2574 | |||
| 2575 | =over | ||
| 2576 | |||
| 2577 | =item CoreDefinitionId => Str | ||
| 2578 | |||
| 2579 | =item [Name => Str] | ||
| 2580 | |||
| 2581 | |||
| 2582 | =back | ||
| 2583 | |||
| 2584 | Each argument is described in detail in: L<Paws::Greengrass::UpdateCoreDefinition> | ||
| 2585 | |||
| 2586 | Returns: a L<Paws::Greengrass::UpdateCoreDefinitionResponse> instance | ||
| 2587 | |||
| 2588 | Updates a core definition. | ||
| 2589 | |||
| 2590 | |||
| 2591 | =head2 UpdateDeviceDefinition | ||
| 2592 | |||
| 2593 | =over | ||
| 2594 | |||
| 2595 | =item DeviceDefinitionId => Str | ||
| 2596 | |||
| 2597 | =item [Name => Str] | ||
| 2598 | |||
| 2599 | |||
| 2600 | =back | ||
| 2601 | |||
| 2602 | Each argument is described in detail in: L<Paws::Greengrass::UpdateDeviceDefinition> | ||
| 2603 | |||
| 2604 | Returns: a L<Paws::Greengrass::UpdateDeviceDefinitionResponse> instance | ||
| 2605 | |||
| 2606 | Updates a device definition. | ||
| 2607 | |||
| 2608 | |||
| 2609 | =head2 UpdateFunctionDefinition | ||
| 2610 | |||
| 2611 | =over | ||
| 2612 | |||
| 2613 | =item FunctionDefinitionId => Str | ||
| 2614 | |||
| 2615 | =item [Name => Str] | ||
| 2616 | |||
| 2617 | |||
| 2618 | =back | ||
| 2619 | |||
| 2620 | Each argument is described in detail in: L<Paws::Greengrass::UpdateFunctionDefinition> | ||
| 2621 | |||
| 2622 | Returns: a L<Paws::Greengrass::UpdateFunctionDefinitionResponse> instance | ||
| 2623 | |||
| 2624 | Updates a Lambda function definition. | ||
| 2625 | |||
| 2626 | |||
| 2627 | =head2 UpdateGroup | ||
| 2628 | |||
| 2629 | =over | ||
| 2630 | |||
| 2631 | =item GroupId => Str | ||
| 2632 | |||
| 2633 | =item [Name => Str] | ||
| 2634 | |||
| 2635 | |||
| 2636 | =back | ||
| 2637 | |||
| 2638 | Each argument is described in detail in: L<Paws::Greengrass::UpdateGroup> | ||
| 2639 | |||
| 2640 | Returns: a L<Paws::Greengrass::UpdateGroupResponse> instance | ||
| 2641 | |||
| 2642 | Updates a group. | ||
| 2643 | |||
| 2644 | |||
| 2645 | =head2 UpdateGroupCertificateConfiguration | ||
| 2646 | |||
| 2647 | =over | ||
| 2648 | |||
| 2649 | =item GroupId => Str | ||
| 2650 | |||
| 2651 | =item [CertificateExpiryInMilliseconds => Str] | ||
| 2652 | |||
| 2653 | |||
| 2654 | =back | ||
| 2655 | |||
| 2656 | Each argument is described in detail in: L<Paws::Greengrass::UpdateGroupCertificateConfiguration> | ||
| 2657 | |||
| 2658 | Returns: a L<Paws::Greengrass::UpdateGroupCertificateConfigurationResponse> instance | ||
| 2659 | |||
| 2660 | Updates the Certificate expiry time for a group. | ||
| 2661 | |||
| 2662 | |||
| 2663 | =head2 UpdateLoggerDefinition | ||
| 2664 | |||
| 2665 | =over | ||
| 2666 | |||
| 2667 | =item LoggerDefinitionId => Str | ||
| 2668 | |||
| 2669 | =item [Name => Str] | ||
| 2670 | |||
| 2671 | |||
| 2672 | =back | ||
| 2673 | |||
| 2674 | Each argument is described in detail in: L<Paws::Greengrass::UpdateLoggerDefinition> | ||
| 2675 | |||
| 2676 | Returns: a L<Paws::Greengrass::UpdateLoggerDefinitionResponse> instance | ||
| 2677 | |||
| 2678 | Updates a logger definition. | ||
| 2679 | |||
| 2680 | |||
| 2681 | =head2 UpdateResourceDefinition | ||
| 2682 | |||
| 2683 | =over | ||
| 2684 | |||
| 2685 | =item ResourceDefinitionId => Str | ||
| 2686 | |||
| 2687 | =item [Name => Str] | ||
| 2688 | |||
| 2689 | |||
| 2690 | =back | ||
| 2691 | |||
| 2692 | Each argument is described in detail in: L<Paws::Greengrass::UpdateResourceDefinition> | ||
| 2693 | |||
| 2694 | Returns: a L<Paws::Greengrass::UpdateResourceDefinitionResponse> instance | ||
| 2695 | |||
| 2696 | Updates a resource definition. | ||
| 2697 | |||
| 2698 | |||
| 2699 | =head2 UpdateSubscriptionDefinition | ||
| 2700 | |||
| 2701 | =over | ||
| 2702 | |||
| 2703 | =item SubscriptionDefinitionId => Str | ||
| 2704 | |||
| 2705 | =item [Name => Str] | ||
| 2706 | |||
| 2707 | |||
| 2708 | =back | ||
| 2709 | |||
| 2710 | Each argument is described in detail in: L<Paws::Greengrass::UpdateSubscriptionDefinition> | ||
| 2711 | |||
| 2712 | Returns: a L<Paws::Greengrass::UpdateSubscriptionDefinitionResponse> instance | ||
| 2713 | |||
| 2714 | Updates a subscription definition. | ||
| 2715 | |||
| 2716 | |||
| 2717 | =head2 UpdateThingRuntimeConfiguration | ||
| 2718 | |||
| 2719 | =over | ||
| 2720 | |||
| 2721 | =item ThingName => Str | ||
| 2722 | |||
| 2723 | =item [TelemetryConfiguration => L<Paws::Greengrass::TelemetryConfigurationUpdate>] | ||
| 2724 | |||
| 2725 | |||
| 2726 | =back | ||
| 2727 | |||
| 2728 | Each argument is described in detail in: L<Paws::Greengrass::UpdateThingRuntimeConfiguration> | ||
| 2729 | |||
| 2730 | Returns: a L<Paws::Greengrass::UpdateThingRuntimeConfigurationResponse> instance | ||
| 2731 | |||
| 2732 | Updates the runtime configuration of a thing. | ||
| 2733 | |||
| 2734 | |||
| 2735 | |||
| 2736 | |||
| 2737 | =head1 PAGINATORS | ||
| 2738 | |||
| 2739 | Paginator methods are helpers that repetively call methods that return partial results | ||
| 2740 | |||
| 2741 | =head2 ListAllBulkDeploymentDetailedReports(sub { },BulkDeploymentId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2742 | |||
| 2743 | =head2 ListAllBulkDeploymentDetailedReports(BulkDeploymentId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2744 | |||
| 2745 | |||
| 2746 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2747 | |||
| 2748 | - Deployments, passing the object as the first parameter, and the string 'Deployments' as the second parameter | ||
| 2749 | |||
| 2750 | If not, it will return a a L<Paws::Greengrass::ListBulkDeploymentDetailedReportsResponse> 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. | ||
| 2751 | |||
| 2752 | |||
| 2753 | =head2 ListAllBulkDeployments(sub { },[MaxResults => Str, NextToken => Str]) | ||
| 2754 | |||
| 2755 | =head2 ListAllBulkDeployments([MaxResults => Str, NextToken => Str]) | ||
| 2756 | |||
| 2757 | |||
| 2758 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2759 | |||
| 2760 | - BulkDeployments, passing the object as the first parameter, and the string 'BulkDeployments' as the second parameter | ||
| 2761 | |||
| 2762 | If not, it will return a a L<Paws::Greengrass::ListBulkDeploymentsResponse> 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. | ||
| 2763 | |||
| 2764 | |||
| 2765 | =head2 ListAllConnectorDefinitions(sub { },[MaxResults => Str, NextToken => Str]) | ||
| 2766 | |||
| 2767 | =head2 ListAllConnectorDefinitions([MaxResults => Str, NextToken => Str]) | ||
| 2768 | |||
| 2769 | |||
| 2770 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2771 | |||
| 2772 | - Definitions, passing the object as the first parameter, and the string 'Definitions' as the second parameter | ||
| 2773 | |||
| 2774 | If not, it will return a a L<Paws::Greengrass::ListConnectorDefinitionsResponse> 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. | ||
| 2775 | |||
| 2776 | |||
| 2777 | =head2 ListAllConnectorDefinitionVersions(sub { },ConnectorDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2778 | |||
| 2779 | =head2 ListAllConnectorDefinitionVersions(ConnectorDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2780 | |||
| 2781 | |||
| 2782 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2783 | |||
| 2784 | - Versions, passing the object as the first parameter, and the string 'Versions' as the second parameter | ||
| 2785 | |||
| 2786 | If not, it will return a a L<Paws::Greengrass::ListConnectorDefinitionVersionsResponse> 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. | ||
| 2787 | |||
| 2788 | |||
| 2789 | =head2 ListAllCoreDefinitions(sub { },[MaxResults => Str, NextToken => Str]) | ||
| 2790 | |||
| 2791 | =head2 ListAllCoreDefinitions([MaxResults => Str, NextToken => Str]) | ||
| 2792 | |||
| 2793 | |||
| 2794 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2795 | |||
| 2796 | - Definitions, passing the object as the first parameter, and the string 'Definitions' as the second parameter | ||
| 2797 | |||
| 2798 | If not, it will return a a L<Paws::Greengrass::ListCoreDefinitionsResponse> 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. | ||
| 2799 | |||
| 2800 | |||
| 2801 | =head2 ListAllCoreDefinitionVersions(sub { },CoreDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2802 | |||
| 2803 | =head2 ListAllCoreDefinitionVersions(CoreDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2804 | |||
| 2805 | |||
| 2806 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2807 | |||
| 2808 | - Versions, passing the object as the first parameter, and the string 'Versions' as the second parameter | ||
| 2809 | |||
| 2810 | If not, it will return a a L<Paws::Greengrass::ListCoreDefinitionVersionsResponse> 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. | ||
| 2811 | |||
| 2812 | |||
| 2813 | =head2 ListAllDeployments(sub { },GroupId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2814 | |||
| 2815 | =head2 ListAllDeployments(GroupId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2816 | |||
| 2817 | |||
| 2818 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2819 | |||
| 2820 | - Deployments, passing the object as the first parameter, and the string 'Deployments' as the second parameter | ||
| 2821 | |||
| 2822 | If not, it will return a a L<Paws::Greengrass::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. | ||
| 2823 | |||
| 2824 | |||
| 2825 | =head2 ListAllDeviceDefinitions(sub { },[MaxResults => Str, NextToken => Str]) | ||
| 2826 | |||
| 2827 | =head2 ListAllDeviceDefinitions([MaxResults => Str, NextToken => Str]) | ||
| 2828 | |||
| 2829 | |||
| 2830 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2831 | |||
| 2832 | - Definitions, passing the object as the first parameter, and the string 'Definitions' as the second parameter | ||
| 2833 | |||
| 2834 | If not, it will return a a L<Paws::Greengrass::ListDeviceDefinitionsResponse> 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. | ||
| 2835 | |||
| 2836 | |||
| 2837 | =head2 ListAllDeviceDefinitionVersions(sub { },DeviceDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2838 | |||
| 2839 | =head2 ListAllDeviceDefinitionVersions(DeviceDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2840 | |||
| 2841 | |||
| 2842 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2843 | |||
| 2844 | - Versions, passing the object as the first parameter, and the string 'Versions' as the second parameter | ||
| 2845 | |||
| 2846 | If not, it will return a a L<Paws::Greengrass::ListDeviceDefinitionVersionsResponse> 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. | ||
| 2847 | |||
| 2848 | |||
| 2849 | =head2 ListAllFunctionDefinitions(sub { },[MaxResults => Str, NextToken => Str]) | ||
| 2850 | |||
| 2851 | =head2 ListAllFunctionDefinitions([MaxResults => Str, NextToken => Str]) | ||
| 2852 | |||
| 2853 | |||
| 2854 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2855 | |||
| 2856 | - Definitions, passing the object as the first parameter, and the string 'Definitions' as the second parameter | ||
| 2857 | |||
| 2858 | If not, it will return a a L<Paws::Greengrass::ListFunctionDefinitionsResponse> 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. | ||
| 2859 | |||
| 2860 | |||
| 2861 | =head2 ListAllFunctionDefinitionVersions(sub { },FunctionDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2862 | |||
| 2863 | =head2 ListAllFunctionDefinitionVersions(FunctionDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2864 | |||
| 2865 | |||
| 2866 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2867 | |||
| 2868 | - Versions, passing the object as the first parameter, and the string 'Versions' as the second parameter | ||
| 2869 | |||
| 2870 | If not, it will return a a L<Paws::Greengrass::ListFunctionDefinitionVersionsResponse> 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. | ||
| 2871 | |||
| 2872 | |||
| 2873 | =head2 ListAllGroups(sub { },[MaxResults => Str, NextToken => Str]) | ||
| 2874 | |||
| 2875 | =head2 ListAllGroups([MaxResults => Str, NextToken => Str]) | ||
| 2876 | |||
| 2877 | |||
| 2878 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2879 | |||
| 2880 | - Groups, passing the object as the first parameter, and the string 'Groups' as the second parameter | ||
| 2881 | |||
| 2882 | If not, it will return a a L<Paws::Greengrass::ListGroupsResponse> 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. | ||
| 2883 | |||
| 2884 | |||
| 2885 | =head2 ListAllGroupVersions(sub { },GroupId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2886 | |||
| 2887 | =head2 ListAllGroupVersions(GroupId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2888 | |||
| 2889 | |||
| 2890 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2891 | |||
| 2892 | - Versions, passing the object as the first parameter, and the string 'Versions' as the second parameter | ||
| 2893 | |||
| 2894 | If not, it will return a a L<Paws::Greengrass::ListGroupVersionsResponse> 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. | ||
| 2895 | |||
| 2896 | |||
| 2897 | =head2 ListAllLoggerDefinitions(sub { },[MaxResults => Str, NextToken => Str]) | ||
| 2898 | |||
| 2899 | =head2 ListAllLoggerDefinitions([MaxResults => Str, NextToken => Str]) | ||
| 2900 | |||
| 2901 | |||
| 2902 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2903 | |||
| 2904 | - Definitions, passing the object as the first parameter, and the string 'Definitions' as the second parameter | ||
| 2905 | |||
| 2906 | If not, it will return a a L<Paws::Greengrass::ListLoggerDefinitionsResponse> 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. | ||
| 2907 | |||
| 2908 | |||
| 2909 | =head2 ListAllLoggerDefinitionVersions(sub { },LoggerDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2910 | |||
| 2911 | =head2 ListAllLoggerDefinitionVersions(LoggerDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2912 | |||
| 2913 | |||
| 2914 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2915 | |||
| 2916 | - Versions, passing the object as the first parameter, and the string 'Versions' as the second parameter | ||
| 2917 | |||
| 2918 | If not, it will return a a L<Paws::Greengrass::ListLoggerDefinitionVersionsResponse> 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. | ||
| 2919 | |||
| 2920 | |||
| 2921 | =head2 ListAllResourceDefinitions(sub { },[MaxResults => Str, NextToken => Str]) | ||
| 2922 | |||
| 2923 | =head2 ListAllResourceDefinitions([MaxResults => Str, NextToken => Str]) | ||
| 2924 | |||
| 2925 | |||
| 2926 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2927 | |||
| 2928 | - Definitions, passing the object as the first parameter, and the string 'Definitions' as the second parameter | ||
| 2929 | |||
| 2930 | If not, it will return a a L<Paws::Greengrass::ListResourceDefinitionsResponse> 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. | ||
| 2931 | |||
| 2932 | |||
| 2933 | =head2 ListAllResourceDefinitionVersions(sub { },ResourceDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2934 | |||
| 2935 | =head2 ListAllResourceDefinitionVersions(ResourceDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2936 | |||
| 2937 | |||
| 2938 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2939 | |||
| 2940 | - Versions, passing the object as the first parameter, and the string 'Versions' as the second parameter | ||
| 2941 | |||
| 2942 | If not, it will return a a L<Paws::Greengrass::ListResourceDefinitionVersionsResponse> 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. | ||
| 2943 | |||
| 2944 | |||
| 2945 | =head2 ListAllSubscriptionDefinitions(sub { },[MaxResults => Str, NextToken => Str]) | ||
| 2946 | |||
| 2947 | =head2 ListAllSubscriptionDefinitions([MaxResults => Str, NextToken => Str]) | ||
| 2948 | |||
| 2949 | |||
| 2950 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2951 | |||
| 2952 | - Definitions, passing the object as the first parameter, and the string 'Definitions' as the second parameter | ||
| 2953 | |||
| 2954 | If not, it will return a a L<Paws::Greengrass::ListSubscriptionDefinitionsResponse> 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. | ||
| 2955 | |||
| 2956 | |||
| 2957 | =head2 ListAllSubscriptionDefinitionVersions(sub { },SubscriptionDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2958 | |||
| 2959 | =head2 ListAllSubscriptionDefinitionVersions(SubscriptionDefinitionId => Str, [MaxResults => Str, NextToken => Str]) | ||
| 2960 | |||
| 2961 | |||
| 2962 | If passed a sub as first parameter, it will call the sub for each element found in : | ||
| 2963 | |||
| 2964 | - Versions, passing the object as the first parameter, and the string 'Versions' as the second parameter | ||
| 2965 | |||
| 2966 | If not, it will return a a L<Paws::Greengrass::ListSubscriptionDefinitionVersionsResponse> 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. | ||
| 2967 | |||
| 2968 | |||
| 2969 | |||
| 2970 | |||
| 2971 | |||
| 2972 | =head1 SEE ALSO | ||
| 2973 | |||
| 2974 | This service class forms part of L<Paws> | ||
| 2975 | |||
| 2976 | =head1 BUGS and CONTRIBUTIONS | ||
| 2977 | |||
| 2978 | The source code is located here: L<https://github.com/pplu/aws-sdk-perl> | ||
| 2979 | |||
| 2980 | Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues> | ||
| 2981 | |||
| 2982 | =cut | ||
| 2983 |