//// Generated from com.amazonaws.sqs#AmazonSQS (awsJson1_0).
//// DO NOT EDIT. Re-generate via the codegen subproject.
import aws/config
import aws/endpoints
import aws/internal/client/runtime
import aws/internal/credentials_cache
import aws/pagination
import aws/region
import gleam/bit_array
import gleam/dict
import gleam/dynamic/decode
import gleam/int
import gleam/json
import gleam/list
import gleam/option
import gleam/result
pub opaque type Client {
Client(config: runtime.ClientConfig, cache: credentials_cache.Cache)
}
/// Smithy endpoint rule set for this service, lifted verbatim from
/// the source model. Parsed once in `new_with` and attached to every
/// Client via `runtime.with_endpoint_rule_set`.
const endpoint_rule_set_json: String = "{\"parameters\":{\"Endpoint\":{\"builtIn\":\"SDK::Endpoint\",\"documentation\":\"Override the endpoint used to send this request\",\"required\":false,\"type\":\"string\"},\"Region\":{\"builtIn\":\"AWS::Region\",\"documentation\":\"The AWS region used to dispatch the request.\",\"required\":false,\"type\":\"string\"},\"UseDualStack\":{\"builtIn\":\"AWS::UseDualStack\",\"default\":false,\"documentation\":\"When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.\",\"required\":true,\"type\":\"boolean\"},\"UseFIPS\":{\"builtIn\":\"AWS::UseFIPS\",\"default\":false,\"documentation\":\"When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.\",\"required\":true,\"type\":\"boolean\"}},\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"Endpoint\"}],\"fn\":\"isSet\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"error\":\"Invalid Configuration: FIPS and custom endpoint are not supported\",\"type\":\"error\"},{\"conditions\":[{\"argv\":[{\"ref\":\"UseDualStack\"},true],\"fn\":\"booleanEquals\"}],\"error\":\"Invalid Configuration: Dualstack and custom endpoint are not supported\",\"type\":\"error\"},{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":{\"ref\":\"Endpoint\"}},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[{\"argv\":[{\"ref\":\"Region\"}],\"fn\":\"isSet\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"Region\"}],\"assign\":\"PartitionResult\",\"fn\":\"aws.partition\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"},{\"argv\":[{\"ref\":\"UseDualStack\"},true],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[true,{\"argv\":[{\"ref\":\"PartitionResult\"},\"supportsFIPS\"],\"fn\":\"getAttr\"}],\"fn\":\"booleanEquals\"},{\"argv\":[true,{\"argv\":[{\"ref\":\"PartitionResult\"},\"supportsDualStack\"],\"fn\":\"getAttr\"}],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://sqs-fips.{Region}.{PartitionResult#dualStackDnsSuffix}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"FIPS and DualStack are enabled, but this partition does not support one or both\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[{\"argv\":[{\"ref\":\"UseFIPS\"},true],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"supportsFIPS\"],\"fn\":\"getAttr\"},true],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[{\"argv\":[{\"ref\":\"PartitionResult\"},\"name\"],\"fn\":\"getAttr\"},\"aws-us-gov\"],\"fn\":\"stringEquals\"}],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://sqs.{Region}.amazonaws.com\"},\"type\":\"endpoint\"},{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://sqs-fips.{Region}.{PartitionResult#dnsSuffix}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"FIPS is enabled but this partition does not support FIPS\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[{\"argv\":[{\"ref\":\"UseDualStack\"},true],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[{\"argv\":[true,{\"argv\":[{\"ref\":\"PartitionResult\"},\"supportsDualStack\"],\"fn\":\"getAttr\"}],\"fn\":\"booleanEquals\"}],\"rules\":[{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://sqs.{Region}.{PartitionResult#dualStackDnsSuffix}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"DualStack is enabled but this partition does not support DualStack\",\"type\":\"error\"}],\"type\":\"tree\"},{\"conditions\":[],\"endpoint\":{\"headers\":{},\"properties\":{},\"url\":\"https://sqs.{Region}.{PartitionResult#dnsSuffix}\"},\"type\":\"endpoint\"}],\"type\":\"tree\"}],\"type\":\"tree\"},{\"conditions\":[],\"error\":\"Invalid Configuration: Missing Region\",\"type\":\"error\"}],\"version\":\"1.0\"}"
/// AWS endpoint-rule-set parameters for this service. Each `Some` value
/// feeds endpoint resolution; `None` keeps the rule set's own default.
/// Start from `default_endpoint_params()` and override what you need.
pub type EndpointParams {
EndpointParams(
use_dual_stack: option.Option(Bool),
use_fips: option.Option(Bool),
)
}
/// The all-default `EndpointParams`: every parameter left to the rule
/// set's default. Spread it and override only the params you need.
pub fn default_endpoint_params() -> EndpointParams {
EndpointParams(use_dual_stack: option.None, use_fips: option.None)
}
/// Build a Client with everything resolved automatically: the region
/// from the standard AWS sources (`AWS_REGION`, `AWS_DEFAULT_REGION`,
/// `~/.aws/config`) and credentials from the default chain. Zero
/// config — the path you want in Lambda / ECS / EC2, where the
/// environment always supplies a region. `Error(_)` only when no
/// source provides one; pass explicit settings via `new_with` then.
pub fn new() -> Result(Client, region.ResolveError) {
new_with(config.default_settings(), default_endpoint_params())
}
/// Build a Client from explicit customer `config.Settings` and this
/// service's AWS `EndpointParams`. Start each from its defaults
/// (`config.default_settings()` / `default_endpoint_params()`) and
/// override only the fields you need. Region auto-resolves when
/// `settings.region` is `None` — the only failure path; credentials
/// resolve lazily on the first request.
pub fn new_with(
settings: config.Settings,
endpoint_params: EndpointParams,
) -> Result(Client, region.ResolveError) {
use cfg <- result.map(config.resolve(
settings,
endpoint_prefix: "sqs",
signing_name: "sqs",
))
let assert Ok(rule_set) = endpoints.parse_rule_set(endpoint_rule_set_json)
let cfg = runtime.with_endpoint_rule_set(cfg, rule_set)
let cfg = case endpoint_params.use_dual_stack {
option.Some(value) ->
runtime.with_endpoint_param(cfg, "UseDualStack", endpoints.BoolVal(value))
option.None -> cfg
}
let cfg = case endpoint_params.use_fips {
option.Some(value) ->
runtime.with_endpoint_param(cfg, "UseFIPS", endpoints.BoolVal(value))
option.None -> cfg
}
let assert Ok(cache) = credentials_cache.start_default(cfg.provider)
let cfg =
runtime.with_credentials_provider(cfg, credentials_cache.as_provider(cache))
Client(config: cfg, cache: cache)
}
/// Read the underlying `runtime.ClientConfig` out of an existing
/// `Client`. Use this when you want to dispatch a request through
/// `runtime.invoke` / `runtime.invoke_streaming` directly — e.g. to
/// build a service-specific streaming wrapper around a `@streaming`
/// output operation that the per-op codegen hasn't surfaced yet.
/// The returned config is a value (Gleam records are immutable);
/// callers cannot mutate the Client through it.
pub fn client_config(client: Client) -> runtime.ClientConfig {
client.config
}
/// Release the per-Client credentials cache actor. Call this when a
/// Client value is no longer needed — long-running processes that
/// build many Clients (tests, scripts, multi-tenant servers) will
/// otherwise accumulate one BEAM process per construction. Fire-and-
/// forget; safe to call multiple times. For tests or graceful
/// shutdown that must observe the actor's exit, use `shutdown_sync`.
pub fn shutdown(client: Client) -> Nil {
credentials_cache.shutdown(client.cache)
}
/// Like `shutdown` but blocks until the credentials cache actor has
/// actually exited (or `timeout_ms` elapses). `Ok(Nil)` indicates a
/// clean exit; `Error(Nil)` indicates the timeout fired and the
/// actor was still alive when the caller gave up.
pub fn shutdown_sync(
client: Client,
timeout_ms timeout_ms: Int,
) -> Result(Nil, Nil) {
credentials_cache.shutdown_sync(client.cache, timeout_ms)
}
pub type AddPermissionRequest {
AddPermissionRequest(
aws_account_ids: List(String),
actions: List(String),
label: String,
queue_url: String,
)
}
pub fn add_permission_request_default(
aws_account_ids aws_account_ids: List(String),
actions actions: List(String),
label label: String,
queue_url queue_url: String,
) -> AddPermissionRequest {
AddPermissionRequest(
aws_account_ids: aws_account_ids,
actions: actions,
label: label,
queue_url: queue_url,
)
}
pub fn encode_add_permission_request_struct(
input: AddPermissionRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.aws_account_ids
[#("AWSAccountIds", fn(xs) { json.array(xs, json.string) }(v)), ..pairs]
}
let pairs = {
let v = input.actions
[#("Actions", fn(xs) { json.array(xs, json.string) }(v)), ..pairs]
}
let pairs = {
let v = input.label
[#("Label", json.string(v)), ..pairs]
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_add_permission_request_struct_top(
input: AddPermissionRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.aws_account_ids
[#("AWSAccountIds", fn(xs) { json.array(xs, json.string) }(v)), ..pairs]
}
let pairs = {
let v = input.actions
[#("Actions", fn(xs) { json.array(xs, json.string) }(v)), ..pairs]
}
let pairs = {
let v = input.label
[#("Label", json.string(v)), ..pairs]
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_add_permission_request_struct() -> decode.Decoder(
AddPermissionRequest,
) {
use <- decode.recursive
use aws_account_ids <- decode.field(
"AWSAccountIds",
decode.list(decode.string),
)
use actions <- decode.field("Actions", decode.list(decode.string))
use label <- decode.field("Label", decode.string)
use queue_url <- decode.field("QueueUrl", decode.string)
decode.success(AddPermissionRequest(
aws_account_ids: aws_account_ids,
actions: actions,
label: label,
queue_url: queue_url,
))
}
pub type InvalidAddress {
InvalidAddress(message: option.Option(String))
}
pub fn invalid_address_default() -> InvalidAddress {
InvalidAddress(message: option.None)
}
pub fn encode_invalid_address_struct(input: InvalidAddress) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_invalid_address_struct_top(input: InvalidAddress) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_invalid_address_struct() -> decode.Decoder(InvalidAddress) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(InvalidAddress(message: message))
}
pub type InvalidSecurity {
InvalidSecurity(message: option.Option(String))
}
pub fn invalid_security_default() -> InvalidSecurity {
InvalidSecurity(message: option.None)
}
pub fn encode_invalid_security_struct(input: InvalidSecurity) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_invalid_security_struct_top(input: InvalidSecurity) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_invalid_security_struct() -> decode.Decoder(InvalidSecurity) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(InvalidSecurity(message: message))
}
pub type OverLimit {
OverLimit(message: option.Option(String))
}
pub fn over_limit_default() -> OverLimit {
OverLimit(message: option.None)
}
pub fn encode_over_limit_struct(input: OverLimit) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_over_limit_struct_top(input: OverLimit) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_over_limit_struct() -> decode.Decoder(OverLimit) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(OverLimit(message: message))
}
pub type QueueDoesNotExist {
QueueDoesNotExist(message: option.Option(String))
}
pub fn queue_does_not_exist_default() -> QueueDoesNotExist {
QueueDoesNotExist(message: option.None)
}
pub fn encode_queue_does_not_exist_struct(
input: QueueDoesNotExist,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_queue_does_not_exist_struct_top(
input: QueueDoesNotExist,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_queue_does_not_exist_struct() -> decode.Decoder(QueueDoesNotExist) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(QueueDoesNotExist(message: message))
}
pub type RequestThrottled {
RequestThrottled(message: option.Option(String))
}
pub fn request_throttled_default() -> RequestThrottled {
RequestThrottled(message: option.None)
}
pub fn encode_request_throttled_struct(input: RequestThrottled) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_request_throttled_struct_top(
input: RequestThrottled,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_request_throttled_struct() -> decode.Decoder(RequestThrottled) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(RequestThrottled(message: message))
}
pub type UnsupportedOperation {
UnsupportedOperation(message: option.Option(String))
}
pub fn unsupported_operation_default() -> UnsupportedOperation {
UnsupportedOperation(message: option.None)
}
pub fn encode_unsupported_operation_struct(
input: UnsupportedOperation,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_unsupported_operation_struct_top(
input: UnsupportedOperation,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_unsupported_operation_struct() -> decode.Decoder(
UnsupportedOperation,
) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(UnsupportedOperation(message: message))
}
pub type CancelMessageMoveTaskRequest {
CancelMessageMoveTaskRequest(task_handle: String)
}
pub fn cancel_message_move_task_request_default(
task_handle task_handle: String,
) -> CancelMessageMoveTaskRequest {
CancelMessageMoveTaskRequest(task_handle: task_handle)
}
pub fn encode_cancel_message_move_task_request_struct(
input: CancelMessageMoveTaskRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.task_handle
[#("TaskHandle", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_cancel_message_move_task_request_struct_top(
input: CancelMessageMoveTaskRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.task_handle
[#("TaskHandle", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_cancel_message_move_task_request_struct() -> decode.Decoder(
CancelMessageMoveTaskRequest,
) {
use <- decode.recursive
use task_handle <- decode.field("TaskHandle", decode.string)
decode.success(CancelMessageMoveTaskRequest(task_handle: task_handle))
}
pub type CancelMessageMoveTaskResult {
CancelMessageMoveTaskResult(
approximate_number_of_messages_moved: option.Option(Int),
)
}
pub fn cancel_message_move_task_result_default() -> CancelMessageMoveTaskResult {
CancelMessageMoveTaskResult(approximate_number_of_messages_moved: option.None)
}
pub fn encode_cancel_message_move_task_result_struct(
input: CancelMessageMoveTaskResult,
) -> json.Json {
let pairs = []
let pairs = case input.approximate_number_of_messages_moved {
option.Some(v) -> [
#("ApproximateNumberOfMessagesMoved", json.int(v)),
..pairs
]
option.None -> [#("ApproximateNumberOfMessagesMoved", json.int(0)), ..pairs]
}
json.object(pairs)
}
pub fn encode_cancel_message_move_task_result_struct_top(
input: CancelMessageMoveTaskResult,
) -> json.Json {
let pairs = []
let pairs = case input.approximate_number_of_messages_moved {
option.Some(v) -> [
#("ApproximateNumberOfMessagesMoved", json.int(v)),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_cancel_message_move_task_result_struct() -> decode.Decoder(
CancelMessageMoveTaskResult,
) {
use <- decode.recursive
use approximate_number_of_messages_moved <- decode.optional_field(
"ApproximateNumberOfMessagesMoved",
option.None,
decode.optional(decode.int),
)
decode.success(CancelMessageMoveTaskResult(
approximate_number_of_messages_moved: approximate_number_of_messages_moved,
))
}
pub type ResourceNotFoundException {
ResourceNotFoundException(message: option.Option(String))
}
pub fn resource_not_found_exception_default() -> ResourceNotFoundException {
ResourceNotFoundException(message: option.None)
}
pub fn encode_resource_not_found_exception_struct(
input: ResourceNotFoundException,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_resource_not_found_exception_struct_top(
input: ResourceNotFoundException,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_resource_not_found_exception_struct() -> decode.Decoder(
ResourceNotFoundException,
) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(ResourceNotFoundException(message: message))
}
pub type ChangeMessageVisibilityRequest {
ChangeMessageVisibilityRequest(
queue_url: String,
receipt_handle: String,
visibility_timeout: Int,
)
}
pub fn change_message_visibility_request_default(
queue_url queue_url: String,
receipt_handle receipt_handle: String,
visibility_timeout visibility_timeout: Int,
) -> ChangeMessageVisibilityRequest {
ChangeMessageVisibilityRequest(
queue_url: queue_url,
receipt_handle: receipt_handle,
visibility_timeout: visibility_timeout,
)
}
pub fn encode_change_message_visibility_request_struct(
input: ChangeMessageVisibilityRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
let pairs = {
let v = input.receipt_handle
[#("ReceiptHandle", json.string(v)), ..pairs]
}
let pairs = {
let v = input.visibility_timeout
[#("VisibilityTimeout", json.int(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_change_message_visibility_request_struct_top(
input: ChangeMessageVisibilityRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
let pairs = {
let v = input.receipt_handle
[#("ReceiptHandle", json.string(v)), ..pairs]
}
let pairs = {
let v = input.visibility_timeout
[#("VisibilityTimeout", json.int(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_change_message_visibility_request_struct() -> decode.Decoder(
ChangeMessageVisibilityRequest,
) {
use <- decode.recursive
use queue_url <- decode.field("QueueUrl", decode.string)
use receipt_handle <- decode.field("ReceiptHandle", decode.string)
use visibility_timeout <- decode.field("VisibilityTimeout", decode.int)
decode.success(ChangeMessageVisibilityRequest(
queue_url: queue_url,
receipt_handle: receipt_handle,
visibility_timeout: visibility_timeout,
))
}
pub type MessageNotInflight {
MessageNotInflight
}
pub fn message_not_inflight_default() -> MessageNotInflight {
MessageNotInflight
}
pub fn encode_message_not_inflight_struct(_v: MessageNotInflight) -> json.Json {
json.object([])
}
pub fn encode_message_not_inflight_struct_top(
_v: MessageNotInflight,
) -> json.Json {
json.object([])
}
pub fn decode_message_not_inflight_struct() -> decode.Decoder(
MessageNotInflight,
) {
decode.success(MessageNotInflight)
}
pub type ReceiptHandleIsInvalid {
ReceiptHandleIsInvalid(message: option.Option(String))
}
pub fn receipt_handle_is_invalid_default() -> ReceiptHandleIsInvalid {
ReceiptHandleIsInvalid(message: option.None)
}
pub fn encode_receipt_handle_is_invalid_struct(
input: ReceiptHandleIsInvalid,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_receipt_handle_is_invalid_struct_top(
input: ReceiptHandleIsInvalid,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_receipt_handle_is_invalid_struct() -> decode.Decoder(
ReceiptHandleIsInvalid,
) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(ReceiptHandleIsInvalid(message: message))
}
pub type ChangeMessageVisibilityBatchRequest {
ChangeMessageVisibilityBatchRequest(
entries: List(ChangeMessageVisibilityBatchRequestEntry),
queue_url: String,
)
}
pub fn change_message_visibility_batch_request_default(
entries entries: List(ChangeMessageVisibilityBatchRequestEntry),
queue_url queue_url: String,
) -> ChangeMessageVisibilityBatchRequest {
ChangeMessageVisibilityBatchRequest(entries: entries, queue_url: queue_url)
}
pub fn encode_change_message_visibility_batch_request_struct(
input: ChangeMessageVisibilityBatchRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.entries
[
#(
"Entries",
fn(xs) {
json.array(
xs,
encode_change_message_visibility_batch_request_entry_struct,
)
}(v),
),
..pairs
]
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_change_message_visibility_batch_request_struct_top(
input: ChangeMessageVisibilityBatchRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.entries
[
#(
"Entries",
fn(xs) {
json.array(
xs,
encode_change_message_visibility_batch_request_entry_struct,
)
}(v),
),
..pairs
]
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_change_message_visibility_batch_request_struct() -> decode.Decoder(
ChangeMessageVisibilityBatchRequest,
) {
use <- decode.recursive
use entries <- decode.field(
"Entries",
decode.list(decode_change_message_visibility_batch_request_entry_struct()),
)
use queue_url <- decode.field("QueueUrl", decode.string)
decode.success(ChangeMessageVisibilityBatchRequest(
entries: entries,
queue_url: queue_url,
))
}
pub type ChangeMessageVisibilityBatchRequestEntry {
ChangeMessageVisibilityBatchRequestEntry(
id: String,
receipt_handle: String,
visibility_timeout: option.Option(Int),
)
}
pub fn change_message_visibility_batch_request_entry_default(
id id: String,
receipt_handle receipt_handle: String,
) -> ChangeMessageVisibilityBatchRequestEntry {
ChangeMessageVisibilityBatchRequestEntry(
id: id,
receipt_handle: receipt_handle,
visibility_timeout: option.None,
)
}
pub fn encode_change_message_visibility_batch_request_entry_struct(
input: ChangeMessageVisibilityBatchRequestEntry,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.id
[#("Id", json.string(v)), ..pairs]
}
let pairs = {
let v = input.receipt_handle
[#("ReceiptHandle", json.string(v)), ..pairs]
}
let pairs = case input.visibility_timeout {
option.Some(v) -> [#("VisibilityTimeout", json.int(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_change_message_visibility_batch_request_entry_struct_top(
input: ChangeMessageVisibilityBatchRequestEntry,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.id
[#("Id", json.string(v)), ..pairs]
}
let pairs = {
let v = input.receipt_handle
[#("ReceiptHandle", json.string(v)), ..pairs]
}
let pairs = case input.visibility_timeout {
option.Some(v) -> [#("VisibilityTimeout", json.int(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_change_message_visibility_batch_request_entry_struct() -> decode.Decoder(
ChangeMessageVisibilityBatchRequestEntry,
) {
use <- decode.recursive
use id <- decode.field("Id", decode.string)
use receipt_handle <- decode.field("ReceiptHandle", decode.string)
use visibility_timeout <- decode.optional_field(
"VisibilityTimeout",
option.None,
decode.optional(decode.int),
)
decode.success(ChangeMessageVisibilityBatchRequestEntry(
id: id,
receipt_handle: receipt_handle,
visibility_timeout: visibility_timeout,
))
}
pub type ChangeMessageVisibilityBatchResult {
ChangeMessageVisibilityBatchResult(
failed: option.Option(List(BatchResultErrorEntry)),
successful: option.Option(List(ChangeMessageVisibilityBatchResultEntry)),
)
}
pub fn change_message_visibility_batch_result_default() -> ChangeMessageVisibilityBatchResult {
ChangeMessageVisibilityBatchResult(
failed: option.None,
successful: option.None,
)
}
pub fn encode_change_message_visibility_batch_result_struct(
input: ChangeMessageVisibilityBatchResult,
) -> json.Json {
let pairs = []
let pairs = case input.failed {
option.Some(v) -> [
#(
"Failed",
fn(xs) { json.array(xs, encode_batch_result_error_entry_struct) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.successful {
option.Some(v) -> [
#(
"Successful",
fn(xs) {
json.array(
xs,
encode_change_message_visibility_batch_result_entry_struct,
)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_change_message_visibility_batch_result_struct_top(
input: ChangeMessageVisibilityBatchResult,
) -> json.Json {
let pairs = []
let pairs = case input.failed {
option.Some(v) -> [
#(
"Failed",
fn(xs) { json.array(xs, encode_batch_result_error_entry_struct) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.successful {
option.Some(v) -> [
#(
"Successful",
fn(xs) {
json.array(
xs,
encode_change_message_visibility_batch_result_entry_struct,
)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_change_message_visibility_batch_result_struct() -> decode.Decoder(
ChangeMessageVisibilityBatchResult,
) {
use <- decode.recursive
use failed <- decode.optional_field(
"Failed",
option.None,
decode.optional(decode.list(decode_batch_result_error_entry_struct())),
)
use successful <- decode.optional_field(
"Successful",
option.None,
decode.optional(
decode.list(decode_change_message_visibility_batch_result_entry_struct()),
),
)
decode.success(ChangeMessageVisibilityBatchResult(
failed: failed,
successful: successful,
))
}
pub type BatchResultErrorEntry {
BatchResultErrorEntry(
code: option.Option(String),
id: option.Option(String),
message: option.Option(String),
sender_fault: option.Option(Bool),
)
}
pub fn batch_result_error_entry_default() -> BatchResultErrorEntry {
BatchResultErrorEntry(
code: option.None,
id: option.None,
message: option.None,
sender_fault: option.None,
)
}
pub fn encode_batch_result_error_entry_struct(
input: BatchResultErrorEntry,
) -> json.Json {
let pairs = []
let pairs = case input.code {
option.Some(v) -> [#("Code", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.id {
option.Some(v) -> [#("Id", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message {
option.Some(v) -> [#("Message", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.sender_fault {
option.Some(v) -> [#("SenderFault", json.bool(v)), ..pairs]
option.None -> [#("SenderFault", json.bool(False)), ..pairs]
}
json.object(pairs)
}
pub fn encode_batch_result_error_entry_struct_top(
input: BatchResultErrorEntry,
) -> json.Json {
let pairs = []
let pairs = case input.code {
option.Some(v) -> [#("Code", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.id {
option.Some(v) -> [#("Id", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message {
option.Some(v) -> [#("Message", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.sender_fault {
option.Some(v) -> [#("SenderFault", json.bool(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_batch_result_error_entry_struct() -> decode.Decoder(
BatchResultErrorEntry,
) {
use <- decode.recursive
use code <- decode.optional_field(
"Code",
option.None,
decode.optional(decode.string),
)
use id <- decode.optional_field(
"Id",
option.None,
decode.optional(decode.string),
)
use message <- decode.optional_field(
"Message",
option.None,
decode.optional(decode.string),
)
use sender_fault <- decode.optional_field(
"SenderFault",
option.None,
decode.optional(decode.bool),
)
decode.success(BatchResultErrorEntry(
code: code,
id: id,
message: message,
sender_fault: sender_fault,
))
}
pub type ChangeMessageVisibilityBatchResultEntry {
ChangeMessageVisibilityBatchResultEntry(id: option.Option(String))
}
pub fn change_message_visibility_batch_result_entry_default() -> ChangeMessageVisibilityBatchResultEntry {
ChangeMessageVisibilityBatchResultEntry(id: option.None)
}
pub fn encode_change_message_visibility_batch_result_entry_struct(
input: ChangeMessageVisibilityBatchResultEntry,
) -> json.Json {
let pairs = []
let pairs = case input.id {
option.Some(v) -> [#("Id", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_change_message_visibility_batch_result_entry_struct_top(
input: ChangeMessageVisibilityBatchResultEntry,
) -> json.Json {
let pairs = []
let pairs = case input.id {
option.Some(v) -> [#("Id", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_change_message_visibility_batch_result_entry_struct() -> decode.Decoder(
ChangeMessageVisibilityBatchResultEntry,
) {
use <- decode.recursive
use id <- decode.optional_field(
"Id",
option.None,
decode.optional(decode.string),
)
decode.success(ChangeMessageVisibilityBatchResultEntry(id: id))
}
pub type BatchEntryIdsNotDistinct {
BatchEntryIdsNotDistinct(message: option.Option(String))
}
pub fn batch_entry_ids_not_distinct_default() -> BatchEntryIdsNotDistinct {
BatchEntryIdsNotDistinct(message: option.None)
}
pub fn encode_batch_entry_ids_not_distinct_struct(
input: BatchEntryIdsNotDistinct,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_batch_entry_ids_not_distinct_struct_top(
input: BatchEntryIdsNotDistinct,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_batch_entry_ids_not_distinct_struct() -> decode.Decoder(
BatchEntryIdsNotDistinct,
) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(BatchEntryIdsNotDistinct(message: message))
}
pub type EmptyBatchRequest {
EmptyBatchRequest(message: option.Option(String))
}
pub fn empty_batch_request_default() -> EmptyBatchRequest {
EmptyBatchRequest(message: option.None)
}
pub fn encode_empty_batch_request_struct(
input: EmptyBatchRequest,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_empty_batch_request_struct_top(
input: EmptyBatchRequest,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_empty_batch_request_struct() -> decode.Decoder(EmptyBatchRequest) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(EmptyBatchRequest(message: message))
}
pub type InvalidBatchEntryId {
InvalidBatchEntryId(message: option.Option(String))
}
pub fn invalid_batch_entry_id_default() -> InvalidBatchEntryId {
InvalidBatchEntryId(message: option.None)
}
pub fn encode_invalid_batch_entry_id_struct(
input: InvalidBatchEntryId,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_invalid_batch_entry_id_struct_top(
input: InvalidBatchEntryId,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_invalid_batch_entry_id_struct() -> decode.Decoder(
InvalidBatchEntryId,
) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(InvalidBatchEntryId(message: message))
}
pub type TooManyEntriesInBatchRequest {
TooManyEntriesInBatchRequest(message: option.Option(String))
}
pub fn too_many_entries_in_batch_request_default() -> TooManyEntriesInBatchRequest {
TooManyEntriesInBatchRequest(message: option.None)
}
pub fn encode_too_many_entries_in_batch_request_struct(
input: TooManyEntriesInBatchRequest,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_too_many_entries_in_batch_request_struct_top(
input: TooManyEntriesInBatchRequest,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_too_many_entries_in_batch_request_struct() -> decode.Decoder(
TooManyEntriesInBatchRequest,
) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(TooManyEntriesInBatchRequest(message: message))
}
pub type CreateQueueRequest {
CreateQueueRequest(
attributes: option.Option(dict.Dict(String, String)),
queue_name: String,
tags: option.Option(dict.Dict(String, String)),
)
}
pub fn create_queue_request_default(
queue_name queue_name: String,
) -> CreateQueueRequest {
CreateQueueRequest(
attributes: option.None,
queue_name: queue_name,
tags: option.None,
)
}
pub fn encode_create_queue_request_struct(
input: CreateQueueRequest,
) -> json.Json {
let pairs = []
let pairs = case input.attributes {
option.Some(v) -> [
#(
"Attributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.queue_name
[#("QueueName", json.string(v)), ..pairs]
}
let pairs = case input.tags {
option.Some(v) -> [
#(
"tags",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_create_queue_request_struct_top(
input: CreateQueueRequest,
) -> json.Json {
let pairs = []
let pairs = case input.attributes {
option.Some(v) -> [
#(
"Attributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.queue_name
[#("QueueName", json.string(v)), ..pairs]
}
let pairs = case input.tags {
option.Some(v) -> [
#(
"tags",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_create_queue_request_struct() -> decode.Decoder(
CreateQueueRequest,
) {
use <- decode.recursive
use attributes <- decode.optional_field(
"Attributes",
option.None,
decode.optional(decode.dict(decode.string, decode.string)),
)
use queue_name <- decode.field("QueueName", decode.string)
use tags <- decode.optional_field(
"tags",
option.None,
decode.optional(decode.dict(decode.string, decode.string)),
)
decode.success(CreateQueueRequest(
attributes: attributes,
queue_name: queue_name,
tags: tags,
))
}
pub type QueueAttributeName {
QueueAttributeNameAll
QueueAttributeNameApproximatenumberofmessages
QueueAttributeNameApproximatenumberofmessagesdelayed
QueueAttributeNameApproximatenumberofmessagesnotvisible
QueueAttributeNameContentbaseddeduplication
QueueAttributeNameCreatedtimestamp
QueueAttributeNameDeduplicationscope
QueueAttributeNameDelayseconds
QueueAttributeNameFifoqueue
QueueAttributeNameFifothroughputlimit
QueueAttributeNameKmsdatakeyreuseperiodseconds
QueueAttributeNameKmsmasterkeyid
QueueAttributeNameLastmodifiedtimestamp
QueueAttributeNameMaximummessagesize
QueueAttributeNameMessageretentionperiod
QueueAttributeNamePolicy
QueueAttributeNameQueuearn
QueueAttributeNameReceivemessagewaittimeseconds
QueueAttributeNameRedriveallowpolicy
QueueAttributeNameRedrivepolicy
QueueAttributeNameSqsmanagedsseenabled
QueueAttributeNameVisibilitytimeout
}
pub fn encode_queue_attribute_name_enum(v: QueueAttributeName) -> json.Json {
case v {
QueueAttributeNameAll -> json.string("All")
QueueAttributeNameApproximatenumberofmessages ->
json.string("ApproximateNumberOfMessages")
QueueAttributeNameApproximatenumberofmessagesdelayed ->
json.string("ApproximateNumberOfMessagesDelayed")
QueueAttributeNameApproximatenumberofmessagesnotvisible ->
json.string("ApproximateNumberOfMessagesNotVisible")
QueueAttributeNameContentbaseddeduplication ->
json.string("ContentBasedDeduplication")
QueueAttributeNameCreatedtimestamp -> json.string("CreatedTimestamp")
QueueAttributeNameDeduplicationscope -> json.string("DeduplicationScope")
QueueAttributeNameDelayseconds -> json.string("DelaySeconds")
QueueAttributeNameFifoqueue -> json.string("FifoQueue")
QueueAttributeNameFifothroughputlimit -> json.string("FifoThroughputLimit")
QueueAttributeNameKmsdatakeyreuseperiodseconds ->
json.string("KmsDataKeyReusePeriodSeconds")
QueueAttributeNameKmsmasterkeyid -> json.string("KmsMasterKeyId")
QueueAttributeNameLastmodifiedtimestamp ->
json.string("LastModifiedTimestamp")
QueueAttributeNameMaximummessagesize -> json.string("MaximumMessageSize")
QueueAttributeNameMessageretentionperiod ->
json.string("MessageRetentionPeriod")
QueueAttributeNamePolicy -> json.string("Policy")
QueueAttributeNameQueuearn -> json.string("QueueArn")
QueueAttributeNameReceivemessagewaittimeseconds ->
json.string("ReceiveMessageWaitTimeSeconds")
QueueAttributeNameRedriveallowpolicy -> json.string("RedriveAllowPolicy")
QueueAttributeNameRedrivepolicy -> json.string("RedrivePolicy")
QueueAttributeNameSqsmanagedsseenabled ->
json.string("SqsManagedSseEnabled")
QueueAttributeNameVisibilitytimeout -> json.string("VisibilityTimeout")
}
}
pub fn decode_queue_attribute_name_enum() -> decode.Decoder(QueueAttributeName) {
decode.then(decode.string, fn(s) {
case s {
"All" -> decode.success(QueueAttributeNameAll)
"ApproximateNumberOfMessages" ->
decode.success(QueueAttributeNameApproximatenumberofmessages)
"ApproximateNumberOfMessagesDelayed" ->
decode.success(QueueAttributeNameApproximatenumberofmessagesdelayed)
"ApproximateNumberOfMessagesNotVisible" ->
decode.success(QueueAttributeNameApproximatenumberofmessagesnotvisible)
"ContentBasedDeduplication" ->
decode.success(QueueAttributeNameContentbaseddeduplication)
"CreatedTimestamp" -> decode.success(QueueAttributeNameCreatedtimestamp)
"DeduplicationScope" ->
decode.success(QueueAttributeNameDeduplicationscope)
"DelaySeconds" -> decode.success(QueueAttributeNameDelayseconds)
"FifoQueue" -> decode.success(QueueAttributeNameFifoqueue)
"FifoThroughputLimit" ->
decode.success(QueueAttributeNameFifothroughputlimit)
"KmsDataKeyReusePeriodSeconds" ->
decode.success(QueueAttributeNameKmsdatakeyreuseperiodseconds)
"KmsMasterKeyId" -> decode.success(QueueAttributeNameKmsmasterkeyid)
"LastModifiedTimestamp" ->
decode.success(QueueAttributeNameLastmodifiedtimestamp)
"MaximumMessageSize" ->
decode.success(QueueAttributeNameMaximummessagesize)
"MessageRetentionPeriod" ->
decode.success(QueueAttributeNameMessageretentionperiod)
"Policy" -> decode.success(QueueAttributeNamePolicy)
"QueueArn" -> decode.success(QueueAttributeNameQueuearn)
"ReceiveMessageWaitTimeSeconds" ->
decode.success(QueueAttributeNameReceivemessagewaittimeseconds)
"RedriveAllowPolicy" ->
decode.success(QueueAttributeNameRedriveallowpolicy)
"RedrivePolicy" -> decode.success(QueueAttributeNameRedrivepolicy)
"SqsManagedSseEnabled" ->
decode.success(QueueAttributeNameSqsmanagedsseenabled)
"VisibilityTimeout" -> decode.success(QueueAttributeNameVisibilitytimeout)
_ -> decode.failure(QueueAttributeNameAll, "unknown enum value")
}
})
}
pub type CreateQueueResult {
CreateQueueResult(queue_url: option.Option(String))
}
pub fn create_queue_result_default() -> CreateQueueResult {
CreateQueueResult(queue_url: option.None)
}
pub fn encode_create_queue_result_struct(
input: CreateQueueResult,
) -> json.Json {
let pairs = []
let pairs = case input.queue_url {
option.Some(v) -> [#("QueueUrl", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_create_queue_result_struct_top(
input: CreateQueueResult,
) -> json.Json {
let pairs = []
let pairs = case input.queue_url {
option.Some(v) -> [#("QueueUrl", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_create_queue_result_struct() -> decode.Decoder(CreateQueueResult) {
use <- decode.recursive
use queue_url <- decode.optional_field(
"QueueUrl",
option.None,
decode.optional(decode.string),
)
decode.success(CreateQueueResult(queue_url: queue_url))
}
pub type InvalidAttributeName {
InvalidAttributeName(message: option.Option(String))
}
pub fn invalid_attribute_name_default() -> InvalidAttributeName {
InvalidAttributeName(message: option.None)
}
pub fn encode_invalid_attribute_name_struct(
input: InvalidAttributeName,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_invalid_attribute_name_struct_top(
input: InvalidAttributeName,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_invalid_attribute_name_struct() -> decode.Decoder(
InvalidAttributeName,
) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(InvalidAttributeName(message: message))
}
pub type InvalidAttributeValue {
InvalidAttributeValue(message: option.Option(String))
}
pub fn invalid_attribute_value_default() -> InvalidAttributeValue {
InvalidAttributeValue(message: option.None)
}
pub fn encode_invalid_attribute_value_struct(
input: InvalidAttributeValue,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_invalid_attribute_value_struct_top(
input: InvalidAttributeValue,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_invalid_attribute_value_struct() -> decode.Decoder(
InvalidAttributeValue,
) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(InvalidAttributeValue(message: message))
}
pub type QueueDeletedRecently {
QueueDeletedRecently(message: option.Option(String))
}
pub fn queue_deleted_recently_default() -> QueueDeletedRecently {
QueueDeletedRecently(message: option.None)
}
pub fn encode_queue_deleted_recently_struct(
input: QueueDeletedRecently,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_queue_deleted_recently_struct_top(
input: QueueDeletedRecently,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_queue_deleted_recently_struct() -> decode.Decoder(
QueueDeletedRecently,
) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(QueueDeletedRecently(message: message))
}
pub type QueueNameExists {
QueueNameExists(message: option.Option(String))
}
pub fn queue_name_exists_default() -> QueueNameExists {
QueueNameExists(message: option.None)
}
pub fn encode_queue_name_exists_struct(input: QueueNameExists) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_queue_name_exists_struct_top(
input: QueueNameExists,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_queue_name_exists_struct() -> decode.Decoder(QueueNameExists) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(QueueNameExists(message: message))
}
pub type DeleteMessageRequest {
DeleteMessageRequest(queue_url: String, receipt_handle: String)
}
pub fn delete_message_request_default(
queue_url queue_url: String,
receipt_handle receipt_handle: String,
) -> DeleteMessageRequest {
DeleteMessageRequest(queue_url: queue_url, receipt_handle: receipt_handle)
}
pub fn encode_delete_message_request_struct(
input: DeleteMessageRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
let pairs = {
let v = input.receipt_handle
[#("ReceiptHandle", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_delete_message_request_struct_top(
input: DeleteMessageRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
let pairs = {
let v = input.receipt_handle
[#("ReceiptHandle", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_delete_message_request_struct() -> decode.Decoder(
DeleteMessageRequest,
) {
use <- decode.recursive
use queue_url <- decode.field("QueueUrl", decode.string)
use receipt_handle <- decode.field("ReceiptHandle", decode.string)
decode.success(DeleteMessageRequest(
queue_url: queue_url,
receipt_handle: receipt_handle,
))
}
pub type InvalidIdFormat {
InvalidIdFormat
}
pub fn invalid_id_format_default() -> InvalidIdFormat {
InvalidIdFormat
}
pub fn encode_invalid_id_format_struct(_v: InvalidIdFormat) -> json.Json {
json.object([])
}
pub fn encode_invalid_id_format_struct_top(_v: InvalidIdFormat) -> json.Json {
json.object([])
}
pub fn decode_invalid_id_format_struct() -> decode.Decoder(InvalidIdFormat) {
decode.success(InvalidIdFormat)
}
pub type DeleteMessageBatchRequest {
DeleteMessageBatchRequest(
entries: List(DeleteMessageBatchRequestEntry),
queue_url: String,
)
}
pub fn delete_message_batch_request_default(
entries entries: List(DeleteMessageBatchRequestEntry),
queue_url queue_url: String,
) -> DeleteMessageBatchRequest {
DeleteMessageBatchRequest(entries: entries, queue_url: queue_url)
}
pub fn encode_delete_message_batch_request_struct(
input: DeleteMessageBatchRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.entries
[
#(
"Entries",
fn(xs) {
json.array(xs, encode_delete_message_batch_request_entry_struct)
}(v),
),
..pairs
]
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_delete_message_batch_request_struct_top(
input: DeleteMessageBatchRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.entries
[
#(
"Entries",
fn(xs) {
json.array(xs, encode_delete_message_batch_request_entry_struct)
}(v),
),
..pairs
]
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_delete_message_batch_request_struct() -> decode.Decoder(
DeleteMessageBatchRequest,
) {
use <- decode.recursive
use entries <- decode.field(
"Entries",
decode.list(decode_delete_message_batch_request_entry_struct()),
)
use queue_url <- decode.field("QueueUrl", decode.string)
decode.success(DeleteMessageBatchRequest(
entries: entries,
queue_url: queue_url,
))
}
pub type DeleteMessageBatchRequestEntry {
DeleteMessageBatchRequestEntry(id: String, receipt_handle: String)
}
pub fn delete_message_batch_request_entry_default(
id id: String,
receipt_handle receipt_handle: String,
) -> DeleteMessageBatchRequestEntry {
DeleteMessageBatchRequestEntry(id: id, receipt_handle: receipt_handle)
}
pub fn encode_delete_message_batch_request_entry_struct(
input: DeleteMessageBatchRequestEntry,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.id
[#("Id", json.string(v)), ..pairs]
}
let pairs = {
let v = input.receipt_handle
[#("ReceiptHandle", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_delete_message_batch_request_entry_struct_top(
input: DeleteMessageBatchRequestEntry,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.id
[#("Id", json.string(v)), ..pairs]
}
let pairs = {
let v = input.receipt_handle
[#("ReceiptHandle", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_delete_message_batch_request_entry_struct() -> decode.Decoder(
DeleteMessageBatchRequestEntry,
) {
use <- decode.recursive
use id <- decode.field("Id", decode.string)
use receipt_handle <- decode.field("ReceiptHandle", decode.string)
decode.success(DeleteMessageBatchRequestEntry(
id: id,
receipt_handle: receipt_handle,
))
}
pub type DeleteMessageBatchResult {
DeleteMessageBatchResult(
failed: option.Option(List(BatchResultErrorEntry)),
successful: option.Option(List(DeleteMessageBatchResultEntry)),
)
}
pub fn delete_message_batch_result_default() -> DeleteMessageBatchResult {
DeleteMessageBatchResult(failed: option.None, successful: option.None)
}
pub fn encode_delete_message_batch_result_struct(
input: DeleteMessageBatchResult,
) -> json.Json {
let pairs = []
let pairs = case input.failed {
option.Some(v) -> [
#(
"Failed",
fn(xs) { json.array(xs, encode_batch_result_error_entry_struct) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.successful {
option.Some(v) -> [
#(
"Successful",
fn(xs) {
json.array(xs, encode_delete_message_batch_result_entry_struct)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_delete_message_batch_result_struct_top(
input: DeleteMessageBatchResult,
) -> json.Json {
let pairs = []
let pairs = case input.failed {
option.Some(v) -> [
#(
"Failed",
fn(xs) { json.array(xs, encode_batch_result_error_entry_struct) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.successful {
option.Some(v) -> [
#(
"Successful",
fn(xs) {
json.array(xs, encode_delete_message_batch_result_entry_struct)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_delete_message_batch_result_struct() -> decode.Decoder(
DeleteMessageBatchResult,
) {
use <- decode.recursive
use failed <- decode.optional_field(
"Failed",
option.None,
decode.optional(decode.list(decode_batch_result_error_entry_struct())),
)
use successful <- decode.optional_field(
"Successful",
option.None,
decode.optional(
decode.list(decode_delete_message_batch_result_entry_struct()),
),
)
decode.success(DeleteMessageBatchResult(
failed: failed,
successful: successful,
))
}
pub type DeleteMessageBatchResultEntry {
DeleteMessageBatchResultEntry(id: option.Option(String))
}
pub fn delete_message_batch_result_entry_default() -> DeleteMessageBatchResultEntry {
DeleteMessageBatchResultEntry(id: option.None)
}
pub fn encode_delete_message_batch_result_entry_struct(
input: DeleteMessageBatchResultEntry,
) -> json.Json {
let pairs = []
let pairs = case input.id {
option.Some(v) -> [#("Id", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_delete_message_batch_result_entry_struct_top(
input: DeleteMessageBatchResultEntry,
) -> json.Json {
let pairs = []
let pairs = case input.id {
option.Some(v) -> [#("Id", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_delete_message_batch_result_entry_struct() -> decode.Decoder(
DeleteMessageBatchResultEntry,
) {
use <- decode.recursive
use id <- decode.optional_field(
"Id",
option.None,
decode.optional(decode.string),
)
decode.success(DeleteMessageBatchResultEntry(id: id))
}
pub type DeleteQueueRequest {
DeleteQueueRequest(queue_url: String)
}
pub fn delete_queue_request_default(
queue_url queue_url: String,
) -> DeleteQueueRequest {
DeleteQueueRequest(queue_url: queue_url)
}
pub fn encode_delete_queue_request_struct(
input: DeleteQueueRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_delete_queue_request_struct_top(
input: DeleteQueueRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_delete_queue_request_struct() -> decode.Decoder(
DeleteQueueRequest,
) {
use <- decode.recursive
use queue_url <- decode.field("QueueUrl", decode.string)
decode.success(DeleteQueueRequest(queue_url: queue_url))
}
pub type GetQueueAttributesRequest {
GetQueueAttributesRequest(
attribute_names: option.Option(List(QueueAttributeName)),
queue_url: String,
)
}
pub fn get_queue_attributes_request_default(
queue_url queue_url: String,
) -> GetQueueAttributesRequest {
GetQueueAttributesRequest(attribute_names: option.None, queue_url: queue_url)
}
pub fn encode_get_queue_attributes_request_struct(
input: GetQueueAttributesRequest,
) -> json.Json {
let pairs = []
let pairs = case input.attribute_names {
option.Some(v) -> [
#(
"AttributeNames",
fn(xs) { json.array(xs, encode_queue_attribute_name_enum) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_get_queue_attributes_request_struct_top(
input: GetQueueAttributesRequest,
) -> json.Json {
let pairs = []
let pairs = case input.attribute_names {
option.Some(v) -> [
#(
"AttributeNames",
fn(xs) { json.array(xs, encode_queue_attribute_name_enum) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_get_queue_attributes_request_struct() -> decode.Decoder(
GetQueueAttributesRequest,
) {
use <- decode.recursive
use attribute_names <- decode.optional_field(
"AttributeNames",
option.None,
decode.optional(decode.list(decode_queue_attribute_name_enum())),
)
use queue_url <- decode.field("QueueUrl", decode.string)
decode.success(GetQueueAttributesRequest(
attribute_names: attribute_names,
queue_url: queue_url,
))
}
pub type GetQueueAttributesResult {
GetQueueAttributesResult(attributes: option.Option(dict.Dict(String, String)))
}
pub fn get_queue_attributes_result_default() -> GetQueueAttributesResult {
GetQueueAttributesResult(attributes: option.None)
}
pub fn encode_get_queue_attributes_result_struct(
input: GetQueueAttributesResult,
) -> json.Json {
let pairs = []
let pairs = case input.attributes {
option.Some(v) -> [
#(
"Attributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_get_queue_attributes_result_struct_top(
input: GetQueueAttributesResult,
) -> json.Json {
let pairs = []
let pairs = case input.attributes {
option.Some(v) -> [
#(
"Attributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_get_queue_attributes_result_struct() -> decode.Decoder(
GetQueueAttributesResult,
) {
use <- decode.recursive
use attributes <- decode.optional_field(
"Attributes",
option.None,
decode.optional(decode.dict(decode.string, decode.string)),
)
decode.success(GetQueueAttributesResult(attributes: attributes))
}
pub type GetQueueUrlRequest {
GetQueueUrlRequest(
queue_name: String,
queue_owner_aws_account_id: option.Option(String),
)
}
pub fn get_queue_url_request_default(
queue_name queue_name: String,
) -> GetQueueUrlRequest {
GetQueueUrlRequest(
queue_name: queue_name,
queue_owner_aws_account_id: option.None,
)
}
pub fn encode_get_queue_url_request_struct(
input: GetQueueUrlRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_name
[#("QueueName", json.string(v)), ..pairs]
}
let pairs = case input.queue_owner_aws_account_id {
option.Some(v) -> [#("QueueOwnerAWSAccountId", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_get_queue_url_request_struct_top(
input: GetQueueUrlRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_name
[#("QueueName", json.string(v)), ..pairs]
}
let pairs = case input.queue_owner_aws_account_id {
option.Some(v) -> [#("QueueOwnerAWSAccountId", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_get_queue_url_request_struct() -> decode.Decoder(
GetQueueUrlRequest,
) {
use <- decode.recursive
use queue_name <- decode.field("QueueName", decode.string)
use queue_owner_aws_account_id <- decode.optional_field(
"QueueOwnerAWSAccountId",
option.None,
decode.optional(decode.string),
)
decode.success(GetQueueUrlRequest(
queue_name: queue_name,
queue_owner_aws_account_id: queue_owner_aws_account_id,
))
}
pub type GetQueueUrlResult {
GetQueueUrlResult(queue_url: option.Option(String))
}
pub fn get_queue_url_result_default() -> GetQueueUrlResult {
GetQueueUrlResult(queue_url: option.None)
}
pub fn encode_get_queue_url_result_struct(
input: GetQueueUrlResult,
) -> json.Json {
let pairs = []
let pairs = case input.queue_url {
option.Some(v) -> [#("QueueUrl", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_get_queue_url_result_struct_top(
input: GetQueueUrlResult,
) -> json.Json {
let pairs = []
let pairs = case input.queue_url {
option.Some(v) -> [#("QueueUrl", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_get_queue_url_result_struct() -> decode.Decoder(GetQueueUrlResult) {
use <- decode.recursive
use queue_url <- decode.optional_field(
"QueueUrl",
option.None,
decode.optional(decode.string),
)
decode.success(GetQueueUrlResult(queue_url: queue_url))
}
pub type ListDeadLetterSourceQueuesRequest {
ListDeadLetterSourceQueuesRequest(
max_results: option.Option(Int),
next_token: option.Option(String),
queue_url: String,
)
}
pub fn list_dead_letter_source_queues_request_default(
queue_url queue_url: String,
) -> ListDeadLetterSourceQueuesRequest {
ListDeadLetterSourceQueuesRequest(
max_results: option.None,
next_token: option.None,
queue_url: queue_url,
)
}
pub fn encode_list_dead_letter_source_queues_request_struct(
input: ListDeadLetterSourceQueuesRequest,
) -> json.Json {
let pairs = []
let pairs = case input.max_results {
option.Some(v) -> [#("MaxResults", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.next_token {
option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_list_dead_letter_source_queues_request_struct_top(
input: ListDeadLetterSourceQueuesRequest,
) -> json.Json {
let pairs = []
let pairs = case input.max_results {
option.Some(v) -> [#("MaxResults", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.next_token {
option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_list_dead_letter_source_queues_request_struct() -> decode.Decoder(
ListDeadLetterSourceQueuesRequest,
) {
use <- decode.recursive
use max_results <- decode.optional_field(
"MaxResults",
option.None,
decode.optional(decode.int),
)
use next_token <- decode.optional_field(
"NextToken",
option.None,
decode.optional(decode.string),
)
use queue_url <- decode.field("QueueUrl", decode.string)
decode.success(ListDeadLetterSourceQueuesRequest(
max_results: max_results,
next_token: next_token,
queue_url: queue_url,
))
}
pub type ListDeadLetterSourceQueuesResult {
ListDeadLetterSourceQueuesResult(
next_token: option.Option(String),
queue_urls: option.Option(List(String)),
)
}
pub fn list_dead_letter_source_queues_result_default() -> ListDeadLetterSourceQueuesResult {
ListDeadLetterSourceQueuesResult(
next_token: option.None,
queue_urls: option.None,
)
}
pub fn encode_list_dead_letter_source_queues_result_struct(
input: ListDeadLetterSourceQueuesResult,
) -> json.Json {
let pairs = []
let pairs = case input.next_token {
option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.queue_urls {
option.Some(v) -> [
#("queueUrls", fn(xs) { json.array(xs, json.string) }(v)),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_list_dead_letter_source_queues_result_struct_top(
input: ListDeadLetterSourceQueuesResult,
) -> json.Json {
let pairs = []
let pairs = case input.next_token {
option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.queue_urls {
option.Some(v) -> [
#("queueUrls", fn(xs) { json.array(xs, json.string) }(v)),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_list_dead_letter_source_queues_result_struct() -> decode.Decoder(
ListDeadLetterSourceQueuesResult,
) {
use <- decode.recursive
use next_token <- decode.optional_field(
"NextToken",
option.None,
decode.optional(decode.string),
)
use queue_urls <- decode.optional_field(
"queueUrls",
option.None,
decode.optional(decode.list(decode.string)),
)
decode.success(ListDeadLetterSourceQueuesResult(
next_token: next_token,
queue_urls: queue_urls,
))
}
pub type ListMessageMoveTasksRequest {
ListMessageMoveTasksRequest(
max_results: option.Option(Int),
source_arn: String,
)
}
pub fn list_message_move_tasks_request_default(
source_arn source_arn: String,
) -> ListMessageMoveTasksRequest {
ListMessageMoveTasksRequest(max_results: option.None, source_arn: source_arn)
}
pub fn encode_list_message_move_tasks_request_struct(
input: ListMessageMoveTasksRequest,
) -> json.Json {
let pairs = []
let pairs = case input.max_results {
option.Some(v) -> [#("MaxResults", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = {
let v = input.source_arn
[#("SourceArn", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_list_message_move_tasks_request_struct_top(
input: ListMessageMoveTasksRequest,
) -> json.Json {
let pairs = []
let pairs = case input.max_results {
option.Some(v) -> [#("MaxResults", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = {
let v = input.source_arn
[#("SourceArn", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_list_message_move_tasks_request_struct() -> decode.Decoder(
ListMessageMoveTasksRequest,
) {
use <- decode.recursive
use max_results <- decode.optional_field(
"MaxResults",
option.None,
decode.optional(decode.int),
)
use source_arn <- decode.field("SourceArn", decode.string)
decode.success(ListMessageMoveTasksRequest(
max_results: max_results,
source_arn: source_arn,
))
}
pub type ListMessageMoveTasksResult {
ListMessageMoveTasksResult(
results: option.Option(List(ListMessageMoveTasksResultEntry)),
)
}
pub fn list_message_move_tasks_result_default() -> ListMessageMoveTasksResult {
ListMessageMoveTasksResult(results: option.None)
}
pub fn encode_list_message_move_tasks_result_struct(
input: ListMessageMoveTasksResult,
) -> json.Json {
let pairs = []
let pairs = case input.results {
option.Some(v) -> [
#(
"Results",
fn(xs) {
json.array(xs, encode_list_message_move_tasks_result_entry_struct)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_list_message_move_tasks_result_struct_top(
input: ListMessageMoveTasksResult,
) -> json.Json {
let pairs = []
let pairs = case input.results {
option.Some(v) -> [
#(
"Results",
fn(xs) {
json.array(xs, encode_list_message_move_tasks_result_entry_struct)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_list_message_move_tasks_result_struct() -> decode.Decoder(
ListMessageMoveTasksResult,
) {
use <- decode.recursive
use results <- decode.optional_field(
"Results",
option.None,
decode.optional(
decode.list(decode_list_message_move_tasks_result_entry_struct()),
),
)
decode.success(ListMessageMoveTasksResult(results: results))
}
pub type ListMessageMoveTasksResultEntry {
ListMessageMoveTasksResultEntry(
approximate_number_of_messages_moved: option.Option(Int),
approximate_number_of_messages_to_move: option.Option(Int),
destination_arn: option.Option(String),
failure_reason: option.Option(String),
max_number_of_messages_per_second: option.Option(Int),
source_arn: option.Option(String),
started_timestamp: option.Option(Int),
status: option.Option(String),
task_handle: option.Option(String),
)
}
pub fn list_message_move_tasks_result_entry_default() -> ListMessageMoveTasksResultEntry {
ListMessageMoveTasksResultEntry(
approximate_number_of_messages_moved: option.None,
approximate_number_of_messages_to_move: option.None,
destination_arn: option.None,
failure_reason: option.None,
max_number_of_messages_per_second: option.None,
source_arn: option.None,
started_timestamp: option.None,
status: option.None,
task_handle: option.None,
)
}
pub fn encode_list_message_move_tasks_result_entry_struct(
input: ListMessageMoveTasksResultEntry,
) -> json.Json {
let pairs = []
let pairs = case input.approximate_number_of_messages_moved {
option.Some(v) -> [
#("ApproximateNumberOfMessagesMoved", json.int(v)),
..pairs
]
option.None -> [#("ApproximateNumberOfMessagesMoved", json.int(0)), ..pairs]
}
let pairs = case input.approximate_number_of_messages_to_move {
option.Some(v) -> [
#("ApproximateNumberOfMessagesToMove", json.int(v)),
..pairs
]
option.None -> pairs
}
let pairs = case input.destination_arn {
option.Some(v) -> [#("DestinationArn", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.failure_reason {
option.Some(v) -> [#("FailureReason", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.max_number_of_messages_per_second {
option.Some(v) -> [#("MaxNumberOfMessagesPerSecond", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.source_arn {
option.Some(v) -> [#("SourceArn", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.started_timestamp {
option.Some(v) -> [#("StartedTimestamp", json.int(v)), ..pairs]
option.None -> [#("StartedTimestamp", json.int(0)), ..pairs]
}
let pairs = case input.status {
option.Some(v) -> [#("Status", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.task_handle {
option.Some(v) -> [#("TaskHandle", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_list_message_move_tasks_result_entry_struct_top(
input: ListMessageMoveTasksResultEntry,
) -> json.Json {
let pairs = []
let pairs = case input.approximate_number_of_messages_moved {
option.Some(v) -> [
#("ApproximateNumberOfMessagesMoved", json.int(v)),
..pairs
]
option.None -> pairs
}
let pairs = case input.approximate_number_of_messages_to_move {
option.Some(v) -> [
#("ApproximateNumberOfMessagesToMove", json.int(v)),
..pairs
]
option.None -> pairs
}
let pairs = case input.destination_arn {
option.Some(v) -> [#("DestinationArn", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.failure_reason {
option.Some(v) -> [#("FailureReason", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.max_number_of_messages_per_second {
option.Some(v) -> [#("MaxNumberOfMessagesPerSecond", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.source_arn {
option.Some(v) -> [#("SourceArn", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.started_timestamp {
option.Some(v) -> [#("StartedTimestamp", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.status {
option.Some(v) -> [#("Status", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.task_handle {
option.Some(v) -> [#("TaskHandle", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_list_message_move_tasks_result_entry_struct() -> decode.Decoder(
ListMessageMoveTasksResultEntry,
) {
use <- decode.recursive
use approximate_number_of_messages_moved <- decode.optional_field(
"ApproximateNumberOfMessagesMoved",
option.None,
decode.optional(decode.int),
)
use approximate_number_of_messages_to_move <- decode.optional_field(
"ApproximateNumberOfMessagesToMove",
option.None,
decode.optional(decode.int),
)
use destination_arn <- decode.optional_field(
"DestinationArn",
option.None,
decode.optional(decode.string),
)
use failure_reason <- decode.optional_field(
"FailureReason",
option.None,
decode.optional(decode.string),
)
use max_number_of_messages_per_second <- decode.optional_field(
"MaxNumberOfMessagesPerSecond",
option.None,
decode.optional(decode.int),
)
use source_arn <- decode.optional_field(
"SourceArn",
option.None,
decode.optional(decode.string),
)
use started_timestamp <- decode.optional_field(
"StartedTimestamp",
option.None,
decode.optional(decode.int),
)
use status <- decode.optional_field(
"Status",
option.None,
decode.optional(decode.string),
)
use task_handle <- decode.optional_field(
"TaskHandle",
option.None,
decode.optional(decode.string),
)
decode.success(ListMessageMoveTasksResultEntry(
approximate_number_of_messages_moved: approximate_number_of_messages_moved,
approximate_number_of_messages_to_move: approximate_number_of_messages_to_move,
destination_arn: destination_arn,
failure_reason: failure_reason,
max_number_of_messages_per_second: max_number_of_messages_per_second,
source_arn: source_arn,
started_timestamp: started_timestamp,
status: status,
task_handle: task_handle,
))
}
pub type ListQueuesRequest {
ListQueuesRequest(
max_results: option.Option(Int),
next_token: option.Option(String),
queue_name_prefix: option.Option(String),
)
}
pub fn list_queues_request_default() -> ListQueuesRequest {
ListQueuesRequest(
max_results: option.None,
next_token: option.None,
queue_name_prefix: option.None,
)
}
pub fn encode_list_queues_request_struct(
input: ListQueuesRequest,
) -> json.Json {
let pairs = []
let pairs = case input.max_results {
option.Some(v) -> [#("MaxResults", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.next_token {
option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.queue_name_prefix {
option.Some(v) -> [#("QueueNamePrefix", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_list_queues_request_struct_top(
input: ListQueuesRequest,
) -> json.Json {
let pairs = []
let pairs = case input.max_results {
option.Some(v) -> [#("MaxResults", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.next_token {
option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.queue_name_prefix {
option.Some(v) -> [#("QueueNamePrefix", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_list_queues_request_struct() -> decode.Decoder(ListQueuesRequest) {
use <- decode.recursive
use max_results <- decode.optional_field(
"MaxResults",
option.None,
decode.optional(decode.int),
)
use next_token <- decode.optional_field(
"NextToken",
option.None,
decode.optional(decode.string),
)
use queue_name_prefix <- decode.optional_field(
"QueueNamePrefix",
option.None,
decode.optional(decode.string),
)
decode.success(ListQueuesRequest(
max_results: max_results,
next_token: next_token,
queue_name_prefix: queue_name_prefix,
))
}
pub type ListQueuesResult {
ListQueuesResult(
next_token: option.Option(String),
queue_urls: option.Option(List(String)),
)
}
pub fn list_queues_result_default() -> ListQueuesResult {
ListQueuesResult(next_token: option.None, queue_urls: option.None)
}
pub fn encode_list_queues_result_struct(input: ListQueuesResult) -> json.Json {
let pairs = []
let pairs = case input.next_token {
option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.queue_urls {
option.Some(v) -> [
#("QueueUrls", fn(xs) { json.array(xs, json.string) }(v)),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_list_queues_result_struct_top(
input: ListQueuesResult,
) -> json.Json {
let pairs = []
let pairs = case input.next_token {
option.Some(v) -> [#("NextToken", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.queue_urls {
option.Some(v) -> [
#("QueueUrls", fn(xs) { json.array(xs, json.string) }(v)),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_list_queues_result_struct() -> decode.Decoder(ListQueuesResult) {
use <- decode.recursive
use next_token <- decode.optional_field(
"NextToken",
option.None,
decode.optional(decode.string),
)
use queue_urls <- decode.optional_field(
"QueueUrls",
option.None,
decode.optional(decode.list(decode.string)),
)
decode.success(ListQueuesResult(
next_token: next_token,
queue_urls: queue_urls,
))
}
pub type ListQueueTagsRequest {
ListQueueTagsRequest(queue_url: String)
}
pub fn list_queue_tags_request_default(
queue_url queue_url: String,
) -> ListQueueTagsRequest {
ListQueueTagsRequest(queue_url: queue_url)
}
pub fn encode_list_queue_tags_request_struct(
input: ListQueueTagsRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_list_queue_tags_request_struct_top(
input: ListQueueTagsRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_list_queue_tags_request_struct() -> decode.Decoder(
ListQueueTagsRequest,
) {
use <- decode.recursive
use queue_url <- decode.field("QueueUrl", decode.string)
decode.success(ListQueueTagsRequest(queue_url: queue_url))
}
pub type ListQueueTagsResult {
ListQueueTagsResult(tags: option.Option(dict.Dict(String, String)))
}
pub fn list_queue_tags_result_default() -> ListQueueTagsResult {
ListQueueTagsResult(tags: option.None)
}
pub fn encode_list_queue_tags_result_struct(
input: ListQueueTagsResult,
) -> json.Json {
let pairs = []
let pairs = case input.tags {
option.Some(v) -> [
#(
"Tags",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_list_queue_tags_result_struct_top(
input: ListQueueTagsResult,
) -> json.Json {
let pairs = []
let pairs = case input.tags {
option.Some(v) -> [
#(
"Tags",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_list_queue_tags_result_struct() -> decode.Decoder(
ListQueueTagsResult,
) {
use <- decode.recursive
use tags <- decode.optional_field(
"Tags",
option.None,
decode.optional(decode.dict(decode.string, decode.string)),
)
decode.success(ListQueueTagsResult(tags: tags))
}
pub type PurgeQueueRequest {
PurgeQueueRequest(queue_url: String)
}
pub fn purge_queue_request_default(
queue_url queue_url: String,
) -> PurgeQueueRequest {
PurgeQueueRequest(queue_url: queue_url)
}
pub fn encode_purge_queue_request_struct(
input: PurgeQueueRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_purge_queue_request_struct_top(
input: PurgeQueueRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_purge_queue_request_struct() -> decode.Decoder(PurgeQueueRequest) {
use <- decode.recursive
use queue_url <- decode.field("QueueUrl", decode.string)
decode.success(PurgeQueueRequest(queue_url: queue_url))
}
pub type PurgeQueueInProgress {
PurgeQueueInProgress(message: option.Option(String))
}
pub fn purge_queue_in_progress_default() -> PurgeQueueInProgress {
PurgeQueueInProgress(message: option.None)
}
pub fn encode_purge_queue_in_progress_struct(
input: PurgeQueueInProgress,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_purge_queue_in_progress_struct_top(
input: PurgeQueueInProgress,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_purge_queue_in_progress_struct() -> decode.Decoder(
PurgeQueueInProgress,
) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(PurgeQueueInProgress(message: message))
}
pub type ReceiveMessageRequest {
ReceiveMessageRequest(
attribute_names: option.Option(List(QueueAttributeName)),
max_number_of_messages: option.Option(Int),
message_attribute_names: option.Option(List(String)),
message_system_attribute_names: option.Option(
List(MessageSystemAttributeName),
),
queue_url: String,
receive_request_attempt_id: option.Option(String),
visibility_timeout: option.Option(Int),
wait_time_seconds: option.Option(Int),
)
}
pub fn receive_message_request_default(
queue_url queue_url: String,
) -> ReceiveMessageRequest {
ReceiveMessageRequest(
attribute_names: option.None,
max_number_of_messages: option.None,
message_attribute_names: option.None,
message_system_attribute_names: option.None,
queue_url: queue_url,
receive_request_attempt_id: option.None,
visibility_timeout: option.None,
wait_time_seconds: option.None,
)
}
pub fn encode_receive_message_request_struct(
input: ReceiveMessageRequest,
) -> json.Json {
let pairs = []
let pairs = case input.attribute_names {
option.Some(v) -> [
#(
"AttributeNames",
fn(xs) { json.array(xs, encode_queue_attribute_name_enum) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.max_number_of_messages {
option.Some(v) -> [#("MaxNumberOfMessages", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_attribute_names {
option.Some(v) -> [
#("MessageAttributeNames", fn(xs) { json.array(xs, json.string) }(v)),
..pairs
]
option.None -> pairs
}
let pairs = case input.message_system_attribute_names {
option.Some(v) -> [
#(
"MessageSystemAttributeNames",
fn(xs) { json.array(xs, encode_message_system_attribute_name_enum) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
let pairs = case input.receive_request_attempt_id {
option.Some(v) -> [#("ReceiveRequestAttemptId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.visibility_timeout {
option.Some(v) -> [#("VisibilityTimeout", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.wait_time_seconds {
option.Some(v) -> [#("WaitTimeSeconds", json.int(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_receive_message_request_struct_top(
input: ReceiveMessageRequest,
) -> json.Json {
let pairs = []
let pairs = case input.attribute_names {
option.Some(v) -> [
#(
"AttributeNames",
fn(xs) { json.array(xs, encode_queue_attribute_name_enum) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.max_number_of_messages {
option.Some(v) -> [#("MaxNumberOfMessages", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_attribute_names {
option.Some(v) -> [
#("MessageAttributeNames", fn(xs) { json.array(xs, json.string) }(v)),
..pairs
]
option.None -> pairs
}
let pairs = case input.message_system_attribute_names {
option.Some(v) -> [
#(
"MessageSystemAttributeNames",
fn(xs) { json.array(xs, encode_message_system_attribute_name_enum) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
let pairs = case input.receive_request_attempt_id {
option.Some(v) -> [#("ReceiveRequestAttemptId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.visibility_timeout {
option.Some(v) -> [#("VisibilityTimeout", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.wait_time_seconds {
option.Some(v) -> [#("WaitTimeSeconds", json.int(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_receive_message_request_struct() -> decode.Decoder(
ReceiveMessageRequest,
) {
use <- decode.recursive
use attribute_names <- decode.optional_field(
"AttributeNames",
option.None,
decode.optional(decode.list(decode_queue_attribute_name_enum())),
)
use max_number_of_messages <- decode.optional_field(
"MaxNumberOfMessages",
option.None,
decode.optional(decode.int),
)
use message_attribute_names <- decode.optional_field(
"MessageAttributeNames",
option.None,
decode.optional(decode.list(decode.string)),
)
use message_system_attribute_names <- decode.optional_field(
"MessageSystemAttributeNames",
option.None,
decode.optional(decode.list(decode_message_system_attribute_name_enum())),
)
use queue_url <- decode.field("QueueUrl", decode.string)
use receive_request_attempt_id <- decode.optional_field(
"ReceiveRequestAttemptId",
option.None,
decode.optional(decode.string),
)
use visibility_timeout <- decode.optional_field(
"VisibilityTimeout",
option.None,
decode.optional(decode.int),
)
use wait_time_seconds <- decode.optional_field(
"WaitTimeSeconds",
option.None,
decode.optional(decode.int),
)
decode.success(ReceiveMessageRequest(
attribute_names: attribute_names,
max_number_of_messages: max_number_of_messages,
message_attribute_names: message_attribute_names,
message_system_attribute_names: message_system_attribute_names,
queue_url: queue_url,
receive_request_attempt_id: receive_request_attempt_id,
visibility_timeout: visibility_timeout,
wait_time_seconds: wait_time_seconds,
))
}
pub type MessageSystemAttributeName {
MessageSystemAttributeNameAwstraceheader
MessageSystemAttributeNameAll
MessageSystemAttributeNameApproximatefirstreceivetimestamp
MessageSystemAttributeNameApproximatereceivecount
MessageSystemAttributeNameDeadletterqueuesourcearn
MessageSystemAttributeNameMessagededuplicationid
MessageSystemAttributeNameMessagegroupid
MessageSystemAttributeNameSenderid
MessageSystemAttributeNameSenttimestamp
MessageSystemAttributeNameSequencenumber
}
pub fn encode_message_system_attribute_name_enum(
v: MessageSystemAttributeName,
) -> json.Json {
case v {
MessageSystemAttributeNameAwstraceheader -> json.string("AWSTraceHeader")
MessageSystemAttributeNameAll -> json.string("All")
MessageSystemAttributeNameApproximatefirstreceivetimestamp ->
json.string("ApproximateFirstReceiveTimestamp")
MessageSystemAttributeNameApproximatereceivecount ->
json.string("ApproximateReceiveCount")
MessageSystemAttributeNameDeadletterqueuesourcearn ->
json.string("DeadLetterQueueSourceArn")
MessageSystemAttributeNameMessagededuplicationid ->
json.string("MessageDeduplicationId")
MessageSystemAttributeNameMessagegroupid -> json.string("MessageGroupId")
MessageSystemAttributeNameSenderid -> json.string("SenderId")
MessageSystemAttributeNameSenttimestamp -> json.string("SentTimestamp")
MessageSystemAttributeNameSequencenumber -> json.string("SequenceNumber")
}
}
pub fn decode_message_system_attribute_name_enum() -> decode.Decoder(
MessageSystemAttributeName,
) {
decode.then(decode.string, fn(s) {
case s {
"AWSTraceHeader" ->
decode.success(MessageSystemAttributeNameAwstraceheader)
"All" -> decode.success(MessageSystemAttributeNameAll)
"ApproximateFirstReceiveTimestamp" ->
decode.success(
MessageSystemAttributeNameApproximatefirstreceivetimestamp,
)
"ApproximateReceiveCount" ->
decode.success(MessageSystemAttributeNameApproximatereceivecount)
"DeadLetterQueueSourceArn" ->
decode.success(MessageSystemAttributeNameDeadletterqueuesourcearn)
"MessageDeduplicationId" ->
decode.success(MessageSystemAttributeNameMessagededuplicationid)
"MessageGroupId" ->
decode.success(MessageSystemAttributeNameMessagegroupid)
"SenderId" -> decode.success(MessageSystemAttributeNameSenderid)
"SentTimestamp" -> decode.success(MessageSystemAttributeNameSenttimestamp)
"SequenceNumber" ->
decode.success(MessageSystemAttributeNameSequencenumber)
_ ->
decode.failure(
MessageSystemAttributeNameAwstraceheader,
"unknown enum value",
)
}
})
}
pub type ReceiveMessageResult {
ReceiveMessageResult(messages: option.Option(List(Message)))
}
pub fn receive_message_result_default() -> ReceiveMessageResult {
ReceiveMessageResult(messages: option.None)
}
pub fn encode_receive_message_result_struct(
input: ReceiveMessageResult,
) -> json.Json {
let pairs = []
let pairs = case input.messages {
option.Some(v) -> [
#("Messages", fn(xs) { json.array(xs, encode_message_struct) }(v)),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_receive_message_result_struct_top(
input: ReceiveMessageResult,
) -> json.Json {
let pairs = []
let pairs = case input.messages {
option.Some(v) -> [
#("Messages", fn(xs) { json.array(xs, encode_message_struct) }(v)),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_receive_message_result_struct() -> decode.Decoder(
ReceiveMessageResult,
) {
use <- decode.recursive
use messages <- decode.optional_field(
"Messages",
option.None,
decode.optional(decode.list(decode_message_struct())),
)
decode.success(ReceiveMessageResult(messages: messages))
}
pub type Message {
Message(
attributes: option.Option(dict.Dict(String, String)),
body: option.Option(String),
md5_of_body: option.Option(String),
md5_of_message_attributes: option.Option(String),
message_attributes: option.Option(dict.Dict(String, MessageAttributeValue)),
message_id: option.Option(String),
receipt_handle: option.Option(String),
)
}
pub fn message_default() -> Message {
Message(
attributes: option.None,
body: option.None,
md5_of_body: option.None,
md5_of_message_attributes: option.None,
message_attributes: option.None,
message_id: option.None,
receipt_handle: option.None,
)
}
pub fn encode_message_struct(input: Message) -> json.Json {
let pairs = []
let pairs = case input.attributes {
option.Some(v) -> [
#(
"Attributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.body {
option.Some(v) -> [#("Body", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_body {
option.Some(v) -> [#("MD5OfBody", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_message_attributes {
option.Some(v) -> [#("MD5OfMessageAttributes", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_attributes {
option.Some(v) -> [
#(
"MessageAttributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) {
#(pair.0, encode_message_attribute_value_struct(pair.1))
}),
)
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.message_id {
option.Some(v) -> [#("MessageId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.receipt_handle {
option.Some(v) -> [#("ReceiptHandle", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_message_struct_top(input: Message) -> json.Json {
let pairs = []
let pairs = case input.attributes {
option.Some(v) -> [
#(
"Attributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.body {
option.Some(v) -> [#("Body", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_body {
option.Some(v) -> [#("MD5OfBody", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_message_attributes {
option.Some(v) -> [#("MD5OfMessageAttributes", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_attributes {
option.Some(v) -> [
#(
"MessageAttributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) {
#(pair.0, encode_message_attribute_value_struct(pair.1))
}),
)
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.message_id {
option.Some(v) -> [#("MessageId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.receipt_handle {
option.Some(v) -> [#("ReceiptHandle", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_message_struct() -> decode.Decoder(Message) {
use <- decode.recursive
use attributes <- decode.optional_field(
"Attributes",
option.None,
decode.optional(decode.dict(decode.string, decode.string)),
)
use body <- decode.optional_field(
"Body",
option.None,
decode.optional(decode.string),
)
use md5_of_body <- decode.optional_field(
"MD5OfBody",
option.None,
decode.optional(decode.string),
)
use md5_of_message_attributes <- decode.optional_field(
"MD5OfMessageAttributes",
option.None,
decode.optional(decode.string),
)
use message_attributes <- decode.optional_field(
"MessageAttributes",
option.None,
decode.optional(decode.dict(
decode.string,
decode_message_attribute_value_struct(),
)),
)
use message_id <- decode.optional_field(
"MessageId",
option.None,
decode.optional(decode.string),
)
use receipt_handle <- decode.optional_field(
"ReceiptHandle",
option.None,
decode.optional(decode.string),
)
decode.success(Message(
attributes: attributes,
body: body,
md5_of_body: md5_of_body,
md5_of_message_attributes: md5_of_message_attributes,
message_attributes: message_attributes,
message_id: message_id,
receipt_handle: receipt_handle,
))
}
pub type MessageAttributeValue {
MessageAttributeValue(
binary_list_values: option.Option(List(BitArray)),
binary_value: option.Option(BitArray),
data_type: String,
string_list_values: option.Option(List(String)),
string_value: option.Option(String),
)
}
pub fn message_attribute_value_default(
data_type data_type: String,
) -> MessageAttributeValue {
MessageAttributeValue(
binary_list_values: option.None,
binary_value: option.None,
data_type: data_type,
string_list_values: option.None,
string_value: option.None,
)
}
pub fn encode_message_attribute_value_struct(
input: MessageAttributeValue,
) -> json.Json {
let pairs = []
let pairs = case input.binary_list_values {
option.Some(v) -> [
#(
"BinaryListValues",
fn(xs) {
json.array(xs, fn(b) { json.string(bit_array.base64_encode(b, True)) })
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.binary_value {
option.Some(v) -> [
#(
"BinaryValue",
fn(b) { json.string(bit_array.base64_encode(b, True)) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.data_type
[#("DataType", json.string(v)), ..pairs]
}
let pairs = case input.string_list_values {
option.Some(v) -> [
#("StringListValues", fn(xs) { json.array(xs, json.string) }(v)),
..pairs
]
option.None -> pairs
}
let pairs = case input.string_value {
option.Some(v) -> [#("StringValue", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_message_attribute_value_struct_top(
input: MessageAttributeValue,
) -> json.Json {
let pairs = []
let pairs = case input.binary_list_values {
option.Some(v) -> [
#(
"BinaryListValues",
fn(xs) {
json.array(xs, fn(b) { json.string(bit_array.base64_encode(b, True)) })
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.binary_value {
option.Some(v) -> [
#(
"BinaryValue",
fn(b) { json.string(bit_array.base64_encode(b, True)) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.data_type
[#("DataType", json.string(v)), ..pairs]
}
let pairs = case input.string_list_values {
option.Some(v) -> [
#("StringListValues", fn(xs) { json.array(xs, json.string) }(v)),
..pairs
]
option.None -> pairs
}
let pairs = case input.string_value {
option.Some(v) -> [#("StringValue", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_message_attribute_value_struct() -> decode.Decoder(
MessageAttributeValue,
) {
use <- decode.recursive
use binary_list_values <- decode.optional_field(
"BinaryListValues",
option.None,
decode.optional(
decode.list(
decode.then(decode.string, fn(s) {
decode.success(bit_array.from_string(s))
}),
),
),
)
use binary_value <- decode.optional_field(
"BinaryValue",
option.None,
decode.optional(
decode.then(decode.string, fn(s) {
decode.success(bit_array.from_string(s))
}),
),
)
use data_type <- decode.field("DataType", decode.string)
use string_list_values <- decode.optional_field(
"StringListValues",
option.None,
decode.optional(decode.list(decode.string)),
)
use string_value <- decode.optional_field(
"StringValue",
option.None,
decode.optional(decode.string),
)
decode.success(MessageAttributeValue(
binary_list_values: binary_list_values,
binary_value: binary_value,
data_type: data_type,
string_list_values: string_list_values,
string_value: string_value,
))
}
pub type KmsAccessDenied {
KmsAccessDenied(message: option.Option(String))
}
pub fn kms_access_denied_default() -> KmsAccessDenied {
KmsAccessDenied(message: option.None)
}
pub fn encode_kms_access_denied_struct(input: KmsAccessDenied) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_kms_access_denied_struct_top(
input: KmsAccessDenied,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_kms_access_denied_struct() -> decode.Decoder(KmsAccessDenied) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(KmsAccessDenied(message: message))
}
pub type KmsDisabled {
KmsDisabled(message: option.Option(String))
}
pub fn kms_disabled_default() -> KmsDisabled {
KmsDisabled(message: option.None)
}
pub fn encode_kms_disabled_struct(input: KmsDisabled) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_kms_disabled_struct_top(input: KmsDisabled) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_kms_disabled_struct() -> decode.Decoder(KmsDisabled) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(KmsDisabled(message: message))
}
pub type KmsInvalidKeyUsage {
KmsInvalidKeyUsage(message: option.Option(String))
}
pub fn kms_invalid_key_usage_default() -> KmsInvalidKeyUsage {
KmsInvalidKeyUsage(message: option.None)
}
pub fn encode_kms_invalid_key_usage_struct(
input: KmsInvalidKeyUsage,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_kms_invalid_key_usage_struct_top(
input: KmsInvalidKeyUsage,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_kms_invalid_key_usage_struct() -> decode.Decoder(
KmsInvalidKeyUsage,
) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(KmsInvalidKeyUsage(message: message))
}
pub type KmsInvalidState {
KmsInvalidState(message: option.Option(String))
}
pub fn kms_invalid_state_default() -> KmsInvalidState {
KmsInvalidState(message: option.None)
}
pub fn encode_kms_invalid_state_struct(input: KmsInvalidState) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_kms_invalid_state_struct_top(
input: KmsInvalidState,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_kms_invalid_state_struct() -> decode.Decoder(KmsInvalidState) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(KmsInvalidState(message: message))
}
pub type KmsNotFound {
KmsNotFound(message: option.Option(String))
}
pub fn kms_not_found_default() -> KmsNotFound {
KmsNotFound(message: option.None)
}
pub fn encode_kms_not_found_struct(input: KmsNotFound) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_kms_not_found_struct_top(input: KmsNotFound) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_kms_not_found_struct() -> decode.Decoder(KmsNotFound) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(KmsNotFound(message: message))
}
pub type KmsOptInRequired {
KmsOptInRequired(message: option.Option(String))
}
pub fn kms_opt_in_required_default() -> KmsOptInRequired {
KmsOptInRequired(message: option.None)
}
pub fn encode_kms_opt_in_required_struct(input: KmsOptInRequired) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_kms_opt_in_required_struct_top(
input: KmsOptInRequired,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_kms_opt_in_required_struct() -> decode.Decoder(KmsOptInRequired) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(KmsOptInRequired(message: message))
}
pub type KmsThrottled {
KmsThrottled(message: option.Option(String))
}
pub fn kms_throttled_default() -> KmsThrottled {
KmsThrottled(message: option.None)
}
pub fn encode_kms_throttled_struct(input: KmsThrottled) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_kms_throttled_struct_top(input: KmsThrottled) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_kms_throttled_struct() -> decode.Decoder(KmsThrottled) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(KmsThrottled(message: message))
}
pub type RemovePermissionRequest {
RemovePermissionRequest(label: String, queue_url: String)
}
pub fn remove_permission_request_default(
label label: String,
queue_url queue_url: String,
) -> RemovePermissionRequest {
RemovePermissionRequest(label: label, queue_url: queue_url)
}
pub fn encode_remove_permission_request_struct(
input: RemovePermissionRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.label
[#("Label", json.string(v)), ..pairs]
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_remove_permission_request_struct_top(
input: RemovePermissionRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.label
[#("Label", json.string(v)), ..pairs]
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_remove_permission_request_struct() -> decode.Decoder(
RemovePermissionRequest,
) {
use <- decode.recursive
use label <- decode.field("Label", decode.string)
use queue_url <- decode.field("QueueUrl", decode.string)
decode.success(RemovePermissionRequest(label: label, queue_url: queue_url))
}
pub type SendMessageRequest {
SendMessageRequest(
delay_seconds: option.Option(Int),
message_attributes: option.Option(dict.Dict(String, MessageAttributeValue)),
message_body: String,
message_deduplication_id: option.Option(String),
message_group_id: option.Option(String),
message_system_attributes: option.Option(
dict.Dict(String, MessageSystemAttributeValue),
),
queue_url: String,
)
}
pub fn send_message_request_default(
message_body message_body: String,
queue_url queue_url: String,
) -> SendMessageRequest {
SendMessageRequest(
delay_seconds: option.None,
message_attributes: option.None,
message_body: message_body,
message_deduplication_id: option.None,
message_group_id: option.None,
message_system_attributes: option.None,
queue_url: queue_url,
)
}
pub fn encode_send_message_request_struct(
input: SendMessageRequest,
) -> json.Json {
let pairs = []
let pairs = case input.delay_seconds {
option.Some(v) -> [#("DelaySeconds", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_attributes {
option.Some(v) -> [
#(
"MessageAttributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) {
#(pair.0, encode_message_attribute_value_struct(pair.1))
}),
)
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.message_body
[#("MessageBody", json.string(v)), ..pairs]
}
let pairs = case input.message_deduplication_id {
option.Some(v) -> [#("MessageDeduplicationId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_group_id {
option.Some(v) -> [#("MessageGroupId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_system_attributes {
option.Some(v) -> [
#(
"MessageSystemAttributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) {
#(pair.0, encode_message_system_attribute_value_struct(pair.1))
}),
)
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_send_message_request_struct_top(
input: SendMessageRequest,
) -> json.Json {
let pairs = []
let pairs = case input.delay_seconds {
option.Some(v) -> [#("DelaySeconds", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_attributes {
option.Some(v) -> [
#(
"MessageAttributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) {
#(pair.0, encode_message_attribute_value_struct(pair.1))
}),
)
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.message_body
[#("MessageBody", json.string(v)), ..pairs]
}
let pairs = case input.message_deduplication_id {
option.Some(v) -> [#("MessageDeduplicationId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_group_id {
option.Some(v) -> [#("MessageGroupId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_system_attributes {
option.Some(v) -> [
#(
"MessageSystemAttributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) {
#(pair.0, encode_message_system_attribute_value_struct(pair.1))
}),
)
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_send_message_request_struct() -> decode.Decoder(
SendMessageRequest,
) {
use <- decode.recursive
use delay_seconds <- decode.optional_field(
"DelaySeconds",
option.None,
decode.optional(decode.int),
)
use message_attributes <- decode.optional_field(
"MessageAttributes",
option.None,
decode.optional(decode.dict(
decode.string,
decode_message_attribute_value_struct(),
)),
)
use message_body <- decode.field("MessageBody", decode.string)
use message_deduplication_id <- decode.optional_field(
"MessageDeduplicationId",
option.None,
decode.optional(decode.string),
)
use message_group_id <- decode.optional_field(
"MessageGroupId",
option.None,
decode.optional(decode.string),
)
use message_system_attributes <- decode.optional_field(
"MessageSystemAttributes",
option.None,
decode.optional(decode.dict(
decode.string,
decode_message_system_attribute_value_struct(),
)),
)
use queue_url <- decode.field("QueueUrl", decode.string)
decode.success(SendMessageRequest(
delay_seconds: delay_seconds,
message_attributes: message_attributes,
message_body: message_body,
message_deduplication_id: message_deduplication_id,
message_group_id: message_group_id,
message_system_attributes: message_system_attributes,
queue_url: queue_url,
))
}
pub type MessageSystemAttributeNameForSends {
MessageSystemAttributeNameForSendsAwstraceheader
}
pub fn encode_message_system_attribute_name_for_sends_enum(
v: MessageSystemAttributeNameForSends,
) -> json.Json {
case v {
MessageSystemAttributeNameForSendsAwstraceheader ->
json.string("AWSTraceHeader")
}
}
pub fn decode_message_system_attribute_name_for_sends_enum() -> decode.Decoder(
MessageSystemAttributeNameForSends,
) {
decode.then(decode.string, fn(s) {
case s {
"AWSTraceHeader" ->
decode.success(MessageSystemAttributeNameForSendsAwstraceheader)
_ ->
decode.failure(
MessageSystemAttributeNameForSendsAwstraceheader,
"unknown enum value",
)
}
})
}
pub type MessageSystemAttributeValue {
MessageSystemAttributeValue(
binary_list_values: option.Option(List(BitArray)),
binary_value: option.Option(BitArray),
data_type: String,
string_list_values: option.Option(List(String)),
string_value: option.Option(String),
)
}
pub fn message_system_attribute_value_default(
data_type data_type: String,
) -> MessageSystemAttributeValue {
MessageSystemAttributeValue(
binary_list_values: option.None,
binary_value: option.None,
data_type: data_type,
string_list_values: option.None,
string_value: option.None,
)
}
pub fn encode_message_system_attribute_value_struct(
input: MessageSystemAttributeValue,
) -> json.Json {
let pairs = []
let pairs = case input.binary_list_values {
option.Some(v) -> [
#(
"BinaryListValues",
fn(xs) {
json.array(xs, fn(b) { json.string(bit_array.base64_encode(b, True)) })
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.binary_value {
option.Some(v) -> [
#(
"BinaryValue",
fn(b) { json.string(bit_array.base64_encode(b, True)) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.data_type
[#("DataType", json.string(v)), ..pairs]
}
let pairs = case input.string_list_values {
option.Some(v) -> [
#("StringListValues", fn(xs) { json.array(xs, json.string) }(v)),
..pairs
]
option.None -> pairs
}
let pairs = case input.string_value {
option.Some(v) -> [#("StringValue", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_message_system_attribute_value_struct_top(
input: MessageSystemAttributeValue,
) -> json.Json {
let pairs = []
let pairs = case input.binary_list_values {
option.Some(v) -> [
#(
"BinaryListValues",
fn(xs) {
json.array(xs, fn(b) { json.string(bit_array.base64_encode(b, True)) })
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.binary_value {
option.Some(v) -> [
#(
"BinaryValue",
fn(b) { json.string(bit_array.base64_encode(b, True)) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.data_type
[#("DataType", json.string(v)), ..pairs]
}
let pairs = case input.string_list_values {
option.Some(v) -> [
#("StringListValues", fn(xs) { json.array(xs, json.string) }(v)),
..pairs
]
option.None -> pairs
}
let pairs = case input.string_value {
option.Some(v) -> [#("StringValue", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_message_system_attribute_value_struct() -> decode.Decoder(
MessageSystemAttributeValue,
) {
use <- decode.recursive
use binary_list_values <- decode.optional_field(
"BinaryListValues",
option.None,
decode.optional(
decode.list(
decode.then(decode.string, fn(s) {
decode.success(bit_array.from_string(s))
}),
),
),
)
use binary_value <- decode.optional_field(
"BinaryValue",
option.None,
decode.optional(
decode.then(decode.string, fn(s) {
decode.success(bit_array.from_string(s))
}),
),
)
use data_type <- decode.field("DataType", decode.string)
use string_list_values <- decode.optional_field(
"StringListValues",
option.None,
decode.optional(decode.list(decode.string)),
)
use string_value <- decode.optional_field(
"StringValue",
option.None,
decode.optional(decode.string),
)
decode.success(MessageSystemAttributeValue(
binary_list_values: binary_list_values,
binary_value: binary_value,
data_type: data_type,
string_list_values: string_list_values,
string_value: string_value,
))
}
pub type SendMessageResult {
SendMessageResult(
md5_of_message_attributes: option.Option(String),
md5_of_message_body: option.Option(String),
md5_of_message_system_attributes: option.Option(String),
message_id: option.Option(String),
sequence_number: option.Option(String),
)
}
pub fn send_message_result_default() -> SendMessageResult {
SendMessageResult(
md5_of_message_attributes: option.None,
md5_of_message_body: option.None,
md5_of_message_system_attributes: option.None,
message_id: option.None,
sequence_number: option.None,
)
}
pub fn encode_send_message_result_struct(
input: SendMessageResult,
) -> json.Json {
let pairs = []
let pairs = case input.md5_of_message_attributes {
option.Some(v) -> [#("MD5OfMessageAttributes", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_message_body {
option.Some(v) -> [#("MD5OfMessageBody", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_message_system_attributes {
option.Some(v) -> [
#("MD5OfMessageSystemAttributes", json.string(v)),
..pairs
]
option.None -> pairs
}
let pairs = case input.message_id {
option.Some(v) -> [#("MessageId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.sequence_number {
option.Some(v) -> [#("SequenceNumber", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_send_message_result_struct_top(
input: SendMessageResult,
) -> json.Json {
let pairs = []
let pairs = case input.md5_of_message_attributes {
option.Some(v) -> [#("MD5OfMessageAttributes", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_message_body {
option.Some(v) -> [#("MD5OfMessageBody", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_message_system_attributes {
option.Some(v) -> [
#("MD5OfMessageSystemAttributes", json.string(v)),
..pairs
]
option.None -> pairs
}
let pairs = case input.message_id {
option.Some(v) -> [#("MessageId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.sequence_number {
option.Some(v) -> [#("SequenceNumber", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_send_message_result_struct() -> decode.Decoder(SendMessageResult) {
use <- decode.recursive
use md5_of_message_attributes <- decode.optional_field(
"MD5OfMessageAttributes",
option.None,
decode.optional(decode.string),
)
use md5_of_message_body <- decode.optional_field(
"MD5OfMessageBody",
option.None,
decode.optional(decode.string),
)
use md5_of_message_system_attributes <- decode.optional_field(
"MD5OfMessageSystemAttributes",
option.None,
decode.optional(decode.string),
)
use message_id <- decode.optional_field(
"MessageId",
option.None,
decode.optional(decode.string),
)
use sequence_number <- decode.optional_field(
"SequenceNumber",
option.None,
decode.optional(decode.string),
)
decode.success(SendMessageResult(
md5_of_message_attributes: md5_of_message_attributes,
md5_of_message_body: md5_of_message_body,
md5_of_message_system_attributes: md5_of_message_system_attributes,
message_id: message_id,
sequence_number: sequence_number,
))
}
pub type InvalidMessageContents {
InvalidMessageContents(message: option.Option(String))
}
pub fn invalid_message_contents_default() -> InvalidMessageContents {
InvalidMessageContents(message: option.None)
}
pub fn encode_invalid_message_contents_struct(
input: InvalidMessageContents,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_invalid_message_contents_struct_top(
input: InvalidMessageContents,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_invalid_message_contents_struct() -> decode.Decoder(
InvalidMessageContents,
) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(InvalidMessageContents(message: message))
}
pub type SendMessageBatchRequest {
SendMessageBatchRequest(
entries: List(SendMessageBatchRequestEntry),
queue_url: String,
)
}
pub fn send_message_batch_request_default(
entries entries: List(SendMessageBatchRequestEntry),
queue_url queue_url: String,
) -> SendMessageBatchRequest {
SendMessageBatchRequest(entries: entries, queue_url: queue_url)
}
pub fn encode_send_message_batch_request_struct(
input: SendMessageBatchRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.entries
[
#(
"Entries",
fn(xs) {
json.array(xs, encode_send_message_batch_request_entry_struct)
}(v),
),
..pairs
]
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_send_message_batch_request_struct_top(
input: SendMessageBatchRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.entries
[
#(
"Entries",
fn(xs) {
json.array(xs, encode_send_message_batch_request_entry_struct)
}(v),
),
..pairs
]
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_send_message_batch_request_struct() -> decode.Decoder(
SendMessageBatchRequest,
) {
use <- decode.recursive
use entries <- decode.field(
"Entries",
decode.list(decode_send_message_batch_request_entry_struct()),
)
use queue_url <- decode.field("QueueUrl", decode.string)
decode.success(SendMessageBatchRequest(entries: entries, queue_url: queue_url))
}
pub type SendMessageBatchRequestEntry {
SendMessageBatchRequestEntry(
delay_seconds: option.Option(Int),
id: String,
message_attributes: option.Option(dict.Dict(String, MessageAttributeValue)),
message_body: String,
message_deduplication_id: option.Option(String),
message_group_id: option.Option(String),
message_system_attributes: option.Option(
dict.Dict(String, MessageSystemAttributeValue),
),
)
}
pub fn send_message_batch_request_entry_default(
id id: String,
message_body message_body: String,
) -> SendMessageBatchRequestEntry {
SendMessageBatchRequestEntry(
delay_seconds: option.None,
id: id,
message_attributes: option.None,
message_body: message_body,
message_deduplication_id: option.None,
message_group_id: option.None,
message_system_attributes: option.None,
)
}
pub fn encode_send_message_batch_request_entry_struct(
input: SendMessageBatchRequestEntry,
) -> json.Json {
let pairs = []
let pairs = case input.delay_seconds {
option.Some(v) -> [#("DelaySeconds", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = {
let v = input.id
[#("Id", json.string(v)), ..pairs]
}
let pairs = case input.message_attributes {
option.Some(v) -> [
#(
"MessageAttributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) {
#(pair.0, encode_message_attribute_value_struct(pair.1))
}),
)
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.message_body
[#("MessageBody", json.string(v)), ..pairs]
}
let pairs = case input.message_deduplication_id {
option.Some(v) -> [#("MessageDeduplicationId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_group_id {
option.Some(v) -> [#("MessageGroupId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_system_attributes {
option.Some(v) -> [
#(
"MessageSystemAttributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) {
#(pair.0, encode_message_system_attribute_value_struct(pair.1))
}),
)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_send_message_batch_request_entry_struct_top(
input: SendMessageBatchRequestEntry,
) -> json.Json {
let pairs = []
let pairs = case input.delay_seconds {
option.Some(v) -> [#("DelaySeconds", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = {
let v = input.id
[#("Id", json.string(v)), ..pairs]
}
let pairs = case input.message_attributes {
option.Some(v) -> [
#(
"MessageAttributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) {
#(pair.0, encode_message_attribute_value_struct(pair.1))
}),
)
}(v),
),
..pairs
]
option.None -> pairs
}
let pairs = {
let v = input.message_body
[#("MessageBody", json.string(v)), ..pairs]
}
let pairs = case input.message_deduplication_id {
option.Some(v) -> [#("MessageDeduplicationId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_group_id {
option.Some(v) -> [#("MessageGroupId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.message_system_attributes {
option.Some(v) -> [
#(
"MessageSystemAttributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) {
#(pair.0, encode_message_system_attribute_value_struct(pair.1))
}),
)
}(v),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_send_message_batch_request_entry_struct() -> decode.Decoder(
SendMessageBatchRequestEntry,
) {
use <- decode.recursive
use delay_seconds <- decode.optional_field(
"DelaySeconds",
option.None,
decode.optional(decode.int),
)
use id <- decode.field("Id", decode.string)
use message_attributes <- decode.optional_field(
"MessageAttributes",
option.None,
decode.optional(decode.dict(
decode.string,
decode_message_attribute_value_struct(),
)),
)
use message_body <- decode.field("MessageBody", decode.string)
use message_deduplication_id <- decode.optional_field(
"MessageDeduplicationId",
option.None,
decode.optional(decode.string),
)
use message_group_id <- decode.optional_field(
"MessageGroupId",
option.None,
decode.optional(decode.string),
)
use message_system_attributes <- decode.optional_field(
"MessageSystemAttributes",
option.None,
decode.optional(decode.dict(
decode.string,
decode_message_system_attribute_value_struct(),
)),
)
decode.success(SendMessageBatchRequestEntry(
delay_seconds: delay_seconds,
id: id,
message_attributes: message_attributes,
message_body: message_body,
message_deduplication_id: message_deduplication_id,
message_group_id: message_group_id,
message_system_attributes: message_system_attributes,
))
}
pub type SendMessageBatchResult {
SendMessageBatchResult(
failed: option.Option(List(BatchResultErrorEntry)),
successful: option.Option(List(SendMessageBatchResultEntry)),
)
}
pub fn send_message_batch_result_default() -> SendMessageBatchResult {
SendMessageBatchResult(failed: option.None, successful: option.None)
}
pub fn encode_send_message_batch_result_struct(
input: SendMessageBatchResult,
) -> json.Json {
let pairs = []
let pairs = case input.failed {
option.Some(v) -> [
#(
"Failed",
fn(xs) { json.array(xs, encode_batch_result_error_entry_struct) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.successful {
option.Some(v) -> [
#(
"Successful",
fn(xs) { json.array(xs, encode_send_message_batch_result_entry_struct) }(
v,
),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_send_message_batch_result_struct_top(
input: SendMessageBatchResult,
) -> json.Json {
let pairs = []
let pairs = case input.failed {
option.Some(v) -> [
#(
"Failed",
fn(xs) { json.array(xs, encode_batch_result_error_entry_struct) }(v),
),
..pairs
]
option.None -> pairs
}
let pairs = case input.successful {
option.Some(v) -> [
#(
"Successful",
fn(xs) { json.array(xs, encode_send_message_batch_result_entry_struct) }(
v,
),
),
..pairs
]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_send_message_batch_result_struct() -> decode.Decoder(
SendMessageBatchResult,
) {
use <- decode.recursive
use failed <- decode.optional_field(
"Failed",
option.None,
decode.optional(decode.list(decode_batch_result_error_entry_struct())),
)
use successful <- decode.optional_field(
"Successful",
option.None,
decode.optional(
decode.list(decode_send_message_batch_result_entry_struct()),
),
)
decode.success(SendMessageBatchResult(failed: failed, successful: successful))
}
pub type SendMessageBatchResultEntry {
SendMessageBatchResultEntry(
id: option.Option(String),
md5_of_message_attributes: option.Option(String),
md5_of_message_body: option.Option(String),
md5_of_message_system_attributes: option.Option(String),
message_id: option.Option(String),
sequence_number: option.Option(String),
)
}
pub fn send_message_batch_result_entry_default() -> SendMessageBatchResultEntry {
SendMessageBatchResultEntry(
id: option.None,
md5_of_message_attributes: option.None,
md5_of_message_body: option.None,
md5_of_message_system_attributes: option.None,
message_id: option.None,
sequence_number: option.None,
)
}
pub fn encode_send_message_batch_result_entry_struct(
input: SendMessageBatchResultEntry,
) -> json.Json {
let pairs = []
let pairs = case input.id {
option.Some(v) -> [#("Id", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_message_attributes {
option.Some(v) -> [#("MD5OfMessageAttributes", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_message_body {
option.Some(v) -> [#("MD5OfMessageBody", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_message_system_attributes {
option.Some(v) -> [
#("MD5OfMessageSystemAttributes", json.string(v)),
..pairs
]
option.None -> pairs
}
let pairs = case input.message_id {
option.Some(v) -> [#("MessageId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.sequence_number {
option.Some(v) -> [#("SequenceNumber", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_send_message_batch_result_entry_struct_top(
input: SendMessageBatchResultEntry,
) -> json.Json {
let pairs = []
let pairs = case input.id {
option.Some(v) -> [#("Id", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_message_attributes {
option.Some(v) -> [#("MD5OfMessageAttributes", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_message_body {
option.Some(v) -> [#("MD5OfMessageBody", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.md5_of_message_system_attributes {
option.Some(v) -> [
#("MD5OfMessageSystemAttributes", json.string(v)),
..pairs
]
option.None -> pairs
}
let pairs = case input.message_id {
option.Some(v) -> [#("MessageId", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.sequence_number {
option.Some(v) -> [#("SequenceNumber", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_send_message_batch_result_entry_struct() -> decode.Decoder(
SendMessageBatchResultEntry,
) {
use <- decode.recursive
use id <- decode.optional_field(
"Id",
option.None,
decode.optional(decode.string),
)
use md5_of_message_attributes <- decode.optional_field(
"MD5OfMessageAttributes",
option.None,
decode.optional(decode.string),
)
use md5_of_message_body <- decode.optional_field(
"MD5OfMessageBody",
option.None,
decode.optional(decode.string),
)
use md5_of_message_system_attributes <- decode.optional_field(
"MD5OfMessageSystemAttributes",
option.None,
decode.optional(decode.string),
)
use message_id <- decode.optional_field(
"MessageId",
option.None,
decode.optional(decode.string),
)
use sequence_number <- decode.optional_field(
"SequenceNumber",
option.None,
decode.optional(decode.string),
)
decode.success(SendMessageBatchResultEntry(
id: id,
md5_of_message_attributes: md5_of_message_attributes,
md5_of_message_body: md5_of_message_body,
md5_of_message_system_attributes: md5_of_message_system_attributes,
message_id: message_id,
sequence_number: sequence_number,
))
}
pub type BatchRequestTooLong {
BatchRequestTooLong(message: option.Option(String))
}
pub fn batch_request_too_long_default() -> BatchRequestTooLong {
BatchRequestTooLong(message: option.None)
}
pub fn encode_batch_request_too_long_struct(
input: BatchRequestTooLong,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_batch_request_too_long_struct_top(
input: BatchRequestTooLong,
) -> json.Json {
let pairs = []
let pairs = case input.message {
option.Some(v) -> [#("message", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_batch_request_too_long_struct() -> decode.Decoder(
BatchRequestTooLong,
) {
use <- decode.recursive
use message <- decode.optional_field(
"message",
option.None,
decode.optional(decode.string),
)
decode.success(BatchRequestTooLong(message: message))
}
pub type SetQueueAttributesRequest {
SetQueueAttributesRequest(
attributes: dict.Dict(String, String),
queue_url: String,
)
}
pub fn set_queue_attributes_request_default(
attributes attributes: dict.Dict(String, String),
queue_url queue_url: String,
) -> SetQueueAttributesRequest {
SetQueueAttributesRequest(attributes: attributes, queue_url: queue_url)
}
pub fn encode_set_queue_attributes_request_struct(
input: SetQueueAttributesRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.attributes
[
#(
"Attributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_set_queue_attributes_request_struct_top(
input: SetQueueAttributesRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.attributes
[
#(
"Attributes",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
}
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_set_queue_attributes_request_struct() -> decode.Decoder(
SetQueueAttributesRequest,
) {
use <- decode.recursive
use attributes <- decode.field(
"Attributes",
decode.dict(decode.string, decode.string),
)
use queue_url <- decode.field("QueueUrl", decode.string)
decode.success(SetQueueAttributesRequest(
attributes: attributes,
queue_url: queue_url,
))
}
pub type StartMessageMoveTaskRequest {
StartMessageMoveTaskRequest(
destination_arn: option.Option(String),
max_number_of_messages_per_second: option.Option(Int),
source_arn: String,
)
}
pub fn start_message_move_task_request_default(
source_arn source_arn: String,
) -> StartMessageMoveTaskRequest {
StartMessageMoveTaskRequest(
destination_arn: option.None,
max_number_of_messages_per_second: option.None,
source_arn: source_arn,
)
}
pub fn encode_start_message_move_task_request_struct(
input: StartMessageMoveTaskRequest,
) -> json.Json {
let pairs = []
let pairs = case input.destination_arn {
option.Some(v) -> [#("DestinationArn", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.max_number_of_messages_per_second {
option.Some(v) -> [#("MaxNumberOfMessagesPerSecond", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = {
let v = input.source_arn
[#("SourceArn", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_start_message_move_task_request_struct_top(
input: StartMessageMoveTaskRequest,
) -> json.Json {
let pairs = []
let pairs = case input.destination_arn {
option.Some(v) -> [#("DestinationArn", json.string(v)), ..pairs]
option.None -> pairs
}
let pairs = case input.max_number_of_messages_per_second {
option.Some(v) -> [#("MaxNumberOfMessagesPerSecond", json.int(v)), ..pairs]
option.None -> pairs
}
let pairs = {
let v = input.source_arn
[#("SourceArn", json.string(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_start_message_move_task_request_struct() -> decode.Decoder(
StartMessageMoveTaskRequest,
) {
use <- decode.recursive
use destination_arn <- decode.optional_field(
"DestinationArn",
option.None,
decode.optional(decode.string),
)
use max_number_of_messages_per_second <- decode.optional_field(
"MaxNumberOfMessagesPerSecond",
option.None,
decode.optional(decode.int),
)
use source_arn <- decode.field("SourceArn", decode.string)
decode.success(StartMessageMoveTaskRequest(
destination_arn: destination_arn,
max_number_of_messages_per_second: max_number_of_messages_per_second,
source_arn: source_arn,
))
}
pub type StartMessageMoveTaskResult {
StartMessageMoveTaskResult(task_handle: option.Option(String))
}
pub fn start_message_move_task_result_default() -> StartMessageMoveTaskResult {
StartMessageMoveTaskResult(task_handle: option.None)
}
pub fn encode_start_message_move_task_result_struct(
input: StartMessageMoveTaskResult,
) -> json.Json {
let pairs = []
let pairs = case input.task_handle {
option.Some(v) -> [#("TaskHandle", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn encode_start_message_move_task_result_struct_top(
input: StartMessageMoveTaskResult,
) -> json.Json {
let pairs = []
let pairs = case input.task_handle {
option.Some(v) -> [#("TaskHandle", json.string(v)), ..pairs]
option.None -> pairs
}
json.object(pairs)
}
pub fn decode_start_message_move_task_result_struct() -> decode.Decoder(
StartMessageMoveTaskResult,
) {
use <- decode.recursive
use task_handle <- decode.optional_field(
"TaskHandle",
option.None,
decode.optional(decode.string),
)
decode.success(StartMessageMoveTaskResult(task_handle: task_handle))
}
pub type TagQueueRequest {
TagQueueRequest(queue_url: String, tags: dict.Dict(String, String))
}
pub fn tag_queue_request_default(
queue_url queue_url: String,
tags tags: dict.Dict(String, String),
) -> TagQueueRequest {
TagQueueRequest(queue_url: queue_url, tags: tags)
}
pub fn encode_tag_queue_request_struct(input: TagQueueRequest) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
let pairs = {
let v = input.tags
[
#(
"Tags",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
}
json.object(pairs)
}
pub fn encode_tag_queue_request_struct_top(
input: TagQueueRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
let pairs = {
let v = input.tags
[
#(
"Tags",
fn(d) {
json.object(
dict.to_list(d)
|> list.map(fn(pair) { #(pair.0, json.string(pair.1)) }),
)
}(v),
),
..pairs
]
}
json.object(pairs)
}
pub fn decode_tag_queue_request_struct() -> decode.Decoder(TagQueueRequest) {
use <- decode.recursive
use queue_url <- decode.field("QueueUrl", decode.string)
use tags <- decode.field("Tags", decode.dict(decode.string, decode.string))
decode.success(TagQueueRequest(queue_url: queue_url, tags: tags))
}
pub type UntagQueueRequest {
UntagQueueRequest(queue_url: String, tag_keys: List(String))
}
pub fn untag_queue_request_default(
queue_url queue_url: String,
tag_keys tag_keys: List(String),
) -> UntagQueueRequest {
UntagQueueRequest(queue_url: queue_url, tag_keys: tag_keys)
}
pub fn encode_untag_queue_request_struct(
input: UntagQueueRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
let pairs = {
let v = input.tag_keys
[#("TagKeys", fn(xs) { json.array(xs, json.string) }(v)), ..pairs]
}
json.object(pairs)
}
pub fn encode_untag_queue_request_struct_top(
input: UntagQueueRequest,
) -> json.Json {
let pairs = []
let pairs = {
let v = input.queue_url
[#("QueueUrl", json.string(v)), ..pairs]
}
let pairs = {
let v = input.tag_keys
[#("TagKeys", fn(xs) { json.array(xs, json.string) }(v)), ..pairs]
}
json.object(pairs)
}
pub fn decode_untag_queue_request_struct() -> decode.Decoder(UntagQueueRequest) {
use <- decode.recursive
use queue_url <- decode.field("QueueUrl", decode.string)
use tag_keys <- decode.field("TagKeys", decode.list(decode.string))
decode.success(UntagQueueRequest(queue_url: queue_url, tag_keys: tag_keys))
}
pub type AddPermissionOutput {
AddPermissionOutput
}
pub fn add_permission_output_default() -> AddPermissionOutput {
AddPermissionOutput
}
pub fn decode_add_permission_output_struct() -> decode.Decoder(
AddPermissionOutput,
) {
decode.success(AddPermissionOutput)
}
pub fn encode_add_permission_input(input: AddPermissionRequest) -> String {
json.to_string(encode_add_permission_request_struct_top(input))
}
pub fn decode_add_permission_output(
body: String,
) -> Result(AddPermissionOutput, String) {
case json.parse(body, decode_add_permission_output_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_add_permission_request(
input: AddPermissionRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_add_permission_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.AddPermission"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_add_permission_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(AddPermissionOutput, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_add_permission_output("{}")
_ -> decode_add_permission_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type AddPermissionError {
AddPermissionErrorInvalidAddress(value: InvalidAddress)
AddPermissionErrorInvalidSecurity(value: InvalidSecurity)
AddPermissionErrorOverLimit(value: OverLimit)
AddPermissionErrorQueueDoesNotExist(value: QueueDoesNotExist)
AddPermissionErrorRequestThrottled(value: RequestThrottled)
AddPermissionErrorUnsupportedOperation(value: UnsupportedOperation)
AddPermissionErrorTransport(reason: String)
AddPermissionErrorUnknown(error_type: String, status: Int, body: String)
}
fn add_permission_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(AddPermissionErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(AddPermissionErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("OverLimit", fn(body) {
case json.parse(body, decode_over_limit_struct()) {
Ok(v) -> Ok(AddPermissionErrorOverLimit(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(AddPermissionErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(AddPermissionErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(AddPermissionErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_add_permission_error(
err: runtime.ClientError,
) -> AddPermissionError {
runtime.translate_service_error(
err,
add_permission_error_decoders(),
fn(reason) { AddPermissionErrorTransport(reason: reason) },
fn(et, s, body) {
AddPermissionErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub fn encode_cancel_message_move_task_input(
input: CancelMessageMoveTaskRequest,
) -> String {
json.to_string(encode_cancel_message_move_task_request_struct_top(input))
}
pub fn decode_cancel_message_move_task_output(
body: String,
) -> Result(CancelMessageMoveTaskResult, String) {
case json.parse(body, decode_cancel_message_move_task_result_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_cancel_message_move_task_request(
input: CancelMessageMoveTaskRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_cancel_message_move_task_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.CancelMessageMoveTask"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_cancel_message_move_task_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(CancelMessageMoveTaskResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_cancel_message_move_task_output("{}")
_ -> decode_cancel_message_move_task_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type CancelMessageMoveTaskError {
CancelMessageMoveTaskErrorInvalidAddress(value: InvalidAddress)
CancelMessageMoveTaskErrorInvalidSecurity(value: InvalidSecurity)
CancelMessageMoveTaskErrorRequestThrottled(value: RequestThrottled)
CancelMessageMoveTaskErrorResourceNotFoundException(
value: ResourceNotFoundException,
)
CancelMessageMoveTaskErrorUnsupportedOperation(value: UnsupportedOperation)
CancelMessageMoveTaskErrorTransport(reason: String)
CancelMessageMoveTaskErrorUnknown(
error_type: String,
status: Int,
body: String,
)
}
fn cancel_message_move_task_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(CancelMessageMoveTaskErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(CancelMessageMoveTaskErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(CancelMessageMoveTaskErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("ResourceNotFoundException", fn(body) {
case json.parse(body, decode_resource_not_found_exception_struct()) {
Ok(v) ->
Ok(CancelMessageMoveTaskErrorResourceNotFoundException(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(CancelMessageMoveTaskErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_cancel_message_move_task_error(
err: runtime.ClientError,
) -> CancelMessageMoveTaskError {
runtime.translate_service_error(
err,
cancel_message_move_task_error_decoders(),
fn(reason) { CancelMessageMoveTaskErrorTransport(reason: reason) },
fn(et, s, body) {
CancelMessageMoveTaskErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub type ChangeMessageVisibilityOutput {
ChangeMessageVisibilityOutput
}
pub fn change_message_visibility_output_default() -> ChangeMessageVisibilityOutput {
ChangeMessageVisibilityOutput
}
pub fn decode_change_message_visibility_output_struct() -> decode.Decoder(
ChangeMessageVisibilityOutput,
) {
decode.success(ChangeMessageVisibilityOutput)
}
pub fn encode_change_message_visibility_input(
input: ChangeMessageVisibilityRequest,
) -> String {
json.to_string(encode_change_message_visibility_request_struct_top(input))
}
pub fn decode_change_message_visibility_output(
body: String,
) -> Result(ChangeMessageVisibilityOutput, String) {
case json.parse(body, decode_change_message_visibility_output_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_change_message_visibility_request(
input: ChangeMessageVisibilityRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_change_message_visibility_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.ChangeMessageVisibility"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_change_message_visibility_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(ChangeMessageVisibilityOutput, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_change_message_visibility_output("{}")
_ -> decode_change_message_visibility_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type ChangeMessageVisibilityError {
ChangeMessageVisibilityErrorInvalidAddress(value: InvalidAddress)
ChangeMessageVisibilityErrorInvalidSecurity(value: InvalidSecurity)
ChangeMessageVisibilityErrorMessageNotInflight(value: MessageNotInflight)
ChangeMessageVisibilityErrorQueueDoesNotExist(value: QueueDoesNotExist)
ChangeMessageVisibilityErrorReceiptHandleIsInvalid(
value: ReceiptHandleIsInvalid,
)
ChangeMessageVisibilityErrorRequestThrottled(value: RequestThrottled)
ChangeMessageVisibilityErrorUnsupportedOperation(value: UnsupportedOperation)
ChangeMessageVisibilityErrorTransport(reason: String)
ChangeMessageVisibilityErrorUnknown(
error_type: String,
status: Int,
body: String,
)
}
fn change_message_visibility_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(ChangeMessageVisibilityErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(ChangeMessageVisibilityErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("MessageNotInflight", fn(body) {
case json.parse(body, decode_message_not_inflight_struct()) {
Ok(v) -> Ok(ChangeMessageVisibilityErrorMessageNotInflight(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(ChangeMessageVisibilityErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("ReceiptHandleIsInvalid", fn(body) {
case json.parse(body, decode_receipt_handle_is_invalid_struct()) {
Ok(v) ->
Ok(ChangeMessageVisibilityErrorReceiptHandleIsInvalid(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(ChangeMessageVisibilityErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(ChangeMessageVisibilityErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_change_message_visibility_error(
err: runtime.ClientError,
) -> ChangeMessageVisibilityError {
runtime.translate_service_error(
err,
change_message_visibility_error_decoders(),
fn(reason) { ChangeMessageVisibilityErrorTransport(reason: reason) },
fn(et, s, body) {
ChangeMessageVisibilityErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub fn encode_change_message_visibility_batch_input(
input: ChangeMessageVisibilityBatchRequest,
) -> String {
json.to_string(encode_change_message_visibility_batch_request_struct_top(
input,
))
}
pub fn decode_change_message_visibility_batch_output(
body: String,
) -> Result(ChangeMessageVisibilityBatchResult, String) {
case
json.parse(body, decode_change_message_visibility_batch_result_struct())
{
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_change_message_visibility_batch_request(
input: ChangeMessageVisibilityBatchRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_change_message_visibility_batch_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.ChangeMessageVisibilityBatch"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_change_message_visibility_batch_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(ChangeMessageVisibilityBatchResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_change_message_visibility_batch_output("{}")
_ -> decode_change_message_visibility_batch_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type ChangeMessageVisibilityBatchError {
ChangeMessageVisibilityBatchErrorBatchEntryIdsNotDistinct(
value: BatchEntryIdsNotDistinct,
)
ChangeMessageVisibilityBatchErrorEmptyBatchRequest(value: EmptyBatchRequest)
ChangeMessageVisibilityBatchErrorInvalidAddress(value: InvalidAddress)
ChangeMessageVisibilityBatchErrorInvalidBatchEntryId(
value: InvalidBatchEntryId,
)
ChangeMessageVisibilityBatchErrorInvalidSecurity(value: InvalidSecurity)
ChangeMessageVisibilityBatchErrorQueueDoesNotExist(value: QueueDoesNotExist)
ChangeMessageVisibilityBatchErrorRequestThrottled(value: RequestThrottled)
ChangeMessageVisibilityBatchErrorTooManyEntriesInBatchRequest(
value: TooManyEntriesInBatchRequest,
)
ChangeMessageVisibilityBatchErrorUnsupportedOperation(
value: UnsupportedOperation,
)
ChangeMessageVisibilityBatchErrorTransport(reason: String)
ChangeMessageVisibilityBatchErrorUnknown(
error_type: String,
status: Int,
body: String,
)
}
fn change_message_visibility_batch_error_decoders() {
[
#("BatchEntryIdsNotDistinct", fn(body) {
case json.parse(body, decode_batch_entry_ids_not_distinct_struct()) {
Ok(v) ->
Ok(ChangeMessageVisibilityBatchErrorBatchEntryIdsNotDistinct(value: v))
Error(_) -> Error(Nil)
}
}),
#("EmptyBatchRequest", fn(body) {
case json.parse(body, decode_empty_batch_request_struct()) {
Ok(v) ->
Ok(ChangeMessageVisibilityBatchErrorEmptyBatchRequest(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(ChangeMessageVisibilityBatchErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidBatchEntryId", fn(body) {
case json.parse(body, decode_invalid_batch_entry_id_struct()) {
Ok(v) ->
Ok(ChangeMessageVisibilityBatchErrorInvalidBatchEntryId(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(ChangeMessageVisibilityBatchErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) ->
Ok(ChangeMessageVisibilityBatchErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(ChangeMessageVisibilityBatchErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("TooManyEntriesInBatchRequest", fn(body) {
case json.parse(body, decode_too_many_entries_in_batch_request_struct()) {
Ok(v) ->
Ok(ChangeMessageVisibilityBatchErrorTooManyEntriesInBatchRequest(
value: v,
))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) ->
Ok(ChangeMessageVisibilityBatchErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_change_message_visibility_batch_error(
err: runtime.ClientError,
) -> ChangeMessageVisibilityBatchError {
runtime.translate_service_error(
err,
change_message_visibility_batch_error_decoders(),
fn(reason) { ChangeMessageVisibilityBatchErrorTransport(reason: reason) },
fn(et, s, body) {
ChangeMessageVisibilityBatchErrorUnknown(
error_type: et,
status: s,
body: body,
)
},
)
}
pub fn encode_create_queue_input(input: CreateQueueRequest) -> String {
json.to_string(encode_create_queue_request_struct_top(input))
}
pub fn decode_create_queue_output(
body: String,
) -> Result(CreateQueueResult, String) {
case json.parse(body, decode_create_queue_result_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_create_queue_request(
input: CreateQueueRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_create_queue_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.CreateQueue"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_create_queue_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(CreateQueueResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_create_queue_output("{}")
_ -> decode_create_queue_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type CreateQueueError {
CreateQueueErrorInvalidAddress(value: InvalidAddress)
CreateQueueErrorInvalidAttributeName(value: InvalidAttributeName)
CreateQueueErrorInvalidAttributeValue(value: InvalidAttributeValue)
CreateQueueErrorInvalidSecurity(value: InvalidSecurity)
CreateQueueErrorQueueDeletedRecently(value: QueueDeletedRecently)
CreateQueueErrorQueueNameExists(value: QueueNameExists)
CreateQueueErrorRequestThrottled(value: RequestThrottled)
CreateQueueErrorUnsupportedOperation(value: UnsupportedOperation)
CreateQueueErrorTransport(reason: String)
CreateQueueErrorUnknown(error_type: String, status: Int, body: String)
}
fn create_queue_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(CreateQueueErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidAttributeName", fn(body) {
case json.parse(body, decode_invalid_attribute_name_struct()) {
Ok(v) -> Ok(CreateQueueErrorInvalidAttributeName(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidAttributeValue", fn(body) {
case json.parse(body, decode_invalid_attribute_value_struct()) {
Ok(v) -> Ok(CreateQueueErrorInvalidAttributeValue(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(CreateQueueErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDeletedRecently", fn(body) {
case json.parse(body, decode_queue_deleted_recently_struct()) {
Ok(v) -> Ok(CreateQueueErrorQueueDeletedRecently(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueNameExists", fn(body) {
case json.parse(body, decode_queue_name_exists_struct()) {
Ok(v) -> Ok(CreateQueueErrorQueueNameExists(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(CreateQueueErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(CreateQueueErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_create_queue_error(err: runtime.ClientError) -> CreateQueueError {
runtime.translate_service_error(
err,
create_queue_error_decoders(),
fn(reason) { CreateQueueErrorTransport(reason: reason) },
fn(et, s, body) {
CreateQueueErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub type DeleteMessageOutput {
DeleteMessageOutput
}
pub fn delete_message_output_default() -> DeleteMessageOutput {
DeleteMessageOutput
}
pub fn decode_delete_message_output_struct() -> decode.Decoder(
DeleteMessageOutput,
) {
decode.success(DeleteMessageOutput)
}
pub fn encode_delete_message_input(input: DeleteMessageRequest) -> String {
json.to_string(encode_delete_message_request_struct_top(input))
}
pub fn decode_delete_message_output(
body: String,
) -> Result(DeleteMessageOutput, String) {
case json.parse(body, decode_delete_message_output_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_delete_message_request(
input: DeleteMessageRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_delete_message_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.DeleteMessage"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_delete_message_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(DeleteMessageOutput, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_delete_message_output("{}")
_ -> decode_delete_message_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type DeleteMessageError {
DeleteMessageErrorInvalidAddress(value: InvalidAddress)
DeleteMessageErrorInvalidIdFormat(value: InvalidIdFormat)
DeleteMessageErrorInvalidSecurity(value: InvalidSecurity)
DeleteMessageErrorQueueDoesNotExist(value: QueueDoesNotExist)
DeleteMessageErrorReceiptHandleIsInvalid(value: ReceiptHandleIsInvalid)
DeleteMessageErrorRequestThrottled(value: RequestThrottled)
DeleteMessageErrorUnsupportedOperation(value: UnsupportedOperation)
DeleteMessageErrorTransport(reason: String)
DeleteMessageErrorUnknown(error_type: String, status: Int, body: String)
}
fn delete_message_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(DeleteMessageErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidIdFormat", fn(body) {
case json.parse(body, decode_invalid_id_format_struct()) {
Ok(v) -> Ok(DeleteMessageErrorInvalidIdFormat(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(DeleteMessageErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(DeleteMessageErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("ReceiptHandleIsInvalid", fn(body) {
case json.parse(body, decode_receipt_handle_is_invalid_struct()) {
Ok(v) -> Ok(DeleteMessageErrorReceiptHandleIsInvalid(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(DeleteMessageErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(DeleteMessageErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_delete_message_error(
err: runtime.ClientError,
) -> DeleteMessageError {
runtime.translate_service_error(
err,
delete_message_error_decoders(),
fn(reason) { DeleteMessageErrorTransport(reason: reason) },
fn(et, s, body) {
DeleteMessageErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub fn encode_delete_message_batch_input(
input: DeleteMessageBatchRequest,
) -> String {
json.to_string(encode_delete_message_batch_request_struct_top(input))
}
pub fn decode_delete_message_batch_output(
body: String,
) -> Result(DeleteMessageBatchResult, String) {
case json.parse(body, decode_delete_message_batch_result_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_delete_message_batch_request(
input: DeleteMessageBatchRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_delete_message_batch_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.DeleteMessageBatch"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_delete_message_batch_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(DeleteMessageBatchResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_delete_message_batch_output("{}")
_ -> decode_delete_message_batch_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type DeleteMessageBatchError {
DeleteMessageBatchErrorBatchEntryIdsNotDistinct(
value: BatchEntryIdsNotDistinct,
)
DeleteMessageBatchErrorEmptyBatchRequest(value: EmptyBatchRequest)
DeleteMessageBatchErrorInvalidAddress(value: InvalidAddress)
DeleteMessageBatchErrorInvalidBatchEntryId(value: InvalidBatchEntryId)
DeleteMessageBatchErrorInvalidSecurity(value: InvalidSecurity)
DeleteMessageBatchErrorQueueDoesNotExist(value: QueueDoesNotExist)
DeleteMessageBatchErrorRequestThrottled(value: RequestThrottled)
DeleteMessageBatchErrorTooManyEntriesInBatchRequest(
value: TooManyEntriesInBatchRequest,
)
DeleteMessageBatchErrorUnsupportedOperation(value: UnsupportedOperation)
DeleteMessageBatchErrorTransport(reason: String)
DeleteMessageBatchErrorUnknown(error_type: String, status: Int, body: String)
}
fn delete_message_batch_error_decoders() {
[
#("BatchEntryIdsNotDistinct", fn(body) {
case json.parse(body, decode_batch_entry_ids_not_distinct_struct()) {
Ok(v) -> Ok(DeleteMessageBatchErrorBatchEntryIdsNotDistinct(value: v))
Error(_) -> Error(Nil)
}
}),
#("EmptyBatchRequest", fn(body) {
case json.parse(body, decode_empty_batch_request_struct()) {
Ok(v) -> Ok(DeleteMessageBatchErrorEmptyBatchRequest(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(DeleteMessageBatchErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidBatchEntryId", fn(body) {
case json.parse(body, decode_invalid_batch_entry_id_struct()) {
Ok(v) -> Ok(DeleteMessageBatchErrorInvalidBatchEntryId(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(DeleteMessageBatchErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(DeleteMessageBatchErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(DeleteMessageBatchErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("TooManyEntriesInBatchRequest", fn(body) {
case json.parse(body, decode_too_many_entries_in_batch_request_struct()) {
Ok(v) ->
Ok(DeleteMessageBatchErrorTooManyEntriesInBatchRequest(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(DeleteMessageBatchErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_delete_message_batch_error(
err: runtime.ClientError,
) -> DeleteMessageBatchError {
runtime.translate_service_error(
err,
delete_message_batch_error_decoders(),
fn(reason) { DeleteMessageBatchErrorTransport(reason: reason) },
fn(et, s, body) {
DeleteMessageBatchErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub type DeleteQueueOutput {
DeleteQueueOutput
}
pub fn delete_queue_output_default() -> DeleteQueueOutput {
DeleteQueueOutput
}
pub fn decode_delete_queue_output_struct() -> decode.Decoder(DeleteQueueOutput) {
decode.success(DeleteQueueOutput)
}
pub fn encode_delete_queue_input(input: DeleteQueueRequest) -> String {
json.to_string(encode_delete_queue_request_struct_top(input))
}
pub fn decode_delete_queue_output(
body: String,
) -> Result(DeleteQueueOutput, String) {
case json.parse(body, decode_delete_queue_output_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_delete_queue_request(
input: DeleteQueueRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_delete_queue_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.DeleteQueue"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_delete_queue_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(DeleteQueueOutput, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_delete_queue_output("{}")
_ -> decode_delete_queue_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type DeleteQueueError {
DeleteQueueErrorInvalidAddress(value: InvalidAddress)
DeleteQueueErrorInvalidSecurity(value: InvalidSecurity)
DeleteQueueErrorQueueDoesNotExist(value: QueueDoesNotExist)
DeleteQueueErrorRequestThrottled(value: RequestThrottled)
DeleteQueueErrorUnsupportedOperation(value: UnsupportedOperation)
DeleteQueueErrorTransport(reason: String)
DeleteQueueErrorUnknown(error_type: String, status: Int, body: String)
}
fn delete_queue_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(DeleteQueueErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(DeleteQueueErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(DeleteQueueErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(DeleteQueueErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(DeleteQueueErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_delete_queue_error(err: runtime.ClientError) -> DeleteQueueError {
runtime.translate_service_error(
err,
delete_queue_error_decoders(),
fn(reason) { DeleteQueueErrorTransport(reason: reason) },
fn(et, s, body) {
DeleteQueueErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub fn encode_get_queue_attributes_input(
input: GetQueueAttributesRequest,
) -> String {
json.to_string(encode_get_queue_attributes_request_struct_top(input))
}
pub fn decode_get_queue_attributes_output(
body: String,
) -> Result(GetQueueAttributesResult, String) {
case json.parse(body, decode_get_queue_attributes_result_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_get_queue_attributes_request(
input: GetQueueAttributesRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_get_queue_attributes_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.GetQueueAttributes"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_get_queue_attributes_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(GetQueueAttributesResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_get_queue_attributes_output("{}")
_ -> decode_get_queue_attributes_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type GetQueueAttributesError {
GetQueueAttributesErrorInvalidAddress(value: InvalidAddress)
GetQueueAttributesErrorInvalidAttributeName(value: InvalidAttributeName)
GetQueueAttributesErrorInvalidSecurity(value: InvalidSecurity)
GetQueueAttributesErrorQueueDoesNotExist(value: QueueDoesNotExist)
GetQueueAttributesErrorRequestThrottled(value: RequestThrottled)
GetQueueAttributesErrorUnsupportedOperation(value: UnsupportedOperation)
GetQueueAttributesErrorTransport(reason: String)
GetQueueAttributesErrorUnknown(error_type: String, status: Int, body: String)
}
fn get_queue_attributes_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(GetQueueAttributesErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidAttributeName", fn(body) {
case json.parse(body, decode_invalid_attribute_name_struct()) {
Ok(v) -> Ok(GetQueueAttributesErrorInvalidAttributeName(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(GetQueueAttributesErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(GetQueueAttributesErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(GetQueueAttributesErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(GetQueueAttributesErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_get_queue_attributes_error(
err: runtime.ClientError,
) -> GetQueueAttributesError {
runtime.translate_service_error(
err,
get_queue_attributes_error_decoders(),
fn(reason) { GetQueueAttributesErrorTransport(reason: reason) },
fn(et, s, body) {
GetQueueAttributesErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub fn encode_get_queue_url_input(input: GetQueueUrlRequest) -> String {
json.to_string(encode_get_queue_url_request_struct_top(input))
}
pub fn decode_get_queue_url_output(
body: String,
) -> Result(GetQueueUrlResult, String) {
case json.parse(body, decode_get_queue_url_result_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_get_queue_url_request(
input: GetQueueUrlRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_get_queue_url_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.GetQueueUrl"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_get_queue_url_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(GetQueueUrlResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_get_queue_url_output("{}")
_ -> decode_get_queue_url_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type GetQueueUrlError {
GetQueueUrlErrorInvalidAddress(value: InvalidAddress)
GetQueueUrlErrorInvalidSecurity(value: InvalidSecurity)
GetQueueUrlErrorQueueDoesNotExist(value: QueueDoesNotExist)
GetQueueUrlErrorRequestThrottled(value: RequestThrottled)
GetQueueUrlErrorUnsupportedOperation(value: UnsupportedOperation)
GetQueueUrlErrorTransport(reason: String)
GetQueueUrlErrorUnknown(error_type: String, status: Int, body: String)
}
fn get_queue_url_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(GetQueueUrlErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(GetQueueUrlErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(GetQueueUrlErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(GetQueueUrlErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(GetQueueUrlErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_get_queue_url_error(err: runtime.ClientError) -> GetQueueUrlError {
runtime.translate_service_error(
err,
get_queue_url_error_decoders(),
fn(reason) { GetQueueUrlErrorTransport(reason: reason) },
fn(et, s, body) {
GetQueueUrlErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub fn encode_list_dead_letter_source_queues_input(
input: ListDeadLetterSourceQueuesRequest,
) -> String {
json.to_string(encode_list_dead_letter_source_queues_request_struct_top(input))
}
pub fn decode_list_dead_letter_source_queues_output(
body: String,
) -> Result(ListDeadLetterSourceQueuesResult, String) {
case json.parse(body, decode_list_dead_letter_source_queues_result_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_list_dead_letter_source_queues_request(
input: ListDeadLetterSourceQueuesRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_list_dead_letter_source_queues_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.ListDeadLetterSourceQueues"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_list_dead_letter_source_queues_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(ListDeadLetterSourceQueuesResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_list_dead_letter_source_queues_output("{}")
_ -> decode_list_dead_letter_source_queues_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type ListDeadLetterSourceQueuesError {
ListDeadLetterSourceQueuesErrorInvalidAddress(value: InvalidAddress)
ListDeadLetterSourceQueuesErrorInvalidSecurity(value: InvalidSecurity)
ListDeadLetterSourceQueuesErrorQueueDoesNotExist(value: QueueDoesNotExist)
ListDeadLetterSourceQueuesErrorRequestThrottled(value: RequestThrottled)
ListDeadLetterSourceQueuesErrorUnsupportedOperation(
value: UnsupportedOperation,
)
ListDeadLetterSourceQueuesErrorTransport(reason: String)
ListDeadLetterSourceQueuesErrorUnknown(
error_type: String,
status: Int,
body: String,
)
}
fn list_dead_letter_source_queues_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(ListDeadLetterSourceQueuesErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(ListDeadLetterSourceQueuesErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(ListDeadLetterSourceQueuesErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(ListDeadLetterSourceQueuesErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) ->
Ok(ListDeadLetterSourceQueuesErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_list_dead_letter_source_queues_error(
err: runtime.ClientError,
) -> ListDeadLetterSourceQueuesError {
runtime.translate_service_error(
err,
list_dead_letter_source_queues_error_decoders(),
fn(reason) { ListDeadLetterSourceQueuesErrorTransport(reason: reason) },
fn(et, s, body) {
ListDeadLetterSourceQueuesErrorUnknown(
error_type: et,
status: s,
body: body,
)
},
)
}
pub fn encode_list_message_move_tasks_input(
input: ListMessageMoveTasksRequest,
) -> String {
json.to_string(encode_list_message_move_tasks_request_struct_top(input))
}
pub fn decode_list_message_move_tasks_output(
body: String,
) -> Result(ListMessageMoveTasksResult, String) {
case json.parse(body, decode_list_message_move_tasks_result_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_list_message_move_tasks_request(
input: ListMessageMoveTasksRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_list_message_move_tasks_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.ListMessageMoveTasks"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_list_message_move_tasks_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(ListMessageMoveTasksResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_list_message_move_tasks_output("{}")
_ -> decode_list_message_move_tasks_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type ListMessageMoveTasksError {
ListMessageMoveTasksErrorInvalidAddress(value: InvalidAddress)
ListMessageMoveTasksErrorInvalidSecurity(value: InvalidSecurity)
ListMessageMoveTasksErrorRequestThrottled(value: RequestThrottled)
ListMessageMoveTasksErrorResourceNotFoundException(
value: ResourceNotFoundException,
)
ListMessageMoveTasksErrorUnsupportedOperation(value: UnsupportedOperation)
ListMessageMoveTasksErrorTransport(reason: String)
ListMessageMoveTasksErrorUnknown(
error_type: String,
status: Int,
body: String,
)
}
fn list_message_move_tasks_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(ListMessageMoveTasksErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(ListMessageMoveTasksErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(ListMessageMoveTasksErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("ResourceNotFoundException", fn(body) {
case json.parse(body, decode_resource_not_found_exception_struct()) {
Ok(v) ->
Ok(ListMessageMoveTasksErrorResourceNotFoundException(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(ListMessageMoveTasksErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_list_message_move_tasks_error(
err: runtime.ClientError,
) -> ListMessageMoveTasksError {
runtime.translate_service_error(
err,
list_message_move_tasks_error_decoders(),
fn(reason) { ListMessageMoveTasksErrorTransport(reason: reason) },
fn(et, s, body) {
ListMessageMoveTasksErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub fn encode_list_queues_input(input: ListQueuesRequest) -> String {
json.to_string(encode_list_queues_request_struct_top(input))
}
pub fn decode_list_queues_output(
body: String,
) -> Result(ListQueuesResult, String) {
case json.parse(body, decode_list_queues_result_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_list_queues_request(
input: ListQueuesRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_list_queues_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.ListQueues"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_list_queues_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(ListQueuesResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_list_queues_output("{}")
_ -> decode_list_queues_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type ListQueuesError {
ListQueuesErrorInvalidAddress(value: InvalidAddress)
ListQueuesErrorInvalidSecurity(value: InvalidSecurity)
ListQueuesErrorRequestThrottled(value: RequestThrottled)
ListQueuesErrorUnsupportedOperation(value: UnsupportedOperation)
ListQueuesErrorTransport(reason: String)
ListQueuesErrorUnknown(error_type: String, status: Int, body: String)
}
fn list_queues_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(ListQueuesErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(ListQueuesErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(ListQueuesErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(ListQueuesErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_list_queues_error(err: runtime.ClientError) -> ListQueuesError {
runtime.translate_service_error(
err,
list_queues_error_decoders(),
fn(reason) { ListQueuesErrorTransport(reason: reason) },
fn(et, s, body) {
ListQueuesErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub fn encode_list_queue_tags_input(input: ListQueueTagsRequest) -> String {
json.to_string(encode_list_queue_tags_request_struct_top(input))
}
pub fn decode_list_queue_tags_output(
body: String,
) -> Result(ListQueueTagsResult, String) {
case json.parse(body, decode_list_queue_tags_result_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_list_queue_tags_request(
input: ListQueueTagsRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_list_queue_tags_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.ListQueueTags"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_list_queue_tags_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(ListQueueTagsResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_list_queue_tags_output("{}")
_ -> decode_list_queue_tags_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type ListQueueTagsError {
ListQueueTagsErrorInvalidAddress(value: InvalidAddress)
ListQueueTagsErrorInvalidSecurity(value: InvalidSecurity)
ListQueueTagsErrorQueueDoesNotExist(value: QueueDoesNotExist)
ListQueueTagsErrorRequestThrottled(value: RequestThrottled)
ListQueueTagsErrorUnsupportedOperation(value: UnsupportedOperation)
ListQueueTagsErrorTransport(reason: String)
ListQueueTagsErrorUnknown(error_type: String, status: Int, body: String)
}
fn list_queue_tags_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(ListQueueTagsErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(ListQueueTagsErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(ListQueueTagsErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(ListQueueTagsErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(ListQueueTagsErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_list_queue_tags_error(
err: runtime.ClientError,
) -> ListQueueTagsError {
runtime.translate_service_error(
err,
list_queue_tags_error_decoders(),
fn(reason) { ListQueueTagsErrorTransport(reason: reason) },
fn(et, s, body) {
ListQueueTagsErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub type PurgeQueueOutput {
PurgeQueueOutput
}
pub fn purge_queue_output_default() -> PurgeQueueOutput {
PurgeQueueOutput
}
pub fn decode_purge_queue_output_struct() -> decode.Decoder(PurgeQueueOutput) {
decode.success(PurgeQueueOutput)
}
pub fn encode_purge_queue_input(input: PurgeQueueRequest) -> String {
json.to_string(encode_purge_queue_request_struct_top(input))
}
pub fn decode_purge_queue_output(
body: String,
) -> Result(PurgeQueueOutput, String) {
case json.parse(body, decode_purge_queue_output_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_purge_queue_request(
input: PurgeQueueRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_purge_queue_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.PurgeQueue"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_purge_queue_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(PurgeQueueOutput, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_purge_queue_output("{}")
_ -> decode_purge_queue_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type PurgeQueueError {
PurgeQueueErrorInvalidAddress(value: InvalidAddress)
PurgeQueueErrorInvalidSecurity(value: InvalidSecurity)
PurgeQueueErrorPurgeQueueInProgress(value: PurgeQueueInProgress)
PurgeQueueErrorQueueDoesNotExist(value: QueueDoesNotExist)
PurgeQueueErrorRequestThrottled(value: RequestThrottled)
PurgeQueueErrorUnsupportedOperation(value: UnsupportedOperation)
PurgeQueueErrorTransport(reason: String)
PurgeQueueErrorUnknown(error_type: String, status: Int, body: String)
}
fn purge_queue_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(PurgeQueueErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(PurgeQueueErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("PurgeQueueInProgress", fn(body) {
case json.parse(body, decode_purge_queue_in_progress_struct()) {
Ok(v) -> Ok(PurgeQueueErrorPurgeQueueInProgress(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(PurgeQueueErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(PurgeQueueErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(PurgeQueueErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_purge_queue_error(err: runtime.ClientError) -> PurgeQueueError {
runtime.translate_service_error(
err,
purge_queue_error_decoders(),
fn(reason) { PurgeQueueErrorTransport(reason: reason) },
fn(et, s, body) {
PurgeQueueErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub fn encode_receive_message_input(input: ReceiveMessageRequest) -> String {
json.to_string(encode_receive_message_request_struct_top(input))
}
pub fn decode_receive_message_output(
body: String,
) -> Result(ReceiveMessageResult, String) {
case json.parse(body, decode_receive_message_result_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_receive_message_request(
input: ReceiveMessageRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_receive_message_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.ReceiveMessage"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_receive_message_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(ReceiveMessageResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_receive_message_output("{}")
_ -> decode_receive_message_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type ReceiveMessageError {
ReceiveMessageErrorInvalidAddress(value: InvalidAddress)
ReceiveMessageErrorInvalidSecurity(value: InvalidSecurity)
ReceiveMessageErrorKmsAccessDenied(value: KmsAccessDenied)
ReceiveMessageErrorKmsDisabled(value: KmsDisabled)
ReceiveMessageErrorKmsInvalidKeyUsage(value: KmsInvalidKeyUsage)
ReceiveMessageErrorKmsInvalidState(value: KmsInvalidState)
ReceiveMessageErrorKmsNotFound(value: KmsNotFound)
ReceiveMessageErrorKmsOptInRequired(value: KmsOptInRequired)
ReceiveMessageErrorKmsThrottled(value: KmsThrottled)
ReceiveMessageErrorOverLimit(value: OverLimit)
ReceiveMessageErrorQueueDoesNotExist(value: QueueDoesNotExist)
ReceiveMessageErrorRequestThrottled(value: RequestThrottled)
ReceiveMessageErrorUnsupportedOperation(value: UnsupportedOperation)
ReceiveMessageErrorTransport(reason: String)
ReceiveMessageErrorUnknown(error_type: String, status: Int, body: String)
}
fn receive_message_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(ReceiveMessageErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(ReceiveMessageErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsAccessDenied", fn(body) {
case json.parse(body, decode_kms_access_denied_struct()) {
Ok(v) -> Ok(ReceiveMessageErrorKmsAccessDenied(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsDisabled", fn(body) {
case json.parse(body, decode_kms_disabled_struct()) {
Ok(v) -> Ok(ReceiveMessageErrorKmsDisabled(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsInvalidKeyUsage", fn(body) {
case json.parse(body, decode_kms_invalid_key_usage_struct()) {
Ok(v) -> Ok(ReceiveMessageErrorKmsInvalidKeyUsage(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsInvalidState", fn(body) {
case json.parse(body, decode_kms_invalid_state_struct()) {
Ok(v) -> Ok(ReceiveMessageErrorKmsInvalidState(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsNotFound", fn(body) {
case json.parse(body, decode_kms_not_found_struct()) {
Ok(v) -> Ok(ReceiveMessageErrorKmsNotFound(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsOptInRequired", fn(body) {
case json.parse(body, decode_kms_opt_in_required_struct()) {
Ok(v) -> Ok(ReceiveMessageErrorKmsOptInRequired(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsThrottled", fn(body) {
case json.parse(body, decode_kms_throttled_struct()) {
Ok(v) -> Ok(ReceiveMessageErrorKmsThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("OverLimit", fn(body) {
case json.parse(body, decode_over_limit_struct()) {
Ok(v) -> Ok(ReceiveMessageErrorOverLimit(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(ReceiveMessageErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(ReceiveMessageErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(ReceiveMessageErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_receive_message_error(
err: runtime.ClientError,
) -> ReceiveMessageError {
runtime.translate_service_error(
err,
receive_message_error_decoders(),
fn(reason) { ReceiveMessageErrorTransport(reason: reason) },
fn(et, s, body) {
ReceiveMessageErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub type RemovePermissionOutput {
RemovePermissionOutput
}
pub fn remove_permission_output_default() -> RemovePermissionOutput {
RemovePermissionOutput
}
pub fn decode_remove_permission_output_struct() -> decode.Decoder(
RemovePermissionOutput,
) {
decode.success(RemovePermissionOutput)
}
pub fn encode_remove_permission_input(
input: RemovePermissionRequest,
) -> String {
json.to_string(encode_remove_permission_request_struct_top(input))
}
pub fn decode_remove_permission_output(
body: String,
) -> Result(RemovePermissionOutput, String) {
case json.parse(body, decode_remove_permission_output_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_remove_permission_request(
input: RemovePermissionRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_remove_permission_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.RemovePermission"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_remove_permission_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(RemovePermissionOutput, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_remove_permission_output("{}")
_ -> decode_remove_permission_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type RemovePermissionError {
RemovePermissionErrorInvalidAddress(value: InvalidAddress)
RemovePermissionErrorInvalidSecurity(value: InvalidSecurity)
RemovePermissionErrorQueueDoesNotExist(value: QueueDoesNotExist)
RemovePermissionErrorRequestThrottled(value: RequestThrottled)
RemovePermissionErrorUnsupportedOperation(value: UnsupportedOperation)
RemovePermissionErrorTransport(reason: String)
RemovePermissionErrorUnknown(error_type: String, status: Int, body: String)
}
fn remove_permission_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(RemovePermissionErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(RemovePermissionErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(RemovePermissionErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(RemovePermissionErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(RemovePermissionErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_remove_permission_error(
err: runtime.ClientError,
) -> RemovePermissionError {
runtime.translate_service_error(
err,
remove_permission_error_decoders(),
fn(reason) { RemovePermissionErrorTransport(reason: reason) },
fn(et, s, body) {
RemovePermissionErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub fn encode_send_message_input(input: SendMessageRequest) -> String {
json.to_string(encode_send_message_request_struct_top(input))
}
pub fn decode_send_message_output(
body: String,
) -> Result(SendMessageResult, String) {
case json.parse(body, decode_send_message_result_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_send_message_request(
input: SendMessageRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_send_message_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.SendMessage"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_send_message_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(SendMessageResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_send_message_output("{}")
_ -> decode_send_message_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type SendMessageError {
SendMessageErrorInvalidAddress(value: InvalidAddress)
SendMessageErrorInvalidMessageContents(value: InvalidMessageContents)
SendMessageErrorInvalidSecurity(value: InvalidSecurity)
SendMessageErrorKmsAccessDenied(value: KmsAccessDenied)
SendMessageErrorKmsDisabled(value: KmsDisabled)
SendMessageErrorKmsInvalidKeyUsage(value: KmsInvalidKeyUsage)
SendMessageErrorKmsInvalidState(value: KmsInvalidState)
SendMessageErrorKmsNotFound(value: KmsNotFound)
SendMessageErrorKmsOptInRequired(value: KmsOptInRequired)
SendMessageErrorKmsThrottled(value: KmsThrottled)
SendMessageErrorQueueDoesNotExist(value: QueueDoesNotExist)
SendMessageErrorRequestThrottled(value: RequestThrottled)
SendMessageErrorUnsupportedOperation(value: UnsupportedOperation)
SendMessageErrorTransport(reason: String)
SendMessageErrorUnknown(error_type: String, status: Int, body: String)
}
fn send_message_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(SendMessageErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidMessageContents", fn(body) {
case json.parse(body, decode_invalid_message_contents_struct()) {
Ok(v) -> Ok(SendMessageErrorInvalidMessageContents(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(SendMessageErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsAccessDenied", fn(body) {
case json.parse(body, decode_kms_access_denied_struct()) {
Ok(v) -> Ok(SendMessageErrorKmsAccessDenied(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsDisabled", fn(body) {
case json.parse(body, decode_kms_disabled_struct()) {
Ok(v) -> Ok(SendMessageErrorKmsDisabled(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsInvalidKeyUsage", fn(body) {
case json.parse(body, decode_kms_invalid_key_usage_struct()) {
Ok(v) -> Ok(SendMessageErrorKmsInvalidKeyUsage(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsInvalidState", fn(body) {
case json.parse(body, decode_kms_invalid_state_struct()) {
Ok(v) -> Ok(SendMessageErrorKmsInvalidState(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsNotFound", fn(body) {
case json.parse(body, decode_kms_not_found_struct()) {
Ok(v) -> Ok(SendMessageErrorKmsNotFound(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsOptInRequired", fn(body) {
case json.parse(body, decode_kms_opt_in_required_struct()) {
Ok(v) -> Ok(SendMessageErrorKmsOptInRequired(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsThrottled", fn(body) {
case json.parse(body, decode_kms_throttled_struct()) {
Ok(v) -> Ok(SendMessageErrorKmsThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(SendMessageErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(SendMessageErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(SendMessageErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_send_message_error(err: runtime.ClientError) -> SendMessageError {
runtime.translate_service_error(
err,
send_message_error_decoders(),
fn(reason) { SendMessageErrorTransport(reason: reason) },
fn(et, s, body) {
SendMessageErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub fn encode_send_message_batch_input(
input: SendMessageBatchRequest,
) -> String {
json.to_string(encode_send_message_batch_request_struct_top(input))
}
pub fn decode_send_message_batch_output(
body: String,
) -> Result(SendMessageBatchResult, String) {
case json.parse(body, decode_send_message_batch_result_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_send_message_batch_request(
input: SendMessageBatchRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_send_message_batch_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.SendMessageBatch"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_send_message_batch_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(SendMessageBatchResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_send_message_batch_output("{}")
_ -> decode_send_message_batch_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type SendMessageBatchError {
SendMessageBatchErrorBatchEntryIdsNotDistinct(value: BatchEntryIdsNotDistinct)
SendMessageBatchErrorBatchRequestTooLong(value: BatchRequestTooLong)
SendMessageBatchErrorEmptyBatchRequest(value: EmptyBatchRequest)
SendMessageBatchErrorInvalidAddress(value: InvalidAddress)
SendMessageBatchErrorInvalidBatchEntryId(value: InvalidBatchEntryId)
SendMessageBatchErrorInvalidSecurity(value: InvalidSecurity)
SendMessageBatchErrorKmsAccessDenied(value: KmsAccessDenied)
SendMessageBatchErrorKmsDisabled(value: KmsDisabled)
SendMessageBatchErrorKmsInvalidKeyUsage(value: KmsInvalidKeyUsage)
SendMessageBatchErrorKmsInvalidState(value: KmsInvalidState)
SendMessageBatchErrorKmsNotFound(value: KmsNotFound)
SendMessageBatchErrorKmsOptInRequired(value: KmsOptInRequired)
SendMessageBatchErrorKmsThrottled(value: KmsThrottled)
SendMessageBatchErrorQueueDoesNotExist(value: QueueDoesNotExist)
SendMessageBatchErrorRequestThrottled(value: RequestThrottled)
SendMessageBatchErrorTooManyEntriesInBatchRequest(
value: TooManyEntriesInBatchRequest,
)
SendMessageBatchErrorUnsupportedOperation(value: UnsupportedOperation)
SendMessageBatchErrorTransport(reason: String)
SendMessageBatchErrorUnknown(error_type: String, status: Int, body: String)
}
fn send_message_batch_error_decoders() {
[
#("BatchEntryIdsNotDistinct", fn(body) {
case json.parse(body, decode_batch_entry_ids_not_distinct_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorBatchEntryIdsNotDistinct(value: v))
Error(_) -> Error(Nil)
}
}),
#("BatchRequestTooLong", fn(body) {
case json.parse(body, decode_batch_request_too_long_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorBatchRequestTooLong(value: v))
Error(_) -> Error(Nil)
}
}),
#("EmptyBatchRequest", fn(body) {
case json.parse(body, decode_empty_batch_request_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorEmptyBatchRequest(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidBatchEntryId", fn(body) {
case json.parse(body, decode_invalid_batch_entry_id_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorInvalidBatchEntryId(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsAccessDenied", fn(body) {
case json.parse(body, decode_kms_access_denied_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorKmsAccessDenied(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsDisabled", fn(body) {
case json.parse(body, decode_kms_disabled_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorKmsDisabled(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsInvalidKeyUsage", fn(body) {
case json.parse(body, decode_kms_invalid_key_usage_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorKmsInvalidKeyUsage(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsInvalidState", fn(body) {
case json.parse(body, decode_kms_invalid_state_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorKmsInvalidState(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsNotFound", fn(body) {
case json.parse(body, decode_kms_not_found_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorKmsNotFound(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsOptInRequired", fn(body) {
case json.parse(body, decode_kms_opt_in_required_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorKmsOptInRequired(value: v))
Error(_) -> Error(Nil)
}
}),
#("KmsThrottled", fn(body) {
case json.parse(body, decode_kms_throttled_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorKmsThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("TooManyEntriesInBatchRequest", fn(body) {
case json.parse(body, decode_too_many_entries_in_batch_request_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorTooManyEntriesInBatchRequest(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(SendMessageBatchErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_send_message_batch_error(
err: runtime.ClientError,
) -> SendMessageBatchError {
runtime.translate_service_error(
err,
send_message_batch_error_decoders(),
fn(reason) { SendMessageBatchErrorTransport(reason: reason) },
fn(et, s, body) {
SendMessageBatchErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub type SetQueueAttributesOutput {
SetQueueAttributesOutput
}
pub fn set_queue_attributes_output_default() -> SetQueueAttributesOutput {
SetQueueAttributesOutput
}
pub fn decode_set_queue_attributes_output_struct() -> decode.Decoder(
SetQueueAttributesOutput,
) {
decode.success(SetQueueAttributesOutput)
}
pub fn encode_set_queue_attributes_input(
input: SetQueueAttributesRequest,
) -> String {
json.to_string(encode_set_queue_attributes_request_struct_top(input))
}
pub fn decode_set_queue_attributes_output(
body: String,
) -> Result(SetQueueAttributesOutput, String) {
case json.parse(body, decode_set_queue_attributes_output_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_set_queue_attributes_request(
input: SetQueueAttributesRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_set_queue_attributes_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.SetQueueAttributes"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_set_queue_attributes_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(SetQueueAttributesOutput, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_set_queue_attributes_output("{}")
_ -> decode_set_queue_attributes_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type SetQueueAttributesError {
SetQueueAttributesErrorInvalidAddress(value: InvalidAddress)
SetQueueAttributesErrorInvalidAttributeName(value: InvalidAttributeName)
SetQueueAttributesErrorInvalidAttributeValue(value: InvalidAttributeValue)
SetQueueAttributesErrorInvalidSecurity(value: InvalidSecurity)
SetQueueAttributesErrorOverLimit(value: OverLimit)
SetQueueAttributesErrorQueueDoesNotExist(value: QueueDoesNotExist)
SetQueueAttributesErrorRequestThrottled(value: RequestThrottled)
SetQueueAttributesErrorUnsupportedOperation(value: UnsupportedOperation)
SetQueueAttributesErrorTransport(reason: String)
SetQueueAttributesErrorUnknown(error_type: String, status: Int, body: String)
}
fn set_queue_attributes_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(SetQueueAttributesErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidAttributeName", fn(body) {
case json.parse(body, decode_invalid_attribute_name_struct()) {
Ok(v) -> Ok(SetQueueAttributesErrorInvalidAttributeName(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidAttributeValue", fn(body) {
case json.parse(body, decode_invalid_attribute_value_struct()) {
Ok(v) -> Ok(SetQueueAttributesErrorInvalidAttributeValue(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(SetQueueAttributesErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("OverLimit", fn(body) {
case json.parse(body, decode_over_limit_struct()) {
Ok(v) -> Ok(SetQueueAttributesErrorOverLimit(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(SetQueueAttributesErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(SetQueueAttributesErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(SetQueueAttributesErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_set_queue_attributes_error(
err: runtime.ClientError,
) -> SetQueueAttributesError {
runtime.translate_service_error(
err,
set_queue_attributes_error_decoders(),
fn(reason) { SetQueueAttributesErrorTransport(reason: reason) },
fn(et, s, body) {
SetQueueAttributesErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub fn encode_start_message_move_task_input(
input: StartMessageMoveTaskRequest,
) -> String {
json.to_string(encode_start_message_move_task_request_struct_top(input))
}
pub fn decode_start_message_move_task_output(
body: String,
) -> Result(StartMessageMoveTaskResult, String) {
case json.parse(body, decode_start_message_move_task_result_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_start_message_move_task_request(
input: StartMessageMoveTaskRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_start_message_move_task_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.StartMessageMoveTask"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_start_message_move_task_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(StartMessageMoveTaskResult, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_start_message_move_task_output("{}")
_ -> decode_start_message_move_task_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type StartMessageMoveTaskError {
StartMessageMoveTaskErrorInvalidAddress(value: InvalidAddress)
StartMessageMoveTaskErrorInvalidSecurity(value: InvalidSecurity)
StartMessageMoveTaskErrorRequestThrottled(value: RequestThrottled)
StartMessageMoveTaskErrorResourceNotFoundException(
value: ResourceNotFoundException,
)
StartMessageMoveTaskErrorUnsupportedOperation(value: UnsupportedOperation)
StartMessageMoveTaskErrorTransport(reason: String)
StartMessageMoveTaskErrorUnknown(
error_type: String,
status: Int,
body: String,
)
}
fn start_message_move_task_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(StartMessageMoveTaskErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(StartMessageMoveTaskErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(StartMessageMoveTaskErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("ResourceNotFoundException", fn(body) {
case json.parse(body, decode_resource_not_found_exception_struct()) {
Ok(v) ->
Ok(StartMessageMoveTaskErrorResourceNotFoundException(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(StartMessageMoveTaskErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_start_message_move_task_error(
err: runtime.ClientError,
) -> StartMessageMoveTaskError {
runtime.translate_service_error(
err,
start_message_move_task_error_decoders(),
fn(reason) { StartMessageMoveTaskErrorTransport(reason: reason) },
fn(et, s, body) {
StartMessageMoveTaskErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub type TagQueueOutput {
TagQueueOutput
}
pub fn tag_queue_output_default() -> TagQueueOutput {
TagQueueOutput
}
pub fn decode_tag_queue_output_struct() -> decode.Decoder(TagQueueOutput) {
decode.success(TagQueueOutput)
}
pub fn encode_tag_queue_input(input: TagQueueRequest) -> String {
json.to_string(encode_tag_queue_request_struct_top(input))
}
pub fn decode_tag_queue_output(body: String) -> Result(TagQueueOutput, String) {
case json.parse(body, decode_tag_queue_output_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_tag_queue_request(
input: TagQueueRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_tag_queue_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.TagQueue"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_tag_queue_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(TagQueueOutput, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_tag_queue_output("{}")
_ -> decode_tag_queue_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type TagQueueError {
TagQueueErrorInvalidAddress(value: InvalidAddress)
TagQueueErrorInvalidSecurity(value: InvalidSecurity)
TagQueueErrorQueueDoesNotExist(value: QueueDoesNotExist)
TagQueueErrorRequestThrottled(value: RequestThrottled)
TagQueueErrorUnsupportedOperation(value: UnsupportedOperation)
TagQueueErrorTransport(reason: String)
TagQueueErrorUnknown(error_type: String, status: Int, body: String)
}
fn tag_queue_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(TagQueueErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(TagQueueErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(TagQueueErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(TagQueueErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(TagQueueErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_tag_queue_error(err: runtime.ClientError) -> TagQueueError {
runtime.translate_service_error(
err,
tag_queue_error_decoders(),
fn(reason) { TagQueueErrorTransport(reason: reason) },
fn(et, s, body) {
TagQueueErrorUnknown(error_type: et, status: s, body: body)
},
)
}
pub type UntagQueueOutput {
UntagQueueOutput
}
pub fn untag_queue_output_default() -> UntagQueueOutput {
UntagQueueOutput
}
pub fn decode_untag_queue_output_struct() -> decode.Decoder(UntagQueueOutput) {
decode.success(UntagQueueOutput)
}
pub fn encode_untag_queue_input(input: UntagQueueRequest) -> String {
json.to_string(encode_untag_queue_request_struct_top(input))
}
pub fn decode_untag_queue_output(
body: String,
) -> Result(UntagQueueOutput, String) {
case json.parse(body, decode_untag_queue_output_struct()) {
Ok(v) -> Ok(v)
Error(_) -> Error("decode failed")
}
}
pub fn build_untag_queue_request(
input: UntagQueueRequest,
) -> #(String, String, dict.Dict(String, String), BitArray) {
let body_str = encode_untag_queue_input(input)
let body = bit_array.from_string(body_str)
let headers =
dict.from_list([
#("Content-Type", "application/x-amz-json-1.0"),
#("Content-Length", int.to_string(bit_array.byte_size(body))),
#("X-Amz-Target", "AmazonSQS.UntagQueue"),
#("x-amzn-query-mode", "true"),
])
#("POST", "/", headers, body)
}
pub fn parse_untag_queue_response(
_code: Int,
_headers: dict.Dict(String, String),
body: BitArray,
) -> Result(UntagQueueOutput, String) {
case bit_array.to_string(body) {
Ok(text) ->
case text {
"" -> decode_untag_queue_output("{}")
_ -> decode_untag_queue_output(text)
}
Error(_) -> Error("non-utf8 body")
}
}
pub type UntagQueueError {
UntagQueueErrorInvalidAddress(value: InvalidAddress)
UntagQueueErrorInvalidSecurity(value: InvalidSecurity)
UntagQueueErrorQueueDoesNotExist(value: QueueDoesNotExist)
UntagQueueErrorRequestThrottled(value: RequestThrottled)
UntagQueueErrorUnsupportedOperation(value: UnsupportedOperation)
UntagQueueErrorTransport(reason: String)
UntagQueueErrorUnknown(error_type: String, status: Int, body: String)
}
fn untag_queue_error_decoders() {
[
#("InvalidAddress", fn(body) {
case json.parse(body, decode_invalid_address_struct()) {
Ok(v) -> Ok(UntagQueueErrorInvalidAddress(value: v))
Error(_) -> Error(Nil)
}
}),
#("InvalidSecurity", fn(body) {
case json.parse(body, decode_invalid_security_struct()) {
Ok(v) -> Ok(UntagQueueErrorInvalidSecurity(value: v))
Error(_) -> Error(Nil)
}
}),
#("QueueDoesNotExist", fn(body) {
case json.parse(body, decode_queue_does_not_exist_struct()) {
Ok(v) -> Ok(UntagQueueErrorQueueDoesNotExist(value: v))
Error(_) -> Error(Nil)
}
}),
#("RequestThrottled", fn(body) {
case json.parse(body, decode_request_throttled_struct()) {
Ok(v) -> Ok(UntagQueueErrorRequestThrottled(value: v))
Error(_) -> Error(Nil)
}
}),
#("UnsupportedOperation", fn(body) {
case json.parse(body, decode_unsupported_operation_struct()) {
Ok(v) -> Ok(UntagQueueErrorUnsupportedOperation(value: v))
Error(_) -> Error(Nil)
}
}),
]
}
fn translate_untag_queue_error(err: runtime.ClientError) -> UntagQueueError {
runtime.translate_service_error(
err,
untag_queue_error_decoders(),
fn(reason) { UntagQueueErrorTransport(reason: reason) },
fn(et, s, body) {
UntagQueueErrorUnknown(error_type: et, status: s, body: body)
},
)
}
/// Invoke AddPermission. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `AddPermissionError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `AddPermissionErrorTransport` variant.
pub fn add_permission(
client: Client,
input: AddPermissionRequest,
) -> Result(AddPermissionOutput, AddPermissionError) {
case
runtime.invoke(
client.config,
build_add_permission_request(input),
parse_add_permission_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_add_permission_error(err))
}
}
/// Invoke CancelMessageMoveTask. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `CancelMessageMoveTaskError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `CancelMessageMoveTaskErrorTransport` variant.
pub fn cancel_message_move_task(
client: Client,
input: CancelMessageMoveTaskRequest,
) -> Result(CancelMessageMoveTaskResult, CancelMessageMoveTaskError) {
case
runtime.invoke(
client.config,
build_cancel_message_move_task_request(input),
parse_cancel_message_move_task_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_cancel_message_move_task_error(err))
}
}
/// Invoke ChangeMessageVisibility. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ChangeMessageVisibilityError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ChangeMessageVisibilityErrorTransport` variant.
pub fn change_message_visibility(
client: Client,
input: ChangeMessageVisibilityRequest,
) -> Result(ChangeMessageVisibilityOutput, ChangeMessageVisibilityError) {
case
runtime.invoke(
client.config,
build_change_message_visibility_request(input),
parse_change_message_visibility_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_change_message_visibility_error(err))
}
}
/// Invoke ChangeMessageVisibilityBatch. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ChangeMessageVisibilityBatchError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ChangeMessageVisibilityBatchErrorTransport` variant.
pub fn change_message_visibility_batch(
client: Client,
input: ChangeMessageVisibilityBatchRequest,
) -> Result(
ChangeMessageVisibilityBatchResult,
ChangeMessageVisibilityBatchError,
) {
case
runtime.invoke(
client.config,
build_change_message_visibility_batch_request(input),
parse_change_message_visibility_batch_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_change_message_visibility_batch_error(err))
}
}
/// Invoke CreateQueue. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `CreateQueueError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `CreateQueueErrorTransport` variant.
pub fn create_queue(
client: Client,
input: CreateQueueRequest,
) -> Result(CreateQueueResult, CreateQueueError) {
case
runtime.invoke(
client.config,
build_create_queue_request(input),
parse_create_queue_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_create_queue_error(err))
}
}
/// Invoke DeleteMessage. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DeleteMessageError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DeleteMessageErrorTransport` variant.
pub fn delete_message(
client: Client,
input: DeleteMessageRequest,
) -> Result(DeleteMessageOutput, DeleteMessageError) {
case
runtime.invoke(
client.config,
build_delete_message_request(input),
parse_delete_message_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_delete_message_error(err))
}
}
/// Invoke DeleteMessageBatch. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DeleteMessageBatchError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DeleteMessageBatchErrorTransport` variant.
pub fn delete_message_batch(
client: Client,
input: DeleteMessageBatchRequest,
) -> Result(DeleteMessageBatchResult, DeleteMessageBatchError) {
case
runtime.invoke(
client.config,
build_delete_message_batch_request(input),
parse_delete_message_batch_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_delete_message_batch_error(err))
}
}
/// Invoke DeleteQueue. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `DeleteQueueError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `DeleteQueueErrorTransport` variant.
pub fn delete_queue(
client: Client,
input: DeleteQueueRequest,
) -> Result(DeleteQueueOutput, DeleteQueueError) {
case
runtime.invoke(
client.config,
build_delete_queue_request(input),
parse_delete_queue_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_delete_queue_error(err))
}
}
/// Invoke GetQueueAttributes. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `GetQueueAttributesError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `GetQueueAttributesErrorTransport` variant.
pub fn get_queue_attributes(
client: Client,
input: GetQueueAttributesRequest,
) -> Result(GetQueueAttributesResult, GetQueueAttributesError) {
case
runtime.invoke(
client.config,
build_get_queue_attributes_request(input),
parse_get_queue_attributes_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_get_queue_attributes_error(err))
}
}
/// Invoke GetQueueUrl. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `GetQueueUrlError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `GetQueueUrlErrorTransport` variant.
pub fn get_queue_url(
client: Client,
input: GetQueueUrlRequest,
) -> Result(GetQueueUrlResult, GetQueueUrlError) {
case
runtime.invoke(
client.config,
build_get_queue_url_request(input),
parse_get_queue_url_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_get_queue_url_error(err))
}
}
/// Invoke ListDeadLetterSourceQueues. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ListDeadLetterSourceQueuesError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ListDeadLetterSourceQueuesErrorTransport` variant.
pub fn list_dead_letter_source_queues(
client: Client,
input: ListDeadLetterSourceQueuesRequest,
) -> Result(ListDeadLetterSourceQueuesResult, ListDeadLetterSourceQueuesError) {
case
runtime.invoke(
client.config,
build_list_dead_letter_source_queues_request(input),
parse_list_dead_letter_source_queues_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_list_dead_letter_source_queues_error(err))
}
}
/// Invoke ListMessageMoveTasks. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ListMessageMoveTasksError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ListMessageMoveTasksErrorTransport` variant.
pub fn list_message_move_tasks(
client: Client,
input: ListMessageMoveTasksRequest,
) -> Result(ListMessageMoveTasksResult, ListMessageMoveTasksError) {
case
runtime.invoke(
client.config,
build_list_message_move_tasks_request(input),
parse_list_message_move_tasks_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_list_message_move_tasks_error(err))
}
}
/// Invoke ListQueues. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ListQueuesError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ListQueuesErrorTransport` variant.
pub fn list_queues(
client: Client,
input: ListQueuesRequest,
) -> Result(ListQueuesResult, ListQueuesError) {
case
runtime.invoke(
client.config,
build_list_queues_request(input),
parse_list_queues_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_list_queues_error(err))
}
}
/// Invoke ListQueueTags. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ListQueueTagsError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ListQueueTagsErrorTransport` variant.
pub fn list_queue_tags(
client: Client,
input: ListQueueTagsRequest,
) -> Result(ListQueueTagsResult, ListQueueTagsError) {
case
runtime.invoke(
client.config,
build_list_queue_tags_request(input),
parse_list_queue_tags_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_list_queue_tags_error(err))
}
}
/// Invoke PurgeQueue. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `PurgeQueueError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `PurgeQueueErrorTransport` variant.
pub fn purge_queue(
client: Client,
input: PurgeQueueRequest,
) -> Result(PurgeQueueOutput, PurgeQueueError) {
case
runtime.invoke(
client.config,
build_purge_queue_request(input),
parse_purge_queue_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_purge_queue_error(err))
}
}
/// Invoke ReceiveMessage. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `ReceiveMessageError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `ReceiveMessageErrorTransport` variant.
pub fn receive_message(
client: Client,
input: ReceiveMessageRequest,
) -> Result(ReceiveMessageResult, ReceiveMessageError) {
case
runtime.invoke(
client.config,
build_receive_message_request(input),
parse_receive_message_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_receive_message_error(err))
}
}
/// Invoke RemovePermission. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `RemovePermissionError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `RemovePermissionErrorTransport` variant.
pub fn remove_permission(
client: Client,
input: RemovePermissionRequest,
) -> Result(RemovePermissionOutput, RemovePermissionError) {
case
runtime.invoke(
client.config,
build_remove_permission_request(input),
parse_remove_permission_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_remove_permission_error(err))
}
}
/// Invoke SendMessage. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `SendMessageError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `SendMessageErrorTransport` variant.
pub fn send_message(
client: Client,
input: SendMessageRequest,
) -> Result(SendMessageResult, SendMessageError) {
case
runtime.invoke(
client.config,
build_send_message_request(input),
parse_send_message_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_send_message_error(err))
}
}
/// Invoke SendMessageBatch. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `SendMessageBatchError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `SendMessageBatchErrorTransport` variant.
pub fn send_message_batch(
client: Client,
input: SendMessageBatchRequest,
) -> Result(SendMessageBatchResult, SendMessageBatchError) {
case
runtime.invoke(
client.config,
build_send_message_batch_request(input),
parse_send_message_batch_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_send_message_batch_error(err))
}
}
/// Invoke SetQueueAttributes. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `SetQueueAttributesError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `SetQueueAttributesErrorTransport` variant.
pub fn set_queue_attributes(
client: Client,
input: SetQueueAttributesRequest,
) -> Result(SetQueueAttributesOutput, SetQueueAttributesError) {
case
runtime.invoke(
client.config,
build_set_queue_attributes_request(input),
parse_set_queue_attributes_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_set_queue_attributes_error(err))
}
}
/// Invoke StartMessageMoveTask. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `StartMessageMoveTaskError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `StartMessageMoveTaskErrorTransport` variant.
pub fn start_message_move_task(
client: Client,
input: StartMessageMoveTaskRequest,
) -> Result(StartMessageMoveTaskResult, StartMessageMoveTaskError) {
case
runtime.invoke(
client.config,
build_start_message_move_task_request(input),
parse_start_message_move_task_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_start_message_move_task_error(err))
}
}
/// Invoke TagQueue. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `TagQueueError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `TagQueueErrorTransport` variant.
pub fn tag_queue(
client: Client,
input: TagQueueRequest,
) -> Result(TagQueueOutput, TagQueueError) {
case
runtime.invoke(
client.config,
build_tag_queue_request(input),
parse_tag_queue_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_tag_queue_error(err))
}
}
/// Invoke UntagQueue. Signs the request with SigV4 and dispatches via the configured
/// HTTP transport. Service errors come back as typed `UntagQueueError`
/// variants; transport, decode, and credentials failures all collapse
/// into the generic `UntagQueueErrorTransport` variant.
pub fn untag_queue(
client: Client,
input: UntagQueueRequest,
) -> Result(UntagQueueOutput, UntagQueueError) {
case
runtime.invoke(
client.config,
build_untag_queue_request(input),
parse_untag_queue_response,
)
{
Ok(out) -> Ok(out)
Error(err) -> Error(translate_untag_queue_error(err))
}
}
pub fn paginate_list_dead_letter_source_queues(
client: Client,
input: ListDeadLetterSourceQueuesRequest,
acc: acc,
reducer: fn(acc, List(String)) -> acc,
) -> Result(acc, ListDeadLetterSourceQueuesError) {
let step = fn(cursor) {
let input = case cursor {
option.Some(_) ->
ListDeadLetterSourceQueuesRequest(..input, next_token: cursor)
option.None -> input
}
case list_dead_letter_source_queues(client, input) {
Ok(out) -> Ok(#(option.unwrap(out.queue_urls, []), out.next_token))
Error(e) -> Error(e)
}
}
pagination.fold(acc: acc, step: step, reducer: reducer)
}
pub fn paginate_list_queues(
client: Client,
input: ListQueuesRequest,
acc: acc,
reducer: fn(acc, List(String)) -> acc,
) -> Result(acc, ListQueuesError) {
let step = fn(cursor) {
let input = case cursor {
option.Some(_) -> ListQueuesRequest(..input, next_token: cursor)
option.None -> input
}
case list_queues(client, input) {
Ok(out) -> Ok(#(option.unwrap(out.queue_urls, []), out.next_token))
Error(e) -> Error(e)
}
}
pagination.fold(acc: acc, step: step, reducer: reducer)
}
pub fn parse_invalid_address_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "InvalidAddress")
}
pub fn parse_invalid_security_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "InvalidSecurity")
}
pub fn parse_over_limit_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "OverLimit")
}
pub fn parse_queue_does_not_exist_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "QueueDoesNotExist")
}
pub fn parse_request_throttled_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "RequestThrottled")
}
pub fn parse_unsupported_operation_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "UnsupportedOperation")
}
pub fn parse_resource_not_found_exception_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "ResourceNotFoundException")
}
pub fn parse_message_not_inflight_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "MessageNotInflight")
}
pub fn parse_receipt_handle_is_invalid_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "ReceiptHandleIsInvalid")
}
pub fn parse_batch_entry_ids_not_distinct_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "BatchEntryIdsNotDistinct")
}
pub fn parse_empty_batch_request_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "EmptyBatchRequest")
}
pub fn parse_invalid_batch_entry_id_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "InvalidBatchEntryId")
}
pub fn parse_too_many_entries_in_batch_request_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(
headers,
body,
"TooManyEntriesInBatchRequest",
)
}
pub fn parse_invalid_attribute_name_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "InvalidAttributeName")
}
pub fn parse_invalid_attribute_value_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "InvalidAttributeValue")
}
pub fn parse_queue_deleted_recently_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "QueueDeletedRecently")
}
pub fn parse_queue_name_exists_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "QueueNameExists")
}
pub fn parse_invalid_id_format_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "InvalidIdFormat")
}
pub fn parse_purge_queue_in_progress_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "PurgeQueueInProgress")
}
pub fn parse_kms_access_denied_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "KmsAccessDenied")
}
pub fn parse_kms_disabled_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "KmsDisabled")
}
pub fn parse_kms_invalid_key_usage_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "KmsInvalidKeyUsage")
}
pub fn parse_kms_invalid_state_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "KmsInvalidState")
}
pub fn parse_kms_not_found_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "KmsNotFound")
}
pub fn parse_kms_opt_in_required_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "KmsOptInRequired")
}
pub fn parse_kms_throttled_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "KmsThrottled")
}
pub fn parse_invalid_message_contents_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "InvalidMessageContents")
}
pub fn parse_batch_request_too_long_response(
_code: Int,
headers: dict.Dict(String, String),
body: BitArray,
) -> Result(Nil, String) {
runtime.check_error_type_matches(headers, body, "BatchRequestTooLong")
}