# This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: opensearch
using AWS.Compat
using AWS.UUIDs

"""
    accept_inbound_connection(connection_id)
    accept_inbound_connection(connection_id, params::Dict{String,<:Any})

Allows the remote domain owner to accept an inbound cross-cluster connection request.

# Arguments
- `connection_id`: The ID of the inbound connection you want to accept.

"""
function accept_inbound_connection(
    ConnectionId; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "PUT",
        "/2021-01-01/opensearch/cc/inboundConnection/$(ConnectionId)/accept";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function accept_inbound_connection(
    ConnectionId,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "PUT",
        "/2021-01-01/opensearch/cc/inboundConnection/$(ConnectionId)/accept",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    add_tags(arn, tag_list)
    add_tags(arn, tag_list, params::Dict{String,<:Any})

Attaches tags to an existing domain. Tags are a set of case-sensitive key value pairs. An
domain can have up to 10 tags. See  Tagging Amazon OpenSearch Service domains for more
information.

# Arguments
- `arn`: Specify the ARN of the domain you want to add tags to.
- `tag_list`: List of Tag to add to the domain.

"""
function add_tags(ARN, TagList; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "POST",
        "/2021-01-01/tags",
        Dict{String,Any}("ARN" => ARN, "TagList" => TagList);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function add_tags(
    ARN,
    TagList,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/tags",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("ARN" => ARN, "TagList" => TagList), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    associate_package(domain_name, package_id)
    associate_package(domain_name, package_id, params::Dict{String,<:Any})

Associates a package with an Amazon OpenSearch Service domain.

# Arguments
- `domain_name`: The name of the domain to associate the package with.
- `package_id`: Internal ID of the package to associate with a domain. Use DescribePackages
  to find this value.

"""
function associate_package(
    DomainName, PackageID; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "POST",
        "/2021-01-01/packages/associate/$(PackageID)/$(DomainName)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function associate_package(
    DomainName,
    PackageID,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/packages/associate/$(PackageID)/$(DomainName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    cancel_service_software_update(domain_name)
    cancel_service_software_update(domain_name, params::Dict{String,<:Any})

Cancels a scheduled service software update for an Amazon OpenSearch Service domain. You
can only perform this operation before the AutomatedUpdateDate and when the UpdateStatus is
in the PENDING_UPDATE state.

# Arguments
- `domain_name`: The name of the domain that you want to stop the latest service software
  update on.

"""
function cancel_service_software_update(
    DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/serviceSoftwareUpdate/cancel",
        Dict{String,Any}("DomainName" => DomainName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function cancel_service_software_update(
    DomainName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/serviceSoftwareUpdate/cancel",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    create_domain(domain_name)
    create_domain(domain_name, params::Dict{String,<:Any})

Creates a new Amazon OpenSearch Service domain. For more information, see Creating and
managing Amazon OpenSearch Service domains  in the Amazon OpenSearch Service Developer
Guide.

# Arguments
- `domain_name`: The name of the Amazon OpenSearch Service domain you're creating. Domain
  names are unique across the domains owned by an account within an AWS region. Domain names
  must start with a lowercase letter and can contain the following characters: a-z
  (lowercase), 0-9, and - (hyphen).

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccessPolicies"`: IAM access policy as a JSON-formatted string.
- `"AdvancedOptions"`: Option to allow references to indices in an HTTP request body. Must
  be false when configuring access to individual sub-resources. By default, the value is
  true. See Advanced cluster parameters  for more information.
- `"AdvancedSecurityOptions"`: Specifies advanced security options.
- `"AutoTuneOptions"`: Specifies Auto-Tune options.
- `"ClusterConfig"`: Configuration options for a domain. Specifies the instance type and
  number of instances in the domain.
- `"CognitoOptions"`: Options to specify the Cognito user and identity pools for OpenSearch
  Dashboards authentication. For more information, see Configuring Amazon Cognito
  authentication for OpenSearch Dashboards.
- `"DomainEndpointOptions"`: Options to specify configurations that will be applied to the
  domain endpoint.
- `"EBSOptions"`: Options to enable, disable, and specify the type and size of EBS storage
  volumes.
- `"EncryptionAtRestOptions"`: Options for encryption of data at rest.
- `"EngineVersion"`: String of format Elasticsearch_X.Y or OpenSearch_X.Y to specify the
  engine version for the Amazon OpenSearch Service domain. For example, \"OpenSearch_1.0\" or
  \"Elasticsearch_7.9\". For more information, see Creating and managing Amazon OpenSearch
  Service domains .
- `"LogPublishingOptions"`: Map of LogType and LogPublishingOption, each containing options
  to publish a given type of OpenSearch log.
- `"NodeToNodeEncryptionOptions"`: Node-to-node encryption options.
- `"SnapshotOptions"`: Option to set time, in UTC format, of the daily automated snapshot.
  Default value is 0 hours.
- `"TagList"`: A list of Tag added during domain creation.
- `"VPCOptions"`: Options to specify the subnets and security groups for a VPC endpoint.
  For more information, see Launching your Amazon OpenSearch Service domains using a VPC .
"""
function create_domain(DomainName; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/domain",
        Dict{String,Any}("DomainName" => DomainName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function create_domain(
    DomainName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/domain",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    create_outbound_connection(connection_alias, local_domain_info, remote_domain_info)
    create_outbound_connection(connection_alias, local_domain_info, remote_domain_info, params::Dict{String,<:Any})

Creates a new cross-cluster connection from a local OpenSearch domain to a remote
OpenSearch domain.

# Arguments
- `connection_alias`: The connection alias used used by the customer for this cross-cluster
  connection.
- `local_domain_info`: The  AWSDomainInformation  for the local OpenSearch domain.
- `remote_domain_info`: The  AWSDomainInformation  for the remote OpenSearch domain.

"""
function create_outbound_connection(
    ConnectionAlias,
    LocalDomainInfo,
    RemoteDomainInfo;
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/cc/outboundConnection",
        Dict{String,Any}(
            "ConnectionAlias" => ConnectionAlias,
            "LocalDomainInfo" => LocalDomainInfo,
            "RemoteDomainInfo" => RemoteDomainInfo,
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function create_outbound_connection(
    ConnectionAlias,
    LocalDomainInfo,
    RemoteDomainInfo,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/cc/outboundConnection",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "ConnectionAlias" => ConnectionAlias,
                    "LocalDomainInfo" => LocalDomainInfo,
                    "RemoteDomainInfo" => RemoteDomainInfo,
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    create_package(package_name, package_source, package_type)
    create_package(package_name, package_source, package_type, params::Dict{String,<:Any})

Create a package for use with Amazon OpenSearch Service domains.

# Arguments
- `package_name`: Unique identifier for the package.
- `package_source`: The Amazon S3 location from which to import the package.
- `package_type`: Type of package. Currently supports only TXT-DICTIONARY.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"PackageDescription"`: Description of the package.
"""
function create_package(
    PackageName,
    PackageSource,
    PackageType;
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/packages",
        Dict{String,Any}(
            "PackageName" => PackageName,
            "PackageSource" => PackageSource,
            "PackageType" => PackageType,
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function create_package(
    PackageName,
    PackageSource,
    PackageType,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/packages",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "PackageName" => PackageName,
                    "PackageSource" => PackageSource,
                    "PackageType" => PackageType,
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    delete_domain(domain_name)
    delete_domain(domain_name, params::Dict{String,<:Any})

Permanently deletes the specified domain and all of its data. Once a domain is deleted, it
cannot be recovered.

# Arguments
- `domain_name`: The name of the domain you want to permanently delete.

"""
function delete_domain(DomainName; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "DELETE",
        "/2021-01-01/opensearch/domain/$(DomainName)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_domain(
    DomainName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "DELETE",
        "/2021-01-01/opensearch/domain/$(DomainName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    delete_inbound_connection(connection_id)
    delete_inbound_connection(connection_id, params::Dict{String,<:Any})

Allows the remote domain owner to delete an existing inbound cross-cluster connection.

# Arguments
- `connection_id`: The ID of the inbound connection to permanently delete.

"""
function delete_inbound_connection(
    ConnectionId; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "DELETE",
        "/2021-01-01/opensearch/cc/inboundConnection/$(ConnectionId)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_inbound_connection(
    ConnectionId,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "DELETE",
        "/2021-01-01/opensearch/cc/inboundConnection/$(ConnectionId)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    delete_outbound_connection(connection_id)
    delete_outbound_connection(connection_id, params::Dict{String,<:Any})

Allows the local domain owner to delete an existing outbound cross-cluster connection.

# Arguments
- `connection_id`: The ID of the outbound connection you want to permanently delete.

"""
function delete_outbound_connection(
    ConnectionId; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "DELETE",
        "/2021-01-01/opensearch/cc/outboundConnection/$(ConnectionId)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_outbound_connection(
    ConnectionId,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "DELETE",
        "/2021-01-01/opensearch/cc/outboundConnection/$(ConnectionId)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    delete_package(package_id)
    delete_package(package_id, params::Dict{String,<:Any})

Deletes the package.

# Arguments
- `package_id`: The internal ID of the package you want to delete. Use DescribePackages to
  find this value.

"""
function delete_package(PackageID; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "DELETE",
        "/2021-01-01/packages/$(PackageID)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function delete_package(
    PackageID,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "DELETE",
        "/2021-01-01/packages/$(PackageID)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    describe_domain(domain_name)
    describe_domain(domain_name, params::Dict{String,<:Any})

Returns domain configuration information about the specified domain, including the domain
ID, domain endpoint, and domain ARN.

# Arguments
- `domain_name`: The name of the domain for which you want information.

"""
function describe_domain(DomainName; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/domain/$(DomainName)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function describe_domain(
    DomainName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/domain/$(DomainName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    describe_domain_auto_tunes(domain_name)
    describe_domain_auto_tunes(domain_name, params::Dict{String,<:Any})

Provides scheduled Auto-Tune action details for the domain, such as Auto-Tune action type,
description, severity, and scheduled date.

# Arguments
- `domain_name`: The domain name for which you want Auto-Tune action details.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"MaxResults"`: Set this value to limit the number of results returned. If not specified,
  defaults to 100.
- `"NextToken"`: NextToken is sent in case the earlier API call results contain the
  NextToken. Used for pagination.
"""
function describe_domain_auto_tunes(
    DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/domain/$(DomainName)/autoTunes";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function describe_domain_auto_tunes(
    DomainName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/domain/$(DomainName)/autoTunes",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    describe_domain_config(domain_name)
    describe_domain_config(domain_name, params::Dict{String,<:Any})

Provides cluster configuration information about the specified domain, such as the state,
creation date, update version, and update date for cluster options.

# Arguments
- `domain_name`: The domain you want to get information about.

"""
function describe_domain_config(
    DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/domain/$(DomainName)/config";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function describe_domain_config(
    DomainName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/domain/$(DomainName)/config",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    describe_domains(domain_names)
    describe_domains(domain_names, params::Dict{String,<:Any})

Returns domain configuration information about the specified domains, including the domain
ID, domain endpoint, and domain ARN.

# Arguments
- `domain_names`: The domains for which you want information.

"""
function describe_domains(DomainNames; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/domain-info",
        Dict{String,Any}("DomainNames" => DomainNames);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function describe_domains(
    DomainNames,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/domain-info",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("DomainNames" => DomainNames), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    describe_inbound_connections()
    describe_inbound_connections(params::Dict{String,<:Any})

Lists all the inbound cross-cluster connections for a remote domain.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Filters"`:  A list of filters used to match properties for inbound cross-cluster
  connections. Available  Filter  values are:  connection-id local-domain-info.domain-name
  local-domain-info.owner-id local-domain-info.region remote-domain-info.domain-name
- `"MaxResults"`: Set this value to limit the number of results returned. If not specified,
  defaults to 100.
- `"NextToken"`: If more results are available and NextToken is present, make the next
  request to the same API with the received NextToken to paginate the remaining results.
"""
function describe_inbound_connections(; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/cc/inboundConnection/search";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function describe_inbound_connections(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/cc/inboundConnection/search",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    describe_instance_type_limits(engine_version, instance_type)
    describe_instance_type_limits(engine_version, instance_type, params::Dict{String,<:Any})

 Describe the limits for a given instance type and OpenSearch or Elasticsearch version.
When modifying an existing domain, specify the  DomainName  to see which limits you can
modify.

# Arguments
- `engine_version`:  Version of OpenSearch for which  Limits  are needed.
- `instance_type`:  The instance type for an OpenSearch cluster for which OpenSearch
  Limits  are needed.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domainName"`:  The name of the domain you want to modify. Only include this value if
  you're querying OpenSearch  Limits  for an existing domain.
"""
function describe_instance_type_limits(
    EngineVersion, InstanceType; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/instanceTypeLimits/$(EngineVersion)/$(InstanceType)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function describe_instance_type_limits(
    EngineVersion,
    InstanceType,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/instanceTypeLimits/$(EngineVersion)/$(InstanceType)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    describe_outbound_connections()
    describe_outbound_connections(params::Dict{String,<:Any})

Lists all the outbound cross-cluster connections for a local domain.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Filters"`:  A list of filters used to match properties for outbound cross-cluster
  connections. Available  Filter  names for this operation are:  connection-id
  remote-domain-info.domain-name remote-domain-info.owner-id remote-domain-info.region
  local-domain-info.domain-name
- `"MaxResults"`: Set this value to limit the number of results returned. If not specified,
  defaults to 100.
- `"NextToken"`: NextToken is sent in case the earlier API call results contain the
  NextToken parameter. Used for pagination.
"""
function describe_outbound_connections(; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/cc/outboundConnection/search";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function describe_outbound_connections(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/cc/outboundConnection/search",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    describe_packages()
    describe_packages(params::Dict{String,<:Any})

Describes all packages available to Amazon OpenSearch Service domains. Includes options for
filtering, limiting the number of results, and pagination.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"Filters"`: Only returns packages that match the DescribePackagesFilterList values.
- `"MaxResults"`: Limits results to a maximum number of packages.
- `"NextToken"`: Used for pagination. Only necessary if a previous API call includes a
  non-null NextToken value. If provided, returns results for the next page.
"""
function describe_packages(; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "POST",
        "/2021-01-01/packages/describe";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function describe_packages(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "POST",
        "/2021-01-01/packages/describe",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    describe_reserved_instance_offerings()
    describe_reserved_instance_offerings(params::Dict{String,<:Any})

Lists available reserved OpenSearch instance offerings.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Set this value to limit the number of results returned. If not specified,
  defaults to 100.
- `"nextToken"`: Provides an identifier to allow retrieval of paginated results.
- `"offeringId"`: The offering identifier filter value. Use this parameter to show only the
  available offering that matches the specified reservation identifier.
"""
function describe_reserved_instance_offerings(;
    aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/reservedInstanceOfferings";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function describe_reserved_instance_offerings(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/reservedInstanceOfferings",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    describe_reserved_instances()
    describe_reserved_instances(params::Dict{String,<:Any})

Returns information about reserved OpenSearch instances for this account.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Set this value to limit the number of results returned. If not specified,
  defaults to 100.
- `"nextToken"`: Provides an identifier to allow retrieval of paginated results.
- `"reservationId"`: The reserved instance identifier filter value. Use this parameter to
  show only the reservation that matches the specified reserved OpenSearch instance ID.
"""
function describe_reserved_instances(; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/reservedInstances";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function describe_reserved_instances(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/reservedInstances",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    dissociate_package(domain_name, package_id)
    dissociate_package(domain_name, package_id, params::Dict{String,<:Any})

Dissociates a package from the Amazon OpenSearch Service domain.

# Arguments
- `domain_name`: The name of the domain to associate the package with.
- `package_id`: The internal ID of the package to associate with a domain. Use
  DescribePackages to find this value.

"""
function dissociate_package(
    DomainName, PackageID; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "POST",
        "/2021-01-01/packages/dissociate/$(PackageID)/$(DomainName)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function dissociate_package(
    DomainName,
    PackageID,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/packages/dissociate/$(PackageID)/$(DomainName)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    get_compatible_versions()
    get_compatible_versions(params::Dict{String,<:Any})

 Returns a list of upgrade-compatible versions of OpenSearch/Elasticsearch. You can
optionally pass a  DomainName  to get all upgrade-compatible versions of
OpenSearch/Elasticsearch for that specific domain.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domainName"`:
"""
function get_compatible_versions(; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/compatibleVersions";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_compatible_versions(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/compatibleVersions",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    get_package_version_history(package_id)
    get_package_version_history(package_id, params::Dict{String,<:Any})

Returns a list of package versions, along with their creation time and commit message.

# Arguments
- `package_id`: Returns an audit history of package versions.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Limits results to a maximum number of package versions.
- `"nextToken"`: Used for pagination. Only necessary if a previous API call includes a
  non-null NextToken value. If provided, returns results for the next page.
"""
function get_package_version_history(
    PackageID; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/packages/$(PackageID)/history";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_package_version_history(
    PackageID,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "GET",
        "/2021-01-01/packages/$(PackageID)/history",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    get_upgrade_history(domain_name)
    get_upgrade_history(domain_name, params::Dict{String,<:Any})

Retrieves the complete history of the last 10 upgrades performed on the domain.

# Arguments
- `domain_name`:

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`:
- `"nextToken"`:
"""
function get_upgrade_history(DomainName; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/upgradeDomain/$(DomainName)/history";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_upgrade_history(
    DomainName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/upgradeDomain/$(DomainName)/history",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    get_upgrade_status(domain_name)
    get_upgrade_status(domain_name, params::Dict{String,<:Any})

Retrieves the latest status of the last upgrade or upgrade eligibility check performed on
the domain.

# Arguments
- `domain_name`:

"""
function get_upgrade_status(DomainName; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/upgradeDomain/$(DomainName)/status";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_upgrade_status(
    DomainName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/upgradeDomain/$(DomainName)/status",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    list_domain_names()
    list_domain_names(params::Dict{String,<:Any})

Returns the names of all domains owned by the current user's account.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"engineType"`:  Optional parameter to filter the output by domain engine type.
  Acceptable values are 'Elasticsearch' and 'OpenSearch'.
"""
function list_domain_names(; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "GET", "/2021-01-01/domain"; aws_config=aws_config, feature_set=SERVICE_FEATURE_SET
    )
end
function list_domain_names(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/domain",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    list_domains_for_package(package_id)
    list_domains_for_package(package_id, params::Dict{String,<:Any})

Lists all Amazon OpenSearch Service domains associated with the package.

# Arguments
- `package_id`: The package for which to list associated domains.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Limits the results to a maximum number of domains.
- `"nextToken"`: Used for pagination. Only necessary if a previous API call includes a
  non-null NextToken value. If provided, returns results for the next page.
"""
function list_domains_for_package(
    PackageID; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/packages/$(PackageID)/domains";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function list_domains_for_package(
    PackageID,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "GET",
        "/2021-01-01/packages/$(PackageID)/domains",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    list_instance_type_details(engine_version)
    list_instance_type_details(engine_version, params::Dict{String,<:Any})



# Arguments
- `engine_version`:

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"domainName"`:
- `"maxResults"`:
- `"nextToken"`:
"""
function list_instance_type_details(
    EngineVersion; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/instanceTypeDetails/$(EngineVersion)";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function list_instance_type_details(
    EngineVersion,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/instanceTypeDetails/$(EngineVersion)",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    list_packages_for_domain(domain_name)
    list_packages_for_domain(domain_name, params::Dict{String,<:Any})

Lists all packages associated with the Amazon OpenSearch Service domain.

# Arguments
- `domain_name`: The name of the domain for which you want to list associated packages.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`: Limits results to a maximum number of packages.
- `"nextToken"`: Used for pagination. Only necessary if a previous API call includes a
  non-null NextToken value. If provided, returns results for the next page.
"""
function list_packages_for_domain(
    DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/domain/$(DomainName)/packages";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function list_packages_for_domain(
    DomainName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "GET",
        "/2021-01-01/domain/$(DomainName)/packages",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    list_tags(arn)
    list_tags(arn, params::Dict{String,<:Any})

Returns all tags for the given domain.

# Arguments
- `arn`: Specify the ARN of the domain that the tags you want to view are attached to.

"""
function list_tags(arn; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "GET",
        "/2021-01-01/tags/",
        Dict{String,Any}("arn" => arn);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function list_tags(
    arn, params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/tags/",
        Dict{String,Any}(mergewith(_merge, Dict{String,Any}("arn" => arn), params));
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    list_versions()
    list_versions(params::Dict{String,<:Any})

List all supported versions of OpenSearch and Elasticsearch.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"maxResults"`:  Set this value to limit the number of results returned. Value must be
  greater than 10 or it won't be honored.
- `"nextToken"`:
"""
function list_versions(; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/versions";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function list_versions(
    params::AbstractDict{String}; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "GET",
        "/2021-01-01/opensearch/versions",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    purchase_reserved_instance_offering(reservation_name, reserved_instance_offering_id)
    purchase_reserved_instance_offering(reservation_name, reserved_instance_offering_id, params::Dict{String,<:Any})

Allows you to purchase reserved OpenSearch instances.

# Arguments
- `reservation_name`: A customer-specified identifier to track this reservation.
- `reserved_instance_offering_id`: The ID of the reserved OpenSearch instance offering to
  purchase.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"InstanceCount"`: The number of OpenSearch instances to reserve.
"""
function purchase_reserved_instance_offering(
    ReservationName,
    ReservedInstanceOfferingId;
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/purchaseReservedInstanceOffering",
        Dict{String,Any}(
            "ReservationName" => ReservationName,
            "ReservedInstanceOfferingId" => ReservedInstanceOfferingId,
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function purchase_reserved_instance_offering(
    ReservationName,
    ReservedInstanceOfferingId,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/purchaseReservedInstanceOffering",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "ReservationName" => ReservationName,
                    "ReservedInstanceOfferingId" => ReservedInstanceOfferingId,
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    reject_inbound_connection(connection_id)
    reject_inbound_connection(connection_id, params::Dict{String,<:Any})

Allows the remote domain owner to reject an inbound cross-cluster connection request.

# Arguments
- `connection_id`: The ID of the inbound connection to reject.

"""
function reject_inbound_connection(
    ConnectionId; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "PUT",
        "/2021-01-01/opensearch/cc/inboundConnection/$(ConnectionId)/reject";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function reject_inbound_connection(
    ConnectionId,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "PUT",
        "/2021-01-01/opensearch/cc/inboundConnection/$(ConnectionId)/reject",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    remove_tags(arn, tag_keys)
    remove_tags(arn, tag_keys, params::Dict{String,<:Any})

Removes the specified set of tags from the given domain.

# Arguments
- `arn`: The ARN of the domain from which you want to delete the specified tags.
- `tag_keys`: The TagKey list you want to remove from the domain.

"""
function remove_tags(ARN, TagKeys; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "POST",
        "/2021-01-01/tags-removal",
        Dict{String,Any}("ARN" => ARN, "TagKeys" => TagKeys);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function remove_tags(
    ARN,
    TagKeys,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/tags-removal",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("ARN" => ARN, "TagKeys" => TagKeys), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    start_service_software_update(domain_name)
    start_service_software_update(domain_name, params::Dict{String,<:Any})

Schedules a service software update for an Amazon OpenSearch Service domain.

# Arguments
- `domain_name`: The name of the domain that you want to update to the latest service
  software.

"""
function start_service_software_update(
    DomainName; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/serviceSoftwareUpdate/start",
        Dict{String,Any}("DomainName" => DomainName);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function start_service_software_update(
    DomainName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/serviceSoftwareUpdate/start",
        Dict{String,Any}(
            mergewith(_merge, Dict{String,Any}("DomainName" => DomainName), params)
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    update_domain_config(domain_name)
    update_domain_config(domain_name, params::Dict{String,<:Any})

Modifies the cluster configuration of the specified domain, such as setting the instance
type and the number of instances.

# Arguments
- `domain_name`: The name of the domain you're updating.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AccessPolicies"`: IAM access policy as a JSON-formatted string.
- `"AdvancedOptions"`: Modifies the advanced option to allow references to indices in an
  HTTP request body. Must be false when configuring access to individual sub-resources. By
  default, the value is true. See Advanced options  for more information.
- `"AdvancedSecurityOptions"`: Specifies advanced security options.
- `"AutoTuneOptions"`: Specifies Auto-Tune options.
- `"ClusterConfig"`: The type and number of instances to instantiate for the domain cluster.
- `"CognitoOptions"`: Options to specify the Cognito user and identity pools for OpenSearch
  Dashboards authentication. For more information, see Configuring Amazon Cognito
  authentication for OpenSearch Dashboards.
- `"DomainEndpointOptions"`: Options to specify configuration that will be applied to the
  domain endpoint.
- `"DryRun"`: This flag, when set to True, specifies whether the UpdateDomain request
  should return the results of validation checks (DryRunResults) without actually applying
  the change.
- `"EBSOptions"`: Specify the type and size of the EBS volume to use.
- `"EncryptionAtRestOptions"`: Specifies encryption of data at rest options.
- `"LogPublishingOptions"`: Map of LogType and LogPublishingOption, each containing options
  to publish a given type of OpenSearch log.
- `"NodeToNodeEncryptionOptions"`: Specifies node-to-node encryption options.
- `"SnapshotOptions"`: Option to set the time, in UTC format, for the daily automated
  snapshot. Default value is 0 hours.
- `"VPCOptions"`: Options to specify the subnets and security groups for the VPC endpoint.
  For more information, see Launching your Amazon OpenSearch Service domains using a VPC .
"""
function update_domain_config(DomainName; aws_config::AbstractAWSConfig=global_aws_config())
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/domain/$(DomainName)/config";
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function update_domain_config(
    DomainName,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/domain/$(DomainName)/config",
        params;
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    update_package(package_id, package_source)
    update_package(package_id, package_source, params::Dict{String,<:Any})

Updates a package for use with Amazon OpenSearch Service domains.

# Arguments
- `package_id`: The unique identifier for the package.
- `package_source`:

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"CommitMessage"`: A commit message for the new version which is shown as part of
  GetPackageVersionHistoryResponse.
- `"PackageDescription"`: A new description of the package.
"""
function update_package(
    PackageID, PackageSource; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "POST",
        "/2021-01-01/packages/update",
        Dict{String,Any}("PackageID" => PackageID, "PackageSource" => PackageSource);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function update_package(
    PackageID,
    PackageSource,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/packages/update",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "PackageID" => PackageID, "PackageSource" => PackageSource
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    upgrade_domain(domain_name, target_version)
    upgrade_domain(domain_name, target_version, params::Dict{String,<:Any})

Allows you to either upgrade your domain or perform an upgrade eligibility check to a
compatible version of OpenSearch or Elasticsearch.

# Arguments
- `domain_name`:
- `target_version`: The version of OpenSearch you intend to upgrade the domain to.

# Optional Parameters
Optional parameters can be passed as a `params::Dict{String,<:Any}`. Valid keys are:
- `"AdvancedOptions"`:
- `"PerformCheckOnly"`:  When true, indicates that an upgrade eligibility check needs to be
  performed. Does not actually perform the upgrade.
"""
function upgrade_domain(
    DomainName, TargetVersion; aws_config::AbstractAWSConfig=global_aws_config()
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/upgradeDomain",
        Dict{String,Any}("DomainName" => DomainName, "TargetVersion" => TargetVersion);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function upgrade_domain(
    DomainName,
    TargetVersion,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return opensearch(
        "POST",
        "/2021-01-01/opensearch/upgradeDomain",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "DomainName" => DomainName, "TargetVersion" => TargetVersion
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
