aws-sdk-bedrockagentcorecontrol 1.15.0 → 1.16.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGELOG.md +5 -0
- data/VERSION +1 -1
- data/lib/aws-sdk-bedrockagentcorecontrol/client.rb +2169 -52
- data/lib/aws-sdk-bedrockagentcorecontrol/client_api.rb +1294 -0
- data/lib/aws-sdk-bedrockagentcorecontrol/types.rb +3803 -196
- data/lib/aws-sdk-bedrockagentcorecontrol/waiters.rb +279 -3
- data/lib/aws-sdk-bedrockagentcorecontrol.rb +1 -1
- data/sig/client.rbs +790 -6
- data/sig/types.rbs +956 -29
- data/sig/waiters.rbs +53 -0
- metadata +1 -1
|
@@ -67,9 +67,14 @@ module Aws::BedrockAgentCoreControl
|
|
|
67
67
|
# The following table lists the valid waiter names, the operations they call,
|
|
68
68
|
# and the default `:delay` and `:max_attempts` values.
|
|
69
69
|
#
|
|
70
|
-
# | waiter_name
|
|
71
|
-
# |
|
|
72
|
-
# | memory_created
|
|
70
|
+
# | waiter_name | params | :delay | :max_attempts |
|
|
71
|
+
# | --------------------------- | ------------------------------ | -------- | ------------- |
|
|
72
|
+
# | memory_created | {Client#get_memory} | 2 | 60 |
|
|
73
|
+
# | policy_active | {Client#get_policy} | 2 | 60 |
|
|
74
|
+
# | policy_deleted | {Client#get_policy} | 2 | 60 |
|
|
75
|
+
# | policy_engine_active | {Client#get_policy_engine} | 2 | 60 |
|
|
76
|
+
# | policy_engine_deleted | {Client#get_policy_engine} | 2 | 60 |
|
|
77
|
+
# | policy_generation_completed | {Client#get_policy_generation} | 2 | 60 |
|
|
73
78
|
#
|
|
74
79
|
module Waiters
|
|
75
80
|
|
|
@@ -122,5 +127,276 @@ module Aws::BedrockAgentCoreControl
|
|
|
122
127
|
attr_reader :waiter
|
|
123
128
|
|
|
124
129
|
end
|
|
130
|
+
|
|
131
|
+
# Wait until a Policy is active
|
|
132
|
+
class PolicyActive
|
|
133
|
+
|
|
134
|
+
# @param [Hash] options
|
|
135
|
+
# @option options [required, Client] :client
|
|
136
|
+
# @option options [Integer] :max_attempts (60)
|
|
137
|
+
# @option options [Integer] :delay (2)
|
|
138
|
+
# @option options [Proc] :before_attempt
|
|
139
|
+
# @option options [Proc] :before_wait
|
|
140
|
+
def initialize(options)
|
|
141
|
+
@client = options.fetch(:client)
|
|
142
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
143
|
+
max_attempts: 60,
|
|
144
|
+
delay: 2,
|
|
145
|
+
poller: Aws::Waiters::Poller.new(
|
|
146
|
+
operation_name: :get_policy,
|
|
147
|
+
acceptors: [
|
|
148
|
+
{
|
|
149
|
+
"matcher" => "path",
|
|
150
|
+
"argument" => "status",
|
|
151
|
+
"state" => "success",
|
|
152
|
+
"expected" => "ACTIVE"
|
|
153
|
+
},
|
|
154
|
+
{
|
|
155
|
+
"matcher" => "path",
|
|
156
|
+
"argument" => "status",
|
|
157
|
+
"state" => "failure",
|
|
158
|
+
"expected" => "CREATE_FAILED"
|
|
159
|
+
},
|
|
160
|
+
{
|
|
161
|
+
"matcher" => "path",
|
|
162
|
+
"argument" => "status",
|
|
163
|
+
"state" => "failure",
|
|
164
|
+
"expected" => "UPDATE_FAILED"
|
|
165
|
+
},
|
|
166
|
+
{
|
|
167
|
+
"matcher" => "path",
|
|
168
|
+
"argument" => "status",
|
|
169
|
+
"state" => "failure",
|
|
170
|
+
"expected" => "DELETE_FAILED"
|
|
171
|
+
}
|
|
172
|
+
]
|
|
173
|
+
)
|
|
174
|
+
}.merge(options))
|
|
175
|
+
end
|
|
176
|
+
|
|
177
|
+
# @option (see Client#get_policy)
|
|
178
|
+
# @return (see Client#get_policy)
|
|
179
|
+
def wait(params = {})
|
|
180
|
+
@waiter.wait(client: @client, params: params)
|
|
181
|
+
end
|
|
182
|
+
|
|
183
|
+
# @api private
|
|
184
|
+
attr_reader :waiter
|
|
185
|
+
|
|
186
|
+
end
|
|
187
|
+
|
|
188
|
+
# Wait until a Policy is deleted
|
|
189
|
+
class PolicyDeleted
|
|
190
|
+
|
|
191
|
+
# @param [Hash] options
|
|
192
|
+
# @option options [required, Client] :client
|
|
193
|
+
# @option options [Integer] :max_attempts (60)
|
|
194
|
+
# @option options [Integer] :delay (2)
|
|
195
|
+
# @option options [Proc] :before_attempt
|
|
196
|
+
# @option options [Proc] :before_wait
|
|
197
|
+
def initialize(options)
|
|
198
|
+
@client = options.fetch(:client)
|
|
199
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
200
|
+
max_attempts: 60,
|
|
201
|
+
delay: 2,
|
|
202
|
+
poller: Aws::Waiters::Poller.new(
|
|
203
|
+
operation_name: :get_policy,
|
|
204
|
+
acceptors: [
|
|
205
|
+
{
|
|
206
|
+
"matcher" => "error",
|
|
207
|
+
"state" => "success",
|
|
208
|
+
"expected" => "ResourceNotFoundException"
|
|
209
|
+
},
|
|
210
|
+
{
|
|
211
|
+
"matcher" => "path",
|
|
212
|
+
"argument" => "status",
|
|
213
|
+
"state" => "retry",
|
|
214
|
+
"expected" => "DELETING"
|
|
215
|
+
},
|
|
216
|
+
{
|
|
217
|
+
"matcher" => "path",
|
|
218
|
+
"argument" => "status",
|
|
219
|
+
"state" => "failure",
|
|
220
|
+
"expected" => "DELETE_FAILED"
|
|
221
|
+
}
|
|
222
|
+
]
|
|
223
|
+
)
|
|
224
|
+
}.merge(options))
|
|
225
|
+
end
|
|
226
|
+
|
|
227
|
+
# @option (see Client#get_policy)
|
|
228
|
+
# @return (see Client#get_policy)
|
|
229
|
+
def wait(params = {})
|
|
230
|
+
@waiter.wait(client: @client, params: params)
|
|
231
|
+
end
|
|
232
|
+
|
|
233
|
+
# @api private
|
|
234
|
+
attr_reader :waiter
|
|
235
|
+
|
|
236
|
+
end
|
|
237
|
+
|
|
238
|
+
# Wait until a PolicyEngine is active
|
|
239
|
+
class PolicyEngineActive
|
|
240
|
+
|
|
241
|
+
# @param [Hash] options
|
|
242
|
+
# @option options [required, Client] :client
|
|
243
|
+
# @option options [Integer] :max_attempts (60)
|
|
244
|
+
# @option options [Integer] :delay (2)
|
|
245
|
+
# @option options [Proc] :before_attempt
|
|
246
|
+
# @option options [Proc] :before_wait
|
|
247
|
+
def initialize(options)
|
|
248
|
+
@client = options.fetch(:client)
|
|
249
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
250
|
+
max_attempts: 60,
|
|
251
|
+
delay: 2,
|
|
252
|
+
poller: Aws::Waiters::Poller.new(
|
|
253
|
+
operation_name: :get_policy_engine,
|
|
254
|
+
acceptors: [
|
|
255
|
+
{
|
|
256
|
+
"matcher" => "path",
|
|
257
|
+
"argument" => "status",
|
|
258
|
+
"state" => "success",
|
|
259
|
+
"expected" => "ACTIVE"
|
|
260
|
+
},
|
|
261
|
+
{
|
|
262
|
+
"matcher" => "path",
|
|
263
|
+
"argument" => "status",
|
|
264
|
+
"state" => "failure",
|
|
265
|
+
"expected" => "CREATE_FAILED"
|
|
266
|
+
},
|
|
267
|
+
{
|
|
268
|
+
"matcher" => "path",
|
|
269
|
+
"argument" => "status",
|
|
270
|
+
"state" => "failure",
|
|
271
|
+
"expected" => "UPDATE_FAILED"
|
|
272
|
+
},
|
|
273
|
+
{
|
|
274
|
+
"matcher" => "path",
|
|
275
|
+
"argument" => "status",
|
|
276
|
+
"state" => "failure",
|
|
277
|
+
"expected" => "DELETE_FAILED"
|
|
278
|
+
}
|
|
279
|
+
]
|
|
280
|
+
)
|
|
281
|
+
}.merge(options))
|
|
282
|
+
end
|
|
283
|
+
|
|
284
|
+
# @option (see Client#get_policy_engine)
|
|
285
|
+
# @return (see Client#get_policy_engine)
|
|
286
|
+
def wait(params = {})
|
|
287
|
+
@waiter.wait(client: @client, params: params)
|
|
288
|
+
end
|
|
289
|
+
|
|
290
|
+
# @api private
|
|
291
|
+
attr_reader :waiter
|
|
292
|
+
|
|
293
|
+
end
|
|
294
|
+
|
|
295
|
+
# Wait until a PolicyEngine is deleted
|
|
296
|
+
class PolicyEngineDeleted
|
|
297
|
+
|
|
298
|
+
# @param [Hash] options
|
|
299
|
+
# @option options [required, Client] :client
|
|
300
|
+
# @option options [Integer] :max_attempts (60)
|
|
301
|
+
# @option options [Integer] :delay (2)
|
|
302
|
+
# @option options [Proc] :before_attempt
|
|
303
|
+
# @option options [Proc] :before_wait
|
|
304
|
+
def initialize(options)
|
|
305
|
+
@client = options.fetch(:client)
|
|
306
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
307
|
+
max_attempts: 60,
|
|
308
|
+
delay: 2,
|
|
309
|
+
poller: Aws::Waiters::Poller.new(
|
|
310
|
+
operation_name: :get_policy_engine,
|
|
311
|
+
acceptors: [
|
|
312
|
+
{
|
|
313
|
+
"matcher" => "error",
|
|
314
|
+
"state" => "success",
|
|
315
|
+
"expected" => "ResourceNotFoundException"
|
|
316
|
+
},
|
|
317
|
+
{
|
|
318
|
+
"matcher" => "path",
|
|
319
|
+
"argument" => "status",
|
|
320
|
+
"state" => "retry",
|
|
321
|
+
"expected" => "DELETING"
|
|
322
|
+
},
|
|
323
|
+
{
|
|
324
|
+
"matcher" => "path",
|
|
325
|
+
"argument" => "status",
|
|
326
|
+
"state" => "failure",
|
|
327
|
+
"expected" => "DELETE_FAILED"
|
|
328
|
+
}
|
|
329
|
+
]
|
|
330
|
+
)
|
|
331
|
+
}.merge(options))
|
|
332
|
+
end
|
|
333
|
+
|
|
334
|
+
# @option (see Client#get_policy_engine)
|
|
335
|
+
# @return (see Client#get_policy_engine)
|
|
336
|
+
def wait(params = {})
|
|
337
|
+
@waiter.wait(client: @client, params: params)
|
|
338
|
+
end
|
|
339
|
+
|
|
340
|
+
# @api private
|
|
341
|
+
attr_reader :waiter
|
|
342
|
+
|
|
343
|
+
end
|
|
344
|
+
|
|
345
|
+
# Wait until policy generation is completed
|
|
346
|
+
class PolicyGenerationCompleted
|
|
347
|
+
|
|
348
|
+
# @param [Hash] options
|
|
349
|
+
# @option options [required, Client] :client
|
|
350
|
+
# @option options [Integer] :max_attempts (60)
|
|
351
|
+
# @option options [Integer] :delay (2)
|
|
352
|
+
# @option options [Proc] :before_attempt
|
|
353
|
+
# @option options [Proc] :before_wait
|
|
354
|
+
def initialize(options)
|
|
355
|
+
@client = options.fetch(:client)
|
|
356
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
357
|
+
max_attempts: 60,
|
|
358
|
+
delay: 2,
|
|
359
|
+
poller: Aws::Waiters::Poller.new(
|
|
360
|
+
operation_name: :get_policy_generation,
|
|
361
|
+
acceptors: [
|
|
362
|
+
{
|
|
363
|
+
"matcher" => "path",
|
|
364
|
+
"argument" => "status",
|
|
365
|
+
"state" => "success",
|
|
366
|
+
"expected" => "GENERATED"
|
|
367
|
+
},
|
|
368
|
+
{
|
|
369
|
+
"matcher" => "path",
|
|
370
|
+
"argument" => "status",
|
|
371
|
+
"state" => "retry",
|
|
372
|
+
"expected" => "GENERATING"
|
|
373
|
+
},
|
|
374
|
+
{
|
|
375
|
+
"matcher" => "path",
|
|
376
|
+
"argument" => "status",
|
|
377
|
+
"state" => "failure",
|
|
378
|
+
"expected" => "GENERATE_FAILED"
|
|
379
|
+
},
|
|
380
|
+
{
|
|
381
|
+
"matcher" => "path",
|
|
382
|
+
"argument" => "status",
|
|
383
|
+
"state" => "failure",
|
|
384
|
+
"expected" => "DELETE_FAILED"
|
|
385
|
+
}
|
|
386
|
+
]
|
|
387
|
+
)
|
|
388
|
+
}.merge(options))
|
|
389
|
+
end
|
|
390
|
+
|
|
391
|
+
# @option (see Client#get_policy_generation)
|
|
392
|
+
# @return (see Client#get_policy_generation)
|
|
393
|
+
def wait(params = {})
|
|
394
|
+
@waiter.wait(client: @client, params: params)
|
|
395
|
+
end
|
|
396
|
+
|
|
397
|
+
# @api private
|
|
398
|
+
attr_reader :waiter
|
|
399
|
+
|
|
400
|
+
end
|
|
125
401
|
end
|
|
126
402
|
end
|