aws-sdk-elasticloadbalancing 1.50.0 → 1.52.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 +10 -0
- data/VERSION +1 -1
- data/lib/aws-sdk-elasticloadbalancing/client.rb +1 -1
- data/lib/aws-sdk-elasticloadbalancing/plugins/endpoints.rb +4 -2
- data/lib/aws-sdk-elasticloadbalancing.rb +1 -1
- data/sig/client.rbs +501 -0
- data/sig/errors.rbs +60 -0
- data/sig/resource.rbs +79 -0
- data/sig/types.rbs +569 -0
- data/sig/waiters.rbs +58 -0
- metadata +13 -8
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA256:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: f7c86c1a479d92eb735b67d035bfb54a8bc5e5b071880f862f9f1e1c90096763
|
|
4
|
+
data.tar.gz: 6e03634506d69500385a292b53dea7b890843de2f8d5d50b56311f039bed83a0
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: 47df44e7a93cbceb63f81c9b3309697607f116dd51629edd628c5d13d1675c7f3c46a9a8b9f9b794ee2316da76ad5309b9de18119f0bd5da185a969adfdf3473
|
|
7
|
+
data.tar.gz: 14dfd2f6bf93c382b04e8672c927de73ddf9c0703daeed05b9f46e7431dc70b95758e633510f6767b62491be4557d2800c0afcfdf1848a81851eec250444ace3
|
data/CHANGELOG.md
CHANGED
|
@@ -1,6 +1,16 @@
|
|
|
1
1
|
Unreleased Changes
|
|
2
2
|
------------------
|
|
3
3
|
|
|
4
|
+
1.52.0 (2024-01-26)
|
|
5
|
+
------------------
|
|
6
|
+
|
|
7
|
+
* Feature - Code Generated Changes, see `./build_tools` or `aws-sdk-core`'s CHANGELOG.md for details.
|
|
8
|
+
|
|
9
|
+
1.51.0 (2023-11-28)
|
|
10
|
+
------------------
|
|
11
|
+
|
|
12
|
+
* Feature - Code Generated Changes, see `./build_tools` or `aws-sdk-core`'s CHANGELOG.md for details.
|
|
13
|
+
|
|
4
14
|
1.50.0 (2023-11-22)
|
|
5
15
|
------------------
|
|
6
16
|
|
data/VERSION
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
1.
|
|
1
|
+
1.52.0
|
|
@@ -2673,7 +2673,7 @@ module Aws::ElasticLoadBalancing
|
|
|
2673
2673
|
params: params,
|
|
2674
2674
|
config: config)
|
|
2675
2675
|
context[:gem_name] = 'aws-sdk-elasticloadbalancing'
|
|
2676
|
-
context[:gem_version] = '1.
|
|
2676
|
+
context[:gem_version] = '1.52.0'
|
|
2677
2677
|
Seahorse::Client::Request.new(handlers, context)
|
|
2678
2678
|
end
|
|
2679
2679
|
|
|
@@ -14,6 +14,7 @@ module Aws::ElasticLoadBalancing
|
|
|
14
14
|
option(
|
|
15
15
|
:endpoint_provider,
|
|
16
16
|
doc_type: 'Aws::ElasticLoadBalancing::EndpointProvider',
|
|
17
|
+
rbs_type: 'untyped',
|
|
17
18
|
docstring: 'The endpoint provider used to resolve endpoints. Any '\
|
|
18
19
|
'object that responds to `#resolve_endpoint(parameters)` '\
|
|
19
20
|
'where `parameters` is a Struct similar to '\
|
|
@@ -25,16 +26,17 @@ module Aws::ElasticLoadBalancing
|
|
|
25
26
|
# @api private
|
|
26
27
|
class Handler < Seahorse::Client::Handler
|
|
27
28
|
def call(context)
|
|
28
|
-
# If endpoint was discovered, do not resolve or apply the endpoint.
|
|
29
29
|
unless context[:discovered_endpoint]
|
|
30
30
|
params = parameters_for_operation(context)
|
|
31
31
|
endpoint = context.config.endpoint_provider.resolve_endpoint(params)
|
|
32
32
|
|
|
33
33
|
context.http_request.endpoint = endpoint.url
|
|
34
34
|
apply_endpoint_headers(context, endpoint.headers)
|
|
35
|
+
|
|
36
|
+
context[:endpoint_params] = params
|
|
37
|
+
context[:endpoint_properties] = endpoint.properties
|
|
35
38
|
end
|
|
36
39
|
|
|
37
|
-
context[:endpoint_params] = params
|
|
38
40
|
context[:auth_scheme] =
|
|
39
41
|
Aws::Endpoints.resolve_auth_scheme(context, endpoint)
|
|
40
42
|
|
data/sig/client.rbs
ADDED
|
@@ -0,0 +1,501 @@
|
|
|
1
|
+
# WARNING ABOUT GENERATED CODE
|
|
2
|
+
#
|
|
3
|
+
# This file is generated. See the contributing guide for more information:
|
|
4
|
+
# https://github.com/aws/aws-sdk-ruby/blob/version-3/CONTRIBUTING.md
|
|
5
|
+
#
|
|
6
|
+
# WARNING ABOUT GENERATED CODE
|
|
7
|
+
|
|
8
|
+
module Aws
|
|
9
|
+
module ElasticLoadBalancing
|
|
10
|
+
class Client < ::Seahorse::Client::Base
|
|
11
|
+
include ::Aws::ClientStubs
|
|
12
|
+
|
|
13
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#initialize-instance_method
|
|
14
|
+
def self.new: (
|
|
15
|
+
?credentials: untyped,
|
|
16
|
+
?region: String,
|
|
17
|
+
?access_key_id: String,
|
|
18
|
+
?active_endpoint_cache: bool,
|
|
19
|
+
?adaptive_retry_wait_to_fill: bool,
|
|
20
|
+
?client_side_monitoring: bool,
|
|
21
|
+
?client_side_monitoring_client_id: String,
|
|
22
|
+
?client_side_monitoring_host: String,
|
|
23
|
+
?client_side_monitoring_port: Integer,
|
|
24
|
+
?client_side_monitoring_publisher: untyped,
|
|
25
|
+
?convert_params: bool,
|
|
26
|
+
?correct_clock_skew: bool,
|
|
27
|
+
?defaults_mode: String,
|
|
28
|
+
?disable_host_prefix_injection: bool,
|
|
29
|
+
?disable_request_compression: bool,
|
|
30
|
+
?endpoint: String,
|
|
31
|
+
?endpoint_cache_max_entries: Integer,
|
|
32
|
+
?endpoint_cache_max_threads: Integer,
|
|
33
|
+
?endpoint_cache_poll_interval: Integer,
|
|
34
|
+
?endpoint_discovery: bool,
|
|
35
|
+
?ignore_configured_endpoint_urls: bool,
|
|
36
|
+
?log_formatter: untyped,
|
|
37
|
+
?log_level: Symbol,
|
|
38
|
+
?logger: untyped,
|
|
39
|
+
?max_attempts: Integer,
|
|
40
|
+
?profile: String,
|
|
41
|
+
?request_min_compression_size_bytes: Integer,
|
|
42
|
+
?retry_backoff: Proc,
|
|
43
|
+
?retry_base_delay: Float,
|
|
44
|
+
?retry_jitter: (:none | :equal | :full | ^(Integer) -> Integer),
|
|
45
|
+
?retry_limit: Integer,
|
|
46
|
+
?retry_max_delay: Integer,
|
|
47
|
+
?retry_mode: ("legacy" | "standard" | "adaptive"),
|
|
48
|
+
?sdk_ua_app_id: String,
|
|
49
|
+
?secret_access_key: String,
|
|
50
|
+
?session_token: String,
|
|
51
|
+
?stub_responses: untyped,
|
|
52
|
+
?token_provider: untyped,
|
|
53
|
+
?use_dualstack_endpoint: bool,
|
|
54
|
+
?use_fips_endpoint: bool,
|
|
55
|
+
?validate_params: bool,
|
|
56
|
+
?endpoint_provider: untyped,
|
|
57
|
+
?http_proxy: String,
|
|
58
|
+
?http_open_timeout: (Float | Integer),
|
|
59
|
+
?http_read_timeout: (Float | Integer),
|
|
60
|
+
?http_idle_timeout: (Float | Integer),
|
|
61
|
+
?http_continue_timeout: (Float | Integer),
|
|
62
|
+
?ssl_timeout: (Float | Integer | nil),
|
|
63
|
+
?http_wire_trace: bool,
|
|
64
|
+
?ssl_verify_peer: bool,
|
|
65
|
+
?ssl_ca_bundle: String,
|
|
66
|
+
?ssl_ca_directory: String,
|
|
67
|
+
?ssl_ca_store: String,
|
|
68
|
+
?on_chunk_received: Proc,
|
|
69
|
+
?on_chunk_sent: Proc,
|
|
70
|
+
?raise_response_errors: bool
|
|
71
|
+
) -> instance
|
|
72
|
+
| (?Hash[Symbol, untyped]) -> instance
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+
interface _AddTagsResponseSuccess
|
|
76
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::AddTagsOutput]
|
|
77
|
+
end
|
|
78
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#add_tags-instance_method
|
|
79
|
+
def add_tags: (
|
|
80
|
+
load_balancer_names: Array[::String],
|
|
81
|
+
tags: Array[
|
|
82
|
+
{
|
|
83
|
+
key: ::String,
|
|
84
|
+
value: ::String?
|
|
85
|
+
},
|
|
86
|
+
]
|
|
87
|
+
) -> _AddTagsResponseSuccess
|
|
88
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AddTagsResponseSuccess
|
|
89
|
+
|
|
90
|
+
interface _ApplySecurityGroupsToLoadBalancerResponseSuccess
|
|
91
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ApplySecurityGroupsToLoadBalancerOutput]
|
|
92
|
+
def security_groups: () -> ::Array[::String]
|
|
93
|
+
end
|
|
94
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#apply_security_groups_to_load_balancer-instance_method
|
|
95
|
+
def apply_security_groups_to_load_balancer: (
|
|
96
|
+
load_balancer_name: ::String,
|
|
97
|
+
security_groups: Array[::String]
|
|
98
|
+
) -> _ApplySecurityGroupsToLoadBalancerResponseSuccess
|
|
99
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ApplySecurityGroupsToLoadBalancerResponseSuccess
|
|
100
|
+
|
|
101
|
+
interface _AttachLoadBalancerToSubnetsResponseSuccess
|
|
102
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::AttachLoadBalancerToSubnetsOutput]
|
|
103
|
+
def subnets: () -> ::Array[::String]
|
|
104
|
+
end
|
|
105
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#attach_load_balancer_to_subnets-instance_method
|
|
106
|
+
def attach_load_balancer_to_subnets: (
|
|
107
|
+
load_balancer_name: ::String,
|
|
108
|
+
subnets: Array[::String]
|
|
109
|
+
) -> _AttachLoadBalancerToSubnetsResponseSuccess
|
|
110
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _AttachLoadBalancerToSubnetsResponseSuccess
|
|
111
|
+
|
|
112
|
+
interface _ConfigureHealthCheckResponseSuccess
|
|
113
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ConfigureHealthCheckOutput]
|
|
114
|
+
def health_check: () -> Types::HealthCheck
|
|
115
|
+
end
|
|
116
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#configure_health_check-instance_method
|
|
117
|
+
def configure_health_check: (
|
|
118
|
+
load_balancer_name: ::String,
|
|
119
|
+
health_check: {
|
|
120
|
+
target: ::String,
|
|
121
|
+
interval: ::Integer,
|
|
122
|
+
timeout: ::Integer,
|
|
123
|
+
unhealthy_threshold: ::Integer,
|
|
124
|
+
healthy_threshold: ::Integer
|
|
125
|
+
}
|
|
126
|
+
) -> _ConfigureHealthCheckResponseSuccess
|
|
127
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ConfigureHealthCheckResponseSuccess
|
|
128
|
+
|
|
129
|
+
interface _CreateAppCookieStickinessPolicyResponseSuccess
|
|
130
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateAppCookieStickinessPolicyOutput]
|
|
131
|
+
end
|
|
132
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#create_app_cookie_stickiness_policy-instance_method
|
|
133
|
+
def create_app_cookie_stickiness_policy: (
|
|
134
|
+
load_balancer_name: ::String,
|
|
135
|
+
policy_name: ::String,
|
|
136
|
+
cookie_name: ::String
|
|
137
|
+
) -> _CreateAppCookieStickinessPolicyResponseSuccess
|
|
138
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateAppCookieStickinessPolicyResponseSuccess
|
|
139
|
+
|
|
140
|
+
interface _CreateLBCookieStickinessPolicyResponseSuccess
|
|
141
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateLBCookieStickinessPolicyOutput]
|
|
142
|
+
end
|
|
143
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#create_lb_cookie_stickiness_policy-instance_method
|
|
144
|
+
def create_lb_cookie_stickiness_policy: (
|
|
145
|
+
load_balancer_name: ::String,
|
|
146
|
+
policy_name: ::String,
|
|
147
|
+
?cookie_expiration_period: ::Integer
|
|
148
|
+
) -> _CreateLBCookieStickinessPolicyResponseSuccess
|
|
149
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateLBCookieStickinessPolicyResponseSuccess
|
|
150
|
+
|
|
151
|
+
interface _CreateLoadBalancerResponseSuccess
|
|
152
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateAccessPointOutput]
|
|
153
|
+
def dns_name: () -> ::String
|
|
154
|
+
end
|
|
155
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#create_load_balancer-instance_method
|
|
156
|
+
def create_load_balancer: (
|
|
157
|
+
load_balancer_name: ::String,
|
|
158
|
+
listeners: Array[
|
|
159
|
+
{
|
|
160
|
+
protocol: ::String,
|
|
161
|
+
load_balancer_port: ::Integer,
|
|
162
|
+
instance_protocol: ::String?,
|
|
163
|
+
instance_port: ::Integer,
|
|
164
|
+
ssl_certificate_id: ::String?
|
|
165
|
+
},
|
|
166
|
+
],
|
|
167
|
+
?availability_zones: Array[::String],
|
|
168
|
+
?subnets: Array[::String],
|
|
169
|
+
?security_groups: Array[::String],
|
|
170
|
+
?scheme: ::String,
|
|
171
|
+
?tags: Array[
|
|
172
|
+
{
|
|
173
|
+
key: ::String,
|
|
174
|
+
value: ::String?
|
|
175
|
+
},
|
|
176
|
+
]
|
|
177
|
+
) -> _CreateLoadBalancerResponseSuccess
|
|
178
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateLoadBalancerResponseSuccess
|
|
179
|
+
|
|
180
|
+
interface _CreateLoadBalancerListenersResponseSuccess
|
|
181
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateLoadBalancerListenerOutput]
|
|
182
|
+
end
|
|
183
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#create_load_balancer_listeners-instance_method
|
|
184
|
+
def create_load_balancer_listeners: (
|
|
185
|
+
load_balancer_name: ::String,
|
|
186
|
+
listeners: Array[
|
|
187
|
+
{
|
|
188
|
+
protocol: ::String,
|
|
189
|
+
load_balancer_port: ::Integer,
|
|
190
|
+
instance_protocol: ::String?,
|
|
191
|
+
instance_port: ::Integer,
|
|
192
|
+
ssl_certificate_id: ::String?
|
|
193
|
+
},
|
|
194
|
+
]
|
|
195
|
+
) -> _CreateLoadBalancerListenersResponseSuccess
|
|
196
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateLoadBalancerListenersResponseSuccess
|
|
197
|
+
|
|
198
|
+
interface _CreateLoadBalancerPolicyResponseSuccess
|
|
199
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::CreateLoadBalancerPolicyOutput]
|
|
200
|
+
end
|
|
201
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#create_load_balancer_policy-instance_method
|
|
202
|
+
def create_load_balancer_policy: (
|
|
203
|
+
load_balancer_name: ::String,
|
|
204
|
+
policy_name: ::String,
|
|
205
|
+
policy_type_name: ::String,
|
|
206
|
+
?policy_attributes: Array[
|
|
207
|
+
{
|
|
208
|
+
attribute_name: ::String?,
|
|
209
|
+
attribute_value: ::String?
|
|
210
|
+
},
|
|
211
|
+
]
|
|
212
|
+
) -> _CreateLoadBalancerPolicyResponseSuccess
|
|
213
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _CreateLoadBalancerPolicyResponseSuccess
|
|
214
|
+
|
|
215
|
+
interface _DeleteLoadBalancerResponseSuccess
|
|
216
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DeleteAccessPointOutput]
|
|
217
|
+
end
|
|
218
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#delete_load_balancer-instance_method
|
|
219
|
+
def delete_load_balancer: (
|
|
220
|
+
load_balancer_name: ::String
|
|
221
|
+
) -> _DeleteLoadBalancerResponseSuccess
|
|
222
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteLoadBalancerResponseSuccess
|
|
223
|
+
|
|
224
|
+
interface _DeleteLoadBalancerListenersResponseSuccess
|
|
225
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DeleteLoadBalancerListenerOutput]
|
|
226
|
+
end
|
|
227
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#delete_load_balancer_listeners-instance_method
|
|
228
|
+
def delete_load_balancer_listeners: (
|
|
229
|
+
load_balancer_name: ::String,
|
|
230
|
+
load_balancer_ports: Array[::Integer]
|
|
231
|
+
) -> _DeleteLoadBalancerListenersResponseSuccess
|
|
232
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteLoadBalancerListenersResponseSuccess
|
|
233
|
+
|
|
234
|
+
interface _DeleteLoadBalancerPolicyResponseSuccess
|
|
235
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DeleteLoadBalancerPolicyOutput]
|
|
236
|
+
end
|
|
237
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#delete_load_balancer_policy-instance_method
|
|
238
|
+
def delete_load_balancer_policy: (
|
|
239
|
+
load_balancer_name: ::String,
|
|
240
|
+
policy_name: ::String
|
|
241
|
+
) -> _DeleteLoadBalancerPolicyResponseSuccess
|
|
242
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeleteLoadBalancerPolicyResponseSuccess
|
|
243
|
+
|
|
244
|
+
interface _DeregisterInstancesFromLoadBalancerResponseSuccess
|
|
245
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DeregisterEndPointsOutput]
|
|
246
|
+
def instances: () -> ::Array[Types::Instance]
|
|
247
|
+
end
|
|
248
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#deregister_instances_from_load_balancer-instance_method
|
|
249
|
+
def deregister_instances_from_load_balancer: (
|
|
250
|
+
load_balancer_name: ::String,
|
|
251
|
+
instances: Array[
|
|
252
|
+
{
|
|
253
|
+
instance_id: ::String?
|
|
254
|
+
},
|
|
255
|
+
]
|
|
256
|
+
) -> _DeregisterInstancesFromLoadBalancerResponseSuccess
|
|
257
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DeregisterInstancesFromLoadBalancerResponseSuccess
|
|
258
|
+
|
|
259
|
+
interface _DescribeAccountLimitsResponseSuccess
|
|
260
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeAccountLimitsOutput]
|
|
261
|
+
def limits: () -> ::Array[Types::Limit]
|
|
262
|
+
def next_marker: () -> ::String
|
|
263
|
+
end
|
|
264
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#describe_account_limits-instance_method
|
|
265
|
+
def describe_account_limits: (
|
|
266
|
+
?marker: ::String,
|
|
267
|
+
?page_size: ::Integer
|
|
268
|
+
) -> _DescribeAccountLimitsResponseSuccess
|
|
269
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeAccountLimitsResponseSuccess
|
|
270
|
+
|
|
271
|
+
interface _DescribeInstanceHealthResponseSuccess
|
|
272
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeEndPointStateOutput]
|
|
273
|
+
def instance_states: () -> ::Array[Types::InstanceState]
|
|
274
|
+
end
|
|
275
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#describe_instance_health-instance_method
|
|
276
|
+
def describe_instance_health: (
|
|
277
|
+
load_balancer_name: ::String,
|
|
278
|
+
?instances: Array[
|
|
279
|
+
{
|
|
280
|
+
instance_id: ::String?
|
|
281
|
+
},
|
|
282
|
+
]
|
|
283
|
+
) -> _DescribeInstanceHealthResponseSuccess
|
|
284
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeInstanceHealthResponseSuccess
|
|
285
|
+
|
|
286
|
+
interface _DescribeLoadBalancerAttributesResponseSuccess
|
|
287
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeLoadBalancerAttributesOutput]
|
|
288
|
+
def load_balancer_attributes: () -> Types::LoadBalancerAttributes
|
|
289
|
+
end
|
|
290
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#describe_load_balancer_attributes-instance_method
|
|
291
|
+
def describe_load_balancer_attributes: (
|
|
292
|
+
load_balancer_name: ::String
|
|
293
|
+
) -> _DescribeLoadBalancerAttributesResponseSuccess
|
|
294
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeLoadBalancerAttributesResponseSuccess
|
|
295
|
+
|
|
296
|
+
interface _DescribeLoadBalancerPoliciesResponseSuccess
|
|
297
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeLoadBalancerPoliciesOutput]
|
|
298
|
+
def policy_descriptions: () -> ::Array[Types::PolicyDescription]
|
|
299
|
+
end
|
|
300
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#describe_load_balancer_policies-instance_method
|
|
301
|
+
def describe_load_balancer_policies: (
|
|
302
|
+
?load_balancer_name: ::String,
|
|
303
|
+
?policy_names: Array[::String]
|
|
304
|
+
) -> _DescribeLoadBalancerPoliciesResponseSuccess
|
|
305
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeLoadBalancerPoliciesResponseSuccess
|
|
306
|
+
|
|
307
|
+
interface _DescribeLoadBalancerPolicyTypesResponseSuccess
|
|
308
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeLoadBalancerPolicyTypesOutput]
|
|
309
|
+
def policy_type_descriptions: () -> ::Array[Types::PolicyTypeDescription]
|
|
310
|
+
end
|
|
311
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#describe_load_balancer_policy_types-instance_method
|
|
312
|
+
def describe_load_balancer_policy_types: (
|
|
313
|
+
?policy_type_names: Array[::String]
|
|
314
|
+
) -> _DescribeLoadBalancerPolicyTypesResponseSuccess
|
|
315
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeLoadBalancerPolicyTypesResponseSuccess
|
|
316
|
+
|
|
317
|
+
interface _DescribeLoadBalancersResponseSuccess
|
|
318
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeAccessPointsOutput]
|
|
319
|
+
def load_balancer_descriptions: () -> ::Array[Types::LoadBalancerDescription]
|
|
320
|
+
def next_marker: () -> ::String
|
|
321
|
+
end
|
|
322
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#describe_load_balancers-instance_method
|
|
323
|
+
def describe_load_balancers: (
|
|
324
|
+
?load_balancer_names: Array[::String],
|
|
325
|
+
?marker: ::String,
|
|
326
|
+
?page_size: ::Integer
|
|
327
|
+
) -> _DescribeLoadBalancersResponseSuccess
|
|
328
|
+
| (?Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeLoadBalancersResponseSuccess
|
|
329
|
+
|
|
330
|
+
interface _DescribeTagsResponseSuccess
|
|
331
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DescribeTagsOutput]
|
|
332
|
+
def tag_descriptions: () -> ::Array[Types::TagDescription]
|
|
333
|
+
end
|
|
334
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#describe_tags-instance_method
|
|
335
|
+
def describe_tags: (
|
|
336
|
+
load_balancer_names: Array[::String]
|
|
337
|
+
) -> _DescribeTagsResponseSuccess
|
|
338
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DescribeTagsResponseSuccess
|
|
339
|
+
|
|
340
|
+
interface _DetachLoadBalancerFromSubnetsResponseSuccess
|
|
341
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::DetachLoadBalancerFromSubnetsOutput]
|
|
342
|
+
def subnets: () -> ::Array[::String]
|
|
343
|
+
end
|
|
344
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#detach_load_balancer_from_subnets-instance_method
|
|
345
|
+
def detach_load_balancer_from_subnets: (
|
|
346
|
+
load_balancer_name: ::String,
|
|
347
|
+
subnets: Array[::String]
|
|
348
|
+
) -> _DetachLoadBalancerFromSubnetsResponseSuccess
|
|
349
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DetachLoadBalancerFromSubnetsResponseSuccess
|
|
350
|
+
|
|
351
|
+
interface _DisableAvailabilityZonesForLoadBalancerResponseSuccess
|
|
352
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::RemoveAvailabilityZonesOutput]
|
|
353
|
+
def availability_zones: () -> ::Array[::String]
|
|
354
|
+
end
|
|
355
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#disable_availability_zones_for_load_balancer-instance_method
|
|
356
|
+
def disable_availability_zones_for_load_balancer: (
|
|
357
|
+
load_balancer_name: ::String,
|
|
358
|
+
availability_zones: Array[::String]
|
|
359
|
+
) -> _DisableAvailabilityZonesForLoadBalancerResponseSuccess
|
|
360
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _DisableAvailabilityZonesForLoadBalancerResponseSuccess
|
|
361
|
+
|
|
362
|
+
interface _EnableAvailabilityZonesForLoadBalancerResponseSuccess
|
|
363
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::AddAvailabilityZonesOutput]
|
|
364
|
+
def availability_zones: () -> ::Array[::String]
|
|
365
|
+
end
|
|
366
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#enable_availability_zones_for_load_balancer-instance_method
|
|
367
|
+
def enable_availability_zones_for_load_balancer: (
|
|
368
|
+
load_balancer_name: ::String,
|
|
369
|
+
availability_zones: Array[::String]
|
|
370
|
+
) -> _EnableAvailabilityZonesForLoadBalancerResponseSuccess
|
|
371
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _EnableAvailabilityZonesForLoadBalancerResponseSuccess
|
|
372
|
+
|
|
373
|
+
interface _ModifyLoadBalancerAttributesResponseSuccess
|
|
374
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::ModifyLoadBalancerAttributesOutput]
|
|
375
|
+
def load_balancer_name: () -> ::String
|
|
376
|
+
def load_balancer_attributes: () -> Types::LoadBalancerAttributes
|
|
377
|
+
end
|
|
378
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#modify_load_balancer_attributes-instance_method
|
|
379
|
+
def modify_load_balancer_attributes: (
|
|
380
|
+
load_balancer_name: ::String,
|
|
381
|
+
load_balancer_attributes: {
|
|
382
|
+
cross_zone_load_balancing: {
|
|
383
|
+
enabled: bool
|
|
384
|
+
}?,
|
|
385
|
+
access_log: {
|
|
386
|
+
enabled: bool,
|
|
387
|
+
s3_bucket_name: ::String?,
|
|
388
|
+
emit_interval: ::Integer?,
|
|
389
|
+
s3_bucket_prefix: ::String?
|
|
390
|
+
}?,
|
|
391
|
+
connection_draining: {
|
|
392
|
+
enabled: bool,
|
|
393
|
+
timeout: ::Integer?
|
|
394
|
+
}?,
|
|
395
|
+
connection_settings: {
|
|
396
|
+
idle_timeout: ::Integer
|
|
397
|
+
}?,
|
|
398
|
+
additional_attributes: Array[
|
|
399
|
+
{
|
|
400
|
+
key: ::String?,
|
|
401
|
+
value: ::String?
|
|
402
|
+
},
|
|
403
|
+
]?
|
|
404
|
+
}
|
|
405
|
+
) -> _ModifyLoadBalancerAttributesResponseSuccess
|
|
406
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _ModifyLoadBalancerAttributesResponseSuccess
|
|
407
|
+
|
|
408
|
+
interface _RegisterInstancesWithLoadBalancerResponseSuccess
|
|
409
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::RegisterEndPointsOutput]
|
|
410
|
+
def instances: () -> ::Array[Types::Instance]
|
|
411
|
+
end
|
|
412
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#register_instances_with_load_balancer-instance_method
|
|
413
|
+
def register_instances_with_load_balancer: (
|
|
414
|
+
load_balancer_name: ::String,
|
|
415
|
+
instances: Array[
|
|
416
|
+
{
|
|
417
|
+
instance_id: ::String?
|
|
418
|
+
},
|
|
419
|
+
]
|
|
420
|
+
) -> _RegisterInstancesWithLoadBalancerResponseSuccess
|
|
421
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RegisterInstancesWithLoadBalancerResponseSuccess
|
|
422
|
+
|
|
423
|
+
interface _RemoveTagsResponseSuccess
|
|
424
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::RemoveTagsOutput]
|
|
425
|
+
end
|
|
426
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#remove_tags-instance_method
|
|
427
|
+
def remove_tags: (
|
|
428
|
+
load_balancer_names: Array[::String],
|
|
429
|
+
tags: Array[
|
|
430
|
+
{
|
|
431
|
+
key: ::String?
|
|
432
|
+
},
|
|
433
|
+
]
|
|
434
|
+
) -> _RemoveTagsResponseSuccess
|
|
435
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _RemoveTagsResponseSuccess
|
|
436
|
+
|
|
437
|
+
interface _SetLoadBalancerListenerSSLCertificateResponseSuccess
|
|
438
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::SetLoadBalancerListenerSSLCertificateOutput]
|
|
439
|
+
end
|
|
440
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#set_load_balancer_listener_ssl_certificate-instance_method
|
|
441
|
+
def set_load_balancer_listener_ssl_certificate: (
|
|
442
|
+
load_balancer_name: ::String,
|
|
443
|
+
load_balancer_port: ::Integer,
|
|
444
|
+
ssl_certificate_id: ::String
|
|
445
|
+
) -> _SetLoadBalancerListenerSSLCertificateResponseSuccess
|
|
446
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SetLoadBalancerListenerSSLCertificateResponseSuccess
|
|
447
|
+
|
|
448
|
+
interface _SetLoadBalancerPoliciesForBackendServerResponseSuccess
|
|
449
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::SetLoadBalancerPoliciesForBackendServerOutput]
|
|
450
|
+
end
|
|
451
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#set_load_balancer_policies_for_backend_server-instance_method
|
|
452
|
+
def set_load_balancer_policies_for_backend_server: (
|
|
453
|
+
load_balancer_name: ::String,
|
|
454
|
+
instance_port: ::Integer,
|
|
455
|
+
policy_names: Array[::String]
|
|
456
|
+
) -> _SetLoadBalancerPoliciesForBackendServerResponseSuccess
|
|
457
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SetLoadBalancerPoliciesForBackendServerResponseSuccess
|
|
458
|
+
|
|
459
|
+
interface _SetLoadBalancerPoliciesOfListenerResponseSuccess
|
|
460
|
+
include ::Seahorse::Client::_ResponseSuccess[Types::SetLoadBalancerPoliciesOfListenerOutput]
|
|
461
|
+
end
|
|
462
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#set_load_balancer_policies_of_listener-instance_method
|
|
463
|
+
def set_load_balancer_policies_of_listener: (
|
|
464
|
+
load_balancer_name: ::String,
|
|
465
|
+
load_balancer_port: ::Integer,
|
|
466
|
+
policy_names: Array[::String]
|
|
467
|
+
) -> _SetLoadBalancerPoliciesOfListenerResponseSuccess
|
|
468
|
+
| (Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> _SetLoadBalancerPoliciesOfListenerResponseSuccess
|
|
469
|
+
|
|
470
|
+
# https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ElasticLoadBalancing/Client.html#wait_until-instance_method
|
|
471
|
+
def wait_until: (:any_instance_in_service waiter_name,
|
|
472
|
+
load_balancer_name: ::String,
|
|
473
|
+
?instances: Array[
|
|
474
|
+
{
|
|
475
|
+
instance_id: ::String?
|
|
476
|
+
},
|
|
477
|
+
]
|
|
478
|
+
) -> Client::_DescribeInstanceHealthResponseSuccess
|
|
479
|
+
| (:any_instance_in_service waiter_name, Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> Client::_DescribeInstanceHealthResponseSuccess
|
|
480
|
+
| (:instance_deregistered waiter_name,
|
|
481
|
+
load_balancer_name: ::String,
|
|
482
|
+
?instances: Array[
|
|
483
|
+
{
|
|
484
|
+
instance_id: ::String?
|
|
485
|
+
},
|
|
486
|
+
]
|
|
487
|
+
) -> Client::_DescribeInstanceHealthResponseSuccess
|
|
488
|
+
| (:instance_deregistered waiter_name, Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> Client::_DescribeInstanceHealthResponseSuccess
|
|
489
|
+
| (:instance_in_service waiter_name,
|
|
490
|
+
load_balancer_name: ::String,
|
|
491
|
+
?instances: Array[
|
|
492
|
+
{
|
|
493
|
+
instance_id: ::String?
|
|
494
|
+
},
|
|
495
|
+
]
|
|
496
|
+
) -> Client::_DescribeInstanceHealthResponseSuccess
|
|
497
|
+
| (:instance_in_service waiter_name, Hash[Symbol, untyped] params, ?Hash[Symbol, untyped] options) -> Client::_DescribeInstanceHealthResponseSuccess
|
|
498
|
+
end
|
|
499
|
+
end
|
|
500
|
+
end
|
|
501
|
+
|
data/sig/errors.rbs
ADDED
|
@@ -0,0 +1,60 @@
|
|
|
1
|
+
# WARNING ABOUT GENERATED CODE
|
|
2
|
+
#
|
|
3
|
+
# This file is generated. See the contributing guide for more information:
|
|
4
|
+
# https://github.com/aws/aws-sdk-ruby/blob/version-3/CONTRIBUTING.md
|
|
5
|
+
#
|
|
6
|
+
# WARNING ABOUT GENERATED CODE
|
|
7
|
+
|
|
8
|
+
module Aws
|
|
9
|
+
module ElasticLoadBalancing
|
|
10
|
+
module Errors
|
|
11
|
+
class ServiceError < ::Aws::Errors::ServiceError
|
|
12
|
+
end
|
|
13
|
+
|
|
14
|
+
class AccessPointNotFoundException < ::Aws::Errors::ServiceError
|
|
15
|
+
end
|
|
16
|
+
class CertificateNotFoundException < ::Aws::Errors::ServiceError
|
|
17
|
+
end
|
|
18
|
+
class DependencyThrottleException < ::Aws::Errors::ServiceError
|
|
19
|
+
end
|
|
20
|
+
class DuplicateAccessPointNameException < ::Aws::Errors::ServiceError
|
|
21
|
+
end
|
|
22
|
+
class DuplicateListenerException < ::Aws::Errors::ServiceError
|
|
23
|
+
end
|
|
24
|
+
class DuplicatePolicyNameException < ::Aws::Errors::ServiceError
|
|
25
|
+
end
|
|
26
|
+
class DuplicateTagKeysException < ::Aws::Errors::ServiceError
|
|
27
|
+
end
|
|
28
|
+
class InvalidConfigurationRequestException < ::Aws::Errors::ServiceError
|
|
29
|
+
end
|
|
30
|
+
class InvalidEndPointException < ::Aws::Errors::ServiceError
|
|
31
|
+
end
|
|
32
|
+
class InvalidSchemeException < ::Aws::Errors::ServiceError
|
|
33
|
+
end
|
|
34
|
+
class InvalidSecurityGroupException < ::Aws::Errors::ServiceError
|
|
35
|
+
end
|
|
36
|
+
class InvalidSubnetException < ::Aws::Errors::ServiceError
|
|
37
|
+
end
|
|
38
|
+
class ListenerNotFoundException < ::Aws::Errors::ServiceError
|
|
39
|
+
end
|
|
40
|
+
class LoadBalancerAttributeNotFoundException < ::Aws::Errors::ServiceError
|
|
41
|
+
end
|
|
42
|
+
class OperationNotPermittedException < ::Aws::Errors::ServiceError
|
|
43
|
+
end
|
|
44
|
+
class PolicyNotFoundException < ::Aws::Errors::ServiceError
|
|
45
|
+
end
|
|
46
|
+
class PolicyTypeNotFoundException < ::Aws::Errors::ServiceError
|
|
47
|
+
end
|
|
48
|
+
class SubnetNotFoundException < ::Aws::Errors::ServiceError
|
|
49
|
+
end
|
|
50
|
+
class TooManyAccessPointsException < ::Aws::Errors::ServiceError
|
|
51
|
+
end
|
|
52
|
+
class TooManyPoliciesException < ::Aws::Errors::ServiceError
|
|
53
|
+
end
|
|
54
|
+
class TooManyTagsException < ::Aws::Errors::ServiceError
|
|
55
|
+
end
|
|
56
|
+
class UnsupportedProtocolException < ::Aws::Errors::ServiceError
|
|
57
|
+
end
|
|
58
|
+
end
|
|
59
|
+
end
|
|
60
|
+
end
|