import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import * as C from "../category.js";
const ns = T.XmlNamespace("http://memorydb.amazonaws.com/doc/2021-01-01/");
const svc = T.AwsApiService({
    sdkId: "MemoryDB",
    serviceShapeName: "AmazonMemoryDB",
});
const auth = T.AwsAuthSigv4({ name: "memorydb" });
const ver = T.ServiceVersion("2021-01-01");
const proto = T.AwsProtocolsAwsJson1_1();
const rules = T.EndpointResolver((p, _) => {
    const { Region, UseDualStack = false, UseFIPS = false, Endpoint } = p;
    const e = (u, p = {}, h = {}) => ({
        type: "endpoint",
        endpoint: { url: u, properties: p, headers: h },
    });
    const err = (m) => ({
        type: "error",
        message: m,
    });
    if (Endpoint != null) {
        if (UseFIPS === true) {
            return err("Invalid Configuration: FIPS and custom endpoint are not supported");
        }
        if (UseDualStack === true) {
            return err("Invalid Configuration: Dualstack and custom endpoint are not supported");
        }
        return e(Endpoint);
    }
    if (Region != null) {
        {
            const PartitionResult = _.partition(Region);
            if (PartitionResult != null && PartitionResult !== false) {
                if (UseFIPS === true && UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsFIPS") &&
                        true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://memory-db-fips.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("FIPS and DualStack are enabled, but this partition does not support one or both");
                }
                if (UseFIPS === true) {
                    if (_.getAttr(PartitionResult, "supportsFIPS") === true) {
                        return e(`https://memory-db-fips.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
                    }
                    return err("FIPS is enabled but this partition does not support FIPS");
                }
                if (UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://memory-db.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("DualStack is enabled but this partition does not support DualStack");
                }
                if (Region === "fips") {
                    return e("https://memory-db-fips.us-west-1.amazonaws.com", {
                        authSchemes: [
                            {
                                name: "sigv4",
                                signingName: "memorydb",
                                signingRegion: "us-west-1",
                            },
                        ],
                    }, {});
                }
                return e(`https://memory-db.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const ClusterNameList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const ServiceUpdateRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ServiceUpdateNameToApply: S.optional(S.String) })).annotate({
    identifier: "ServiceUpdateRequest",
});
export const BatchUpdateClusterRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClusterNames: ClusterNameList,
    ServiceUpdate: S.optional(ServiceUpdateRequest),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "BatchUpdateClusterRequest",
});
export const SlotMigration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ProgressPercentage: S.optional(S.Number) })).annotate({ identifier: "SlotMigration" });
export const ReshardingStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ SlotMigration: S.optional(SlotMigration) })).annotate({
    identifier: "ReshardingStatus",
});
export const ACLsUpdateStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ACLToApply: S.optional(S.String) })).annotate({
    identifier: "ACLsUpdateStatus",
});
export const ServiceUpdateStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const PendingModifiedServiceUpdate = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ServiceUpdateName: S.optional(S.String),
    Status: S.optional(ServiceUpdateStatus),
})).annotate({
    identifier: "PendingModifiedServiceUpdate",
});
export const PendingModifiedServiceUpdateList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PendingModifiedServiceUpdate.pipe(T.XmlName("PendingModifiedServiceUpdate")).annotate({ identifier: "PendingModifiedServiceUpdate" }));
export const ClusterPendingUpdates = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Resharding: S.optional(ReshardingStatus),
    ACLs: S.optional(ACLsUpdateStatus),
    ServiceUpdates: S.optional(PendingModifiedServiceUpdateList),
})).annotate({
    identifier: "ClusterPendingUpdates",
});
export const Endpoint = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Address: S.optional(S.String), Port: S.optional(S.Number) })).annotate({ identifier: "Endpoint" });
export const Node = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Status: S.optional(S.String),
    AvailabilityZone: S.optional(S.String),
    CreateTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Endpoint: S.optional(Endpoint),
})).annotate({ identifier: "Node" });
export const NodeList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Node.pipe(T.XmlName("Node")).annotate({ identifier: "Node" }));
export const Shard = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Status: S.optional(S.String),
    Slots: S.optional(S.String),
    Nodes: S.optional(NodeList),
    NumberOfNodes: S.optional(S.Number),
})).annotate({ identifier: "Shard" });
export const ShardList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Shard.pipe(T.XmlName("Shard")).annotate({ identifier: "Shard" }));
export const AZStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const SecurityGroupMembership = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SecurityGroupId: S.optional(S.String),
    Status: S.optional(S.String),
})).annotate({
    identifier: "SecurityGroupMembership",
});
export const SecurityGroupMembershipList = /*@__PURE__*/ /*#__PURE__*/ S.Array(SecurityGroupMembership);
export const DataTieringStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const NetworkType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const IpDiscovery = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Cluster = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Description: S.optional(S.String),
    Status: S.optional(S.String),
    PendingUpdates: S.optional(ClusterPendingUpdates),
    MultiRegionClusterName: S.optional(S.String),
    NumberOfShards: S.optional(S.Number),
    Shards: S.optional(ShardList),
    AvailabilityMode: S.optional(AZStatus),
    ClusterEndpoint: S.optional(Endpoint),
    NodeType: S.optional(S.String),
    Engine: S.optional(S.String),
    EngineVersion: S.optional(S.String),
    EnginePatchVersion: S.optional(S.String),
    ParameterGroupName: S.optional(S.String),
    ParameterGroupStatus: S.optional(S.String),
    SecurityGroups: S.optional(SecurityGroupMembershipList),
    SubnetGroupName: S.optional(S.String),
    TLSEnabled: S.optional(S.Boolean),
    KmsKeyId: S.optional(S.String),
    ARN: S.optional(S.String),
    SnsTopicArn: S.optional(S.String),
    SnsTopicStatus: S.optional(S.String),
    SnapshotRetentionLimit: S.optional(S.Number),
    MaintenanceWindow: S.optional(S.String),
    SnapshotWindow: S.optional(S.String),
    ACLName: S.optional(S.String),
    AutoMinorVersionUpgrade: S.optional(S.Boolean),
    DataTiering: S.optional(DataTieringStatus),
    NetworkType: S.optional(NetworkType),
    IpDiscovery: S.optional(IpDiscovery),
})).annotate({ identifier: "Cluster" });
export const ClusterList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Cluster.pipe(T.XmlName("Cluster")).annotate({ identifier: "Cluster" }));
export const UnprocessedCluster = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClusterName: S.optional(S.String),
    ErrorType: S.optional(S.String),
    ErrorMessage: S.optional(S.String),
})).annotate({
    identifier: "UnprocessedCluster",
});
export const UnprocessedClusterList = /*@__PURE__*/ /*#__PURE__*/ S.Array(UnprocessedCluster.pipe(T.XmlName("UnprocessedCluster")).annotate({
    identifier: "UnprocessedCluster",
}));
export const BatchUpdateClusterResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ProcessedClusters: S.optional(ClusterList),
    UnprocessedClusters: S.optional(UnprocessedClusterList),
}).pipe(ns)).annotate({
    identifier: "BatchUpdateClusterResponse",
});
export const Tag = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Key: S.optional(S.String), Value: S.optional(S.String) })).annotate({ identifier: "Tag" });
export const TagList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Tag.pipe(T.XmlName("Tag")).annotate({ identifier: "Tag" }));
export const CopySnapshotRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SourceSnapshotName: S.String,
    TargetSnapshotName: S.String,
    TargetBucket: S.optional(S.String),
    KmsKeyId: S.optional(S.String),
    Tags: S.optional(TagList),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CopySnapshotRequest",
});
export const ShardConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Slots: S.optional(S.String), ReplicaCount: S.optional(S.Number) })).annotate({
    identifier: "ShardConfiguration",
});
export const ShardDetail = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Configuration: S.optional(ShardConfiguration),
    Size: S.optional(S.String),
    SnapshotCreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({ identifier: "ShardDetail" });
export const ShardDetails = /*@__PURE__*/ /*#__PURE__*/ S.Array(ShardDetail);
export const ClusterConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Description: S.optional(S.String),
    NodeType: S.optional(S.String),
    Engine: S.optional(S.String),
    EngineVersion: S.optional(S.String),
    MaintenanceWindow: S.optional(S.String),
    TopicArn: S.optional(S.String),
    Port: S.optional(S.Number),
    ParameterGroupName: S.optional(S.String),
    SubnetGroupName: S.optional(S.String),
    VpcId: S.optional(S.String),
    SnapshotRetentionLimit: S.optional(S.Number),
    SnapshotWindow: S.optional(S.String),
    NumShards: S.optional(S.Number),
    Shards: S.optional(ShardDetails),
    MultiRegionParameterGroupName: S.optional(S.String),
    MultiRegionClusterName: S.optional(S.String),
})).annotate({
    identifier: "ClusterConfiguration",
});
export const Snapshot = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Status: S.optional(S.String),
    Source: S.optional(S.String),
    KmsKeyId: S.optional(S.String),
    ARN: S.optional(S.String),
    ClusterConfiguration: S.optional(ClusterConfiguration),
    DataTiering: S.optional(DataTieringStatus),
})).annotate({ identifier: "Snapshot" });
export const CopySnapshotResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Snapshot: S.optional(Snapshot) }).pipe(ns)).annotate({
    identifier: "CopySnapshotResponse",
});
export const UserNameListInput = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const CreateACLRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ACLName: S.String,
    UserNames: S.optional(UserNameListInput),
    Tags: S.optional(TagList),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateACLRequest",
});
export const UserNameList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const ACLPendingChanges = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    UserNamesToRemove: S.optional(UserNameList),
    UserNamesToAdd: S.optional(UserNameList),
})).annotate({
    identifier: "ACLPendingChanges",
});
export const ACLClusterNameList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const ACL = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Status: S.optional(S.String),
    UserNames: S.optional(UserNameList),
    MinimumEngineVersion: S.optional(S.String),
    PendingChanges: S.optional(ACLPendingChanges),
    Clusters: S.optional(ACLClusterNameList),
    ARN: S.optional(S.String),
})).annotate({ identifier: "ACL" });
export const CreateACLResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ACL: S.optional(ACL) }).pipe(ns)).annotate({
    identifier: "CreateACLResponse",
});
export const SecurityGroupIdsList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String.pipe(T.XmlName("SecurityGroupId")));
export const SnapshotArnsList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String.pipe(T.XmlName("SnapshotArn")));
export const CreateClusterRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClusterName: S.String,
    NodeType: S.String,
    MultiRegionClusterName: S.optional(S.String),
    ParameterGroupName: S.optional(S.String),
    Description: S.optional(S.String),
    NumShards: S.optional(S.Number),
    NumReplicasPerShard: S.optional(S.Number),
    SubnetGroupName: S.optional(S.String),
    SecurityGroupIds: S.optional(SecurityGroupIdsList),
    MaintenanceWindow: S.optional(S.String),
    Port: S.optional(S.Number),
    SnsTopicArn: S.optional(S.String),
    TLSEnabled: S.optional(S.Boolean),
    KmsKeyId: S.optional(S.String),
    SnapshotArns: S.optional(SnapshotArnsList),
    SnapshotName: S.optional(S.String),
    SnapshotRetentionLimit: S.optional(S.Number),
    Tags: S.optional(TagList),
    SnapshotWindow: S.optional(S.String),
    ACLName: S.String,
    Engine: S.optional(S.String),
    EngineVersion: S.optional(S.String),
    AutoMinorVersionUpgrade: S.optional(S.Boolean),
    DataTiering: S.optional(S.Boolean),
    NetworkType: S.optional(NetworkType),
    IpDiscovery: S.optional(IpDiscovery),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateClusterRequest",
});
export const CreateClusterResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Cluster: S.optional(Cluster) }).pipe(ns)).annotate({
    identifier: "CreateClusterResponse",
});
export const CreateMultiRegionClusterRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MultiRegionClusterNameSuffix: S.String,
    Description: S.optional(S.String),
    Engine: S.optional(S.String),
    EngineVersion: S.optional(S.String),
    NodeType: S.String,
    MultiRegionParameterGroupName: S.optional(S.String),
    NumShards: S.optional(S.Number),
    TLSEnabled: S.optional(S.Boolean),
    Tags: S.optional(TagList),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateMultiRegionClusterRequest",
});
export const RegionalCluster = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClusterName: S.optional(S.String),
    Region: S.optional(S.String),
    Status: S.optional(S.String),
    ARN: S.optional(S.String),
})).annotate({
    identifier: "RegionalCluster",
});
export const RegionalClusterList = /*@__PURE__*/ /*#__PURE__*/ S.Array(RegionalCluster.pipe(T.XmlName("RegionalCluster")).annotate({
    identifier: "RegionalCluster",
}));
export const MultiRegionCluster = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MultiRegionClusterName: S.optional(S.String),
    Description: S.optional(S.String),
    Status: S.optional(S.String),
    NodeType: S.optional(S.String),
    Engine: S.optional(S.String),
    EngineVersion: S.optional(S.String),
    NumberOfShards: S.optional(S.Number),
    Clusters: S.optional(RegionalClusterList),
    MultiRegionParameterGroupName: S.optional(S.String),
    TLSEnabled: S.optional(S.Boolean),
    ARN: S.optional(S.String),
})).annotate({
    identifier: "MultiRegionCluster",
});
export const CreateMultiRegionClusterResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ MultiRegionCluster: S.optional(MultiRegionCluster) }).pipe(ns)).annotate({
    identifier: "CreateMultiRegionClusterResponse",
});
export const CreateParameterGroupRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ParameterGroupName: S.String,
    Family: S.String,
    Description: S.optional(S.String),
    Tags: S.optional(TagList),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateParameterGroupRequest",
});
export const ParameterGroup = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Family: S.optional(S.String),
    Description: S.optional(S.String),
    ARN: S.optional(S.String),
})).annotate({ identifier: "ParameterGroup" });
export const CreateParameterGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ParameterGroup: S.optional(ParameterGroup) }).pipe(ns)).annotate({
    identifier: "CreateParameterGroupResponse",
});
export const CreateSnapshotRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClusterName: S.String,
    SnapshotName: S.String,
    KmsKeyId: S.optional(S.String),
    Tags: S.optional(TagList),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateSnapshotRequest",
});
export const CreateSnapshotResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Snapshot: S.optional(Snapshot) }).pipe(ns)).annotate({
    identifier: "CreateSnapshotResponse",
});
export const SubnetIdentifierList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String.pipe(T.XmlName("SubnetIdentifier")));
export const CreateSubnetGroupRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SubnetGroupName: S.String,
    Description: S.optional(S.String),
    SubnetIds: SubnetIdentifierList,
    Tags: S.optional(TagList),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateSubnetGroupRequest",
});
export const AvailabilityZone = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.optional(S.String) })).annotate({
    identifier: "AvailabilityZone",
});
export const NetworkTypeList = /*@__PURE__*/ /*#__PURE__*/ S.Array(NetworkType);
export const Subnet = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Identifier: S.optional(S.String),
    AvailabilityZone: S.optional(AvailabilityZone),
    SupportedNetworkTypes: S.optional(NetworkTypeList),
})).annotate({ identifier: "Subnet" });
export const SubnetList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Subnet.pipe(T.XmlName("Subnet")).annotate({ identifier: "Subnet" }));
export const SubnetGroup = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Description: S.optional(S.String),
    VpcId: S.optional(S.String),
    Subnets: S.optional(SubnetList),
    ARN: S.optional(S.String),
    SupportedNetworkTypes: S.optional(NetworkTypeList),
})).annotate({ identifier: "SubnetGroup" });
export const CreateSubnetGroupResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ SubnetGroup: S.optional(SubnetGroup) }).pipe(ns)).annotate({
    identifier: "CreateSubnetGroupResponse",
});
export const InputAuthenticationType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const PasswordListInput = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const AuthenticationMode = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Type: S.optional(InputAuthenticationType),
    Passwords: S.optional(PasswordListInput),
})).annotate({
    identifier: "AuthenticationMode",
});
export const CreateUserRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    UserName: S.String,
    AuthenticationMode: AuthenticationMode,
    AccessString: S.String,
    Tags: S.optional(TagList),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateUserRequest",
});
export const ACLNameList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const AuthenticationType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Authentication = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Type: S.optional(AuthenticationType),
    PasswordCount: S.optional(S.Number),
})).annotate({ identifier: "Authentication" });
export const User = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Status: S.optional(S.String),
    AccessString: S.optional(S.String),
    ACLNames: S.optional(ACLNameList),
    MinimumEngineVersion: S.optional(S.String),
    Authentication: S.optional(Authentication),
    ARN: S.optional(S.String),
})).annotate({ identifier: "User" });
export const CreateUserResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ User: S.optional(User) }).pipe(ns)).annotate({
    identifier: "CreateUserResponse",
});
export const DeleteACLRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ACLName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteACLRequest",
});
export const DeleteACLResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ACL: S.optional(ACL) }).pipe(ns)).annotate({
    identifier: "DeleteACLResponse",
});
export const DeleteClusterRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClusterName: S.String,
    MultiRegionClusterName: S.optional(S.String),
    FinalSnapshotName: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteClusterRequest",
});
export const DeleteClusterResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Cluster: S.optional(Cluster) }).pipe(ns)).annotate({
    identifier: "DeleteClusterResponse",
});
export const DeleteMultiRegionClusterRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ MultiRegionClusterName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteMultiRegionClusterRequest",
});
export const DeleteMultiRegionClusterResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ MultiRegionCluster: S.optional(MultiRegionCluster) }).pipe(ns)).annotate({
    identifier: "DeleteMultiRegionClusterResponse",
});
export const DeleteParameterGroupRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ParameterGroupName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteParameterGroupRequest",
});
export const DeleteParameterGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ParameterGroup: S.optional(ParameterGroup) }).pipe(ns)).annotate({
    identifier: "DeleteParameterGroupResponse",
});
export const DeleteSnapshotRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ SnapshotName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteSnapshotRequest",
});
export const DeleteSnapshotResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Snapshot: S.optional(Snapshot) }).pipe(ns)).annotate({
    identifier: "DeleteSnapshotResponse",
});
export const DeleteSubnetGroupRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ SubnetGroupName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteSubnetGroupRequest",
});
export const DeleteSubnetGroupResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ SubnetGroup: S.optional(SubnetGroup) }).pipe(ns)).annotate({
    identifier: "DeleteSubnetGroupResponse",
});
export const DeleteUserRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ UserName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteUserRequest",
});
export const DeleteUserResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ User: S.optional(User) }).pipe(ns)).annotate({
    identifier: "DeleteUserResponse",
});
export const DescribeACLsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ACLName: S.optional(S.String),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeACLsRequest",
});
export const ACLList = /*@__PURE__*/ /*#__PURE__*/ S.Array(ACL);
export const DescribeACLsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ACLs: S.optional(ACLList), NextToken: S.optional(S.String) }).pipe(ns)).annotate({
    identifier: "DescribeACLsResponse",
});
export const DescribeClustersRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClusterName: S.optional(S.String),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
    ShowShardDetails: S.optional(S.Boolean),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeClustersRequest",
});
export const DescribeClustersResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    Clusters: S.optional(ClusterList),
}).pipe(ns)).annotate({
    identifier: "DescribeClustersResponse",
});
export const DescribeEngineVersionsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Engine: S.optional(S.String),
    EngineVersion: S.optional(S.String),
    ParameterGroupFamily: S.optional(S.String),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
    DefaultOnly: S.optional(S.Boolean),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeEngineVersionsRequest",
});
export const EngineVersionInfo = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Engine: S.optional(S.String),
    EngineVersion: S.optional(S.String),
    EnginePatchVersion: S.optional(S.String),
    ParameterGroupFamily: S.optional(S.String),
})).annotate({
    identifier: "EngineVersionInfo",
});
export const EngineVersionInfoList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(EngineVersionInfo);
export const DescribeEngineVersionsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    EngineVersions: S.optional(EngineVersionInfoList),
}).pipe(ns)).annotate({
    identifier: "DescribeEngineVersionsResponse",
});
export const SourceType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DescribeEventsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SourceName: S.optional(S.String),
    SourceType: S.optional(SourceType),
    StartTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    EndTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Duration: S.optional(S.Number),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeEventsRequest",
});
export const Event = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SourceName: S.optional(S.String),
    SourceType: S.optional(SourceType),
    Message: S.optional(S.String),
    Date: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({ identifier: "Event" });
export const EventList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Event.pipe(T.XmlName("Event")).annotate({ identifier: "Event" }));
export const DescribeEventsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    Events: S.optional(EventList),
}).pipe(ns)).annotate({
    identifier: "DescribeEventsResponse",
});
export const DescribeMultiRegionClustersRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MultiRegionClusterName: S.optional(S.String),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
    ShowClusterDetails: S.optional(S.Boolean),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeMultiRegionClustersRequest",
});
export const MultiRegionClusterList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(MultiRegionCluster);
export const DescribeMultiRegionClustersResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    MultiRegionClusters: S.optional(MultiRegionClusterList),
}).pipe(ns)).annotate({
    identifier: "DescribeMultiRegionClustersResponse",
});
export const DescribeMultiRegionParameterGroupsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MultiRegionParameterGroupName: S.optional(S.String),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeMultiRegionParameterGroupsRequest",
});
export const MultiRegionParameterGroup = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Family: S.optional(S.String),
    Description: S.optional(S.String),
    ARN: S.optional(S.String),
})).annotate({
    identifier: "MultiRegionParameterGroup",
});
export const MultiRegionParameterGroupList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(MultiRegionParameterGroup.pipe(T.XmlName("MultiRegionParameterGroup")).annotate({ identifier: "MultiRegionParameterGroup" }));
export const DescribeMultiRegionParameterGroupsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    MultiRegionParameterGroups: S.optional(MultiRegionParameterGroupList),
}).pipe(ns)).annotate({
    identifier: "DescribeMultiRegionParameterGroupsResponse",
});
export const DescribeMultiRegionParametersRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MultiRegionParameterGroupName: S.String,
    Source: S.optional(S.String),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeMultiRegionParametersRequest",
});
export const MultiRegionParameter = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Value: S.optional(S.String),
    Description: S.optional(S.String),
    Source: S.optional(S.String),
    DataType: S.optional(S.String),
    AllowedValues: S.optional(S.String),
    MinimumEngineVersion: S.optional(S.String),
})).annotate({
    identifier: "MultiRegionParameter",
});
export const MultiRegionParametersList = /*@__PURE__*/ /*#__PURE__*/ S.Array(MultiRegionParameter.pipe(T.XmlName("MultiRegionParameter")).annotate({
    identifier: "MultiRegionParameter",
}));
export const DescribeMultiRegionParametersResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    MultiRegionParameters: S.optional(MultiRegionParametersList),
}).pipe(ns)).annotate({
    identifier: "DescribeMultiRegionParametersResponse",
});
export const DescribeParameterGroupsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ParameterGroupName: S.optional(S.String),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeParameterGroupsRequest",
});
export const ParameterGroupList = /*@__PURE__*/ /*#__PURE__*/ S.Array(ParameterGroup.pipe(T.XmlName("ParameterGroup")).annotate({
    identifier: "ParameterGroup",
}));
export const DescribeParameterGroupsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    ParameterGroups: S.optional(ParameterGroupList),
}).pipe(ns)).annotate({
    identifier: "DescribeParameterGroupsResponse",
});
export const DescribeParametersRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ParameterGroupName: S.String,
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeParametersRequest",
});
export const Parameter = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Value: S.optional(S.String),
    Description: S.optional(S.String),
    DataType: S.optional(S.String),
    AllowedValues: S.optional(S.String),
    MinimumEngineVersion: S.optional(S.String),
})).annotate({ identifier: "Parameter" });
export const ParametersList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Parameter.pipe(T.XmlName("Parameter")).annotate({ identifier: "Parameter" }));
export const DescribeParametersResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    Parameters: S.optional(ParametersList),
}).pipe(ns)).annotate({
    identifier: "DescribeParametersResponse",
});
export const DescribeReservedNodesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReservationId: S.optional(S.String),
    ReservedNodesOfferingId: S.optional(S.String),
    NodeType: S.optional(S.String),
    Duration: S.optional(S.String),
    OfferingType: S.optional(S.String),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeReservedNodesRequest",
});
export const RecurringCharge = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    RecurringChargeAmount: S.optional(S.Number),
    RecurringChargeFrequency: S.optional(S.String),
})).annotate({
    identifier: "RecurringCharge",
});
export const RecurringChargeList = /*@__PURE__*/ /*#__PURE__*/ S.Array(RecurringCharge.pipe(T.XmlName("RecurringCharge")).annotate({
    identifier: "RecurringCharge",
}));
export const ReservedNode = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReservationId: S.optional(S.String),
    ReservedNodesOfferingId: S.optional(S.String),
    NodeType: S.optional(S.String),
    StartTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Duration: S.optional(S.Number),
    FixedPrice: S.optional(S.Number),
    NodeCount: S.optional(S.Number),
    OfferingType: S.optional(S.String),
    State: S.optional(S.String),
    RecurringCharges: S.optional(RecurringChargeList),
    ARN: S.optional(S.String),
})).annotate({ identifier: "ReservedNode" });
export const ReservedNodeList = /*@__PURE__*/ /*#__PURE__*/ S.Array(ReservedNode.pipe(T.XmlName("ReservedNode")).annotate({
    identifier: "ReservedNode",
}));
export const DescribeReservedNodesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    ReservedNodes: S.optional(ReservedNodeList),
}).pipe(ns)).annotate({
    identifier: "DescribeReservedNodesResponse",
});
export const DescribeReservedNodesOfferingsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReservedNodesOfferingId: S.optional(S.String),
    NodeType: S.optional(S.String),
    Duration: S.optional(S.String),
    OfferingType: S.optional(S.String),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeReservedNodesOfferingsRequest",
});
export const ReservedNodesOffering = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReservedNodesOfferingId: S.optional(S.String),
    NodeType: S.optional(S.String),
    Duration: S.optional(S.Number),
    FixedPrice: S.optional(S.Number),
    OfferingType: S.optional(S.String),
    RecurringCharges: S.optional(RecurringChargeList),
})).annotate({
    identifier: "ReservedNodesOffering",
});
export const ReservedNodesOfferingList = /*@__PURE__*/ /*#__PURE__*/ S.Array(ReservedNodesOffering.pipe(T.XmlName("ReservedNodesOffering")).annotate({
    identifier: "ReservedNodesOffering",
}));
export const DescribeReservedNodesOfferingsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    ReservedNodesOfferings: S.optional(ReservedNodesOfferingList),
}).pipe(ns)).annotate({
    identifier: "DescribeReservedNodesOfferingsResponse",
});
export const ServiceUpdateStatusList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ServiceUpdateStatus);
export const DescribeServiceUpdatesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ServiceUpdateName: S.optional(S.String),
    ClusterNames: S.optional(ClusterNameList),
    Status: S.optional(ServiceUpdateStatusList),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeServiceUpdatesRequest",
});
export const ServiceUpdateType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ServiceUpdate = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClusterName: S.optional(S.String),
    ServiceUpdateName: S.optional(S.String),
    ReleaseDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Description: S.optional(S.String),
    Status: S.optional(ServiceUpdateStatus),
    Type: S.optional(ServiceUpdateType),
    Engine: S.optional(S.String),
    NodesUpdated: S.optional(S.String),
    AutoUpdateStartDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({ identifier: "ServiceUpdate" });
export const ServiceUpdateList = /*@__PURE__*/ /*#__PURE__*/ S.Array(ServiceUpdate.pipe(T.XmlName("ServiceUpdate")).annotate({
    identifier: "ServiceUpdate",
}));
export const DescribeServiceUpdatesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    ServiceUpdates: S.optional(ServiceUpdateList),
}).pipe(ns)).annotate({
    identifier: "DescribeServiceUpdatesResponse",
});
export const DescribeSnapshotsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClusterName: S.optional(S.String),
    SnapshotName: S.optional(S.String),
    Source: S.optional(S.String),
    NextToken: S.optional(S.String),
    MaxResults: S.optional(S.Number),
    ShowDetail: S.optional(S.Boolean),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeSnapshotsRequest",
});
export const SnapshotList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Snapshot);
export const DescribeSnapshotsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    Snapshots: S.optional(SnapshotList),
}).pipe(ns)).annotate({
    identifier: "DescribeSnapshotsResponse",
});
export const DescribeSubnetGroupsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SubnetGroupName: S.optional(S.String),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeSubnetGroupsRequest",
});
export const SubnetGroupList = /*@__PURE__*/ /*#__PURE__*/ S.Array(SubnetGroup);
export const DescribeSubnetGroupsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    SubnetGroups: S.optional(SubnetGroupList),
}).pipe(ns)).annotate({
    identifier: "DescribeSubnetGroupsResponse",
});
export const FilterValueList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const Filter = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String, Values: FilterValueList })).annotate({ identifier: "Filter" });
export const FilterList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Filter);
export const DescribeUsersRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    UserName: S.optional(S.String),
    Filters: S.optional(FilterList),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeUsersRequest",
});
export const UserList = /*@__PURE__*/ /*#__PURE__*/ S.Array(User);
export const DescribeUsersResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Users: S.optional(UserList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "DescribeUsersResponse",
});
export const FailoverShardRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ClusterName: S.String, ShardName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "FailoverShardRequest",
});
export const FailoverShardResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Cluster: S.optional(Cluster) }).pipe(ns)).annotate({
    identifier: "FailoverShardResponse",
});
export const ListAllowedMultiRegionClusterUpdatesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ MultiRegionClusterName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListAllowedMultiRegionClusterUpdatesRequest",
});
export const NodeTypeList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const ListAllowedMultiRegionClusterUpdatesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ScaleUpNodeTypes: S.optional(NodeTypeList),
    ScaleDownNodeTypes: S.optional(NodeTypeList),
}).pipe(ns)).annotate({
    identifier: "ListAllowedMultiRegionClusterUpdatesResponse",
});
export const ListAllowedNodeTypeUpdatesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ClusterName: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListAllowedNodeTypeUpdatesRequest",
});
export const ListAllowedNodeTypeUpdatesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ScaleUpNodeTypes: S.optional(NodeTypeList),
    ScaleDownNodeTypes: S.optional(NodeTypeList),
}).pipe(ns)).annotate({
    identifier: "ListAllowedNodeTypeUpdatesResponse",
});
export const ListTagsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ResourceArn: S.String }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListTagsRequest",
});
export const ListTagsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ TagList: S.optional(TagList) }).pipe(ns)).annotate({
    identifier: "ListTagsResponse",
});
export const PurchaseReservedNodesOfferingRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReservedNodesOfferingId: S.String,
    ReservationId: S.optional(S.String),
    NodeCount: S.optional(S.Number),
    Tags: S.optional(TagList),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "PurchaseReservedNodesOfferingRequest",
});
export const PurchaseReservedNodesOfferingResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ReservedNode: S.optional(ReservedNode) }).pipe(ns)).annotate({
    identifier: "PurchaseReservedNodesOfferingResponse",
});
export const ParameterNameList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const ResetParameterGroupRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ParameterGroupName: S.String,
    AllParameters: S.optional(S.Boolean),
    ParameterNames: S.optional(ParameterNameList),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ResetParameterGroupRequest",
});
export const ResetParameterGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ParameterGroup: S.optional(ParameterGroup) }).pipe(ns)).annotate({
    identifier: "ResetParameterGroupResponse",
});
export const TagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ResourceArn: S.String, Tags: TagList }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "TagResourceRequest",
});
export const TagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ TagList: S.optional(TagList) }).pipe(ns)).annotate({
    identifier: "TagResourceResponse",
});
export const KeyList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const UntagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ResourceArn: S.String, TagKeys: KeyList }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UntagResourceRequest",
});
export const UntagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ TagList: S.optional(TagList) }).pipe(ns)).annotate({
    identifier: "UntagResourceResponse",
});
export const UpdateACLRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ACLName: S.String,
    UserNamesToAdd: S.optional(UserNameListInput),
    UserNamesToRemove: S.optional(UserNameListInput),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateACLRequest",
});
export const UpdateACLResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ACL: S.optional(ACL) }).pipe(ns)).annotate({
    identifier: "UpdateACLResponse",
});
export const ReplicaConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ReplicaCount: S.optional(S.Number) })).annotate({
    identifier: "ReplicaConfigurationRequest",
});
export const ShardConfigurationRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ShardCount: S.optional(S.Number) })).annotate({
    identifier: "ShardConfigurationRequest",
});
export const UpdateClusterRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ClusterName: S.String,
    Description: S.optional(S.String),
    SecurityGroupIds: S.optional(SecurityGroupIdsList),
    MaintenanceWindow: S.optional(S.String),
    SnsTopicArn: S.optional(S.String),
    SnsTopicStatus: S.optional(S.String),
    ParameterGroupName: S.optional(S.String),
    SnapshotWindow: S.optional(S.String),
    SnapshotRetentionLimit: S.optional(S.Number),
    NodeType: S.optional(S.String),
    Engine: S.optional(S.String),
    EngineVersion: S.optional(S.String),
    ReplicaConfiguration: S.optional(ReplicaConfigurationRequest),
    ShardConfiguration: S.optional(ShardConfigurationRequest),
    ACLName: S.optional(S.String),
    IpDiscovery: S.optional(IpDiscovery),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateClusterRequest",
});
export const UpdateClusterResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Cluster: S.optional(Cluster) }).pipe(ns)).annotate({
    identifier: "UpdateClusterResponse",
});
export const UpdateStrategy = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const UpdateMultiRegionClusterRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MultiRegionClusterName: S.String,
    NodeType: S.optional(S.String),
    Description: S.optional(S.String),
    EngineVersion: S.optional(S.String),
    ShardConfiguration: S.optional(ShardConfigurationRequest),
    MultiRegionParameterGroupName: S.optional(S.String),
    UpdateStrategy: S.optional(UpdateStrategy),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateMultiRegionClusterRequest",
});
export const UpdateMultiRegionClusterResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ MultiRegionCluster: S.optional(MultiRegionCluster) }).pipe(ns)).annotate({
    identifier: "UpdateMultiRegionClusterResponse",
});
export const ParameterNameValue = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ParameterName: S.optional(S.String),
    ParameterValue: S.optional(S.String),
})).annotate({
    identifier: "ParameterNameValue",
});
export const ParameterNameValueList = /*@__PURE__*/ /*#__PURE__*/ S.Array(ParameterNameValue.pipe(T.XmlName("ParameterNameValue")).annotate({
    identifier: "ParameterNameValue",
}));
export const UpdateParameterGroupRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ParameterGroupName: S.String,
    ParameterNameValues: ParameterNameValueList,
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateParameterGroupRequest",
});
export const UpdateParameterGroupResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ParameterGroup: S.optional(ParameterGroup) }).pipe(ns)).annotate({
    identifier: "UpdateParameterGroupResponse",
});
export const UpdateSubnetGroupRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SubnetGroupName: S.String,
    Description: S.optional(S.String),
    SubnetIds: S.optional(SubnetIdentifierList),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateSubnetGroupRequest",
});
export const UpdateSubnetGroupResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ SubnetGroup: S.optional(SubnetGroup) }).pipe(ns)).annotate({
    identifier: "UpdateSubnetGroupResponse",
});
export const UpdateUserRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    UserName: S.String,
    AuthenticationMode: S.optional(AuthenticationMode),
    AccessString: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateUserRequest",
});
export const UpdateUserResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ User: S.optional(User) }).pipe(ns)).annotate({
    identifier: "UpdateUserResponse",
});
//# Errors
export class InvalidParameterValueException extends S.TaggedErrorClass()("InvalidParameterValueException", { message: S.optional(S.String) }, T.AwsQueryError({ code: "InvalidParameterValue", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class ServiceUpdateNotFoundFault extends S.TaggedErrorClass()("ServiceUpdateNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "ServiceUpdateNotFoundFault",
    httpResponseCode: 404,
})).pipe(C.withBadRequestError) {
}
export class InvalidParameterCombinationException extends S.TaggedErrorClass()("InvalidParameterCombinationException", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "InvalidParameterCombination",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class InvalidSnapshotStateFault extends S.TaggedErrorClass()("InvalidSnapshotStateFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "InvalidSnapshotState", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class ServiceLinkedRoleNotFoundFault extends S.TaggedErrorClass()("ServiceLinkedRoleNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "ServiceLinkedRoleNotFoundFault",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class SnapshotAlreadyExistsFault extends S.TaggedErrorClass()("SnapshotAlreadyExistsFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "SnapshotAlreadyExistsFault",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError, C.withAlreadyExistsError) {
}
export class SnapshotNotFoundFault extends S.TaggedErrorClass()("SnapshotNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "SnapshotNotFoundFault", httpResponseCode: 404 })).pipe(C.withBadRequestError) {
}
export class SnapshotQuotaExceededFault extends S.TaggedErrorClass()("SnapshotQuotaExceededFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "SnapshotQuotaExceededFault",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class TagQuotaPerResourceExceeded extends S.TaggedErrorClass()("TagQuotaPerResourceExceeded", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "TagQuotaPerResourceExceeded",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class ACLAlreadyExistsFault extends S.TaggedErrorClass()("ACLAlreadyExistsFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "ACLAlreadyExists", httpResponseCode: 400 })).pipe(C.withBadRequestError, C.withAlreadyExistsError) {
}
export class ACLQuotaExceededFault extends S.TaggedErrorClass()("ACLQuotaExceededFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "ACLQuotaExceeded", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class DefaultUserRequired extends S.TaggedErrorClass()("DefaultUserRequired", { message: S.optional(S.String) }, T.AwsQueryError({ code: "DefaultUserRequired", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class DuplicateUserNameFault extends S.TaggedErrorClass()("DuplicateUserNameFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "DuplicateUserName", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class UserNotFoundFault extends S.TaggedErrorClass()("UserNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "UserNotFound", httpResponseCode: 404 })).pipe(C.withBadRequestError) {
}
export class ACLNotFoundFault extends S.TaggedErrorClass()("ACLNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "ACLNotFound", httpResponseCode: 404 })).pipe(C.withBadRequestError) {
}
export class ClusterAlreadyExistsFault extends S.TaggedErrorClass()("ClusterAlreadyExistsFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "ClusterAlreadyExists", httpResponseCode: 400 })).pipe(C.withBadRequestError, C.withAlreadyExistsError) {
}
export class ClusterQuotaForCustomerExceededFault extends S.TaggedErrorClass()("ClusterQuotaForCustomerExceededFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "ClusterQuotaForCustomerExceeded",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class InsufficientClusterCapacityFault extends S.TaggedErrorClass()("InsufficientClusterCapacityFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "InsufficientClusterCapacity",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class InvalidACLStateFault extends S.TaggedErrorClass()("InvalidACLStateFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "InvalidACLState", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class InvalidCredentialsException extends S.TaggedErrorClass()("InvalidCredentialsException", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "InvalidCredentialsException",
    httpResponseCode: 408,
})).pipe(C.withTimeoutError) {
}
export class InvalidMultiRegionClusterStateFault extends S.TaggedErrorClass()("InvalidMultiRegionClusterStateFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "InvalidMultiRegionClusterState",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class InvalidVPCNetworkStateFault extends S.TaggedErrorClass()("InvalidVPCNetworkStateFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "InvalidVPCNetworkStateFault",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class MultiRegionClusterNotFoundFault extends S.TaggedErrorClass()("MultiRegionClusterNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "MultiRegionClusterNotFound",
    httpResponseCode: 404,
})).pipe(C.withBadRequestError) {
}
export class NodeQuotaForClusterExceededFault extends S.TaggedErrorClass()("NodeQuotaForClusterExceededFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "NodeQuotaForClusterExceeded",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class NodeQuotaForCustomerExceededFault extends S.TaggedErrorClass()("NodeQuotaForCustomerExceededFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "NodeQuotaForCustomerExceeded",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class ParameterGroupNotFoundFault extends S.TaggedErrorClass()("ParameterGroupNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "ParameterGroupNotFound", httpResponseCode: 404 })).pipe(C.withBadRequestError) {
}
export class ShardsPerClusterQuotaExceededFault extends S.TaggedErrorClass()("ShardsPerClusterQuotaExceededFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "ShardsPerClusterQuotaExceeded",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class SubnetGroupNotFoundFault extends S.TaggedErrorClass()("SubnetGroupNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "SubnetGroupNotFoundFault", httpResponseCode: 404 })).pipe(C.withBadRequestError) {
}
export class MultiRegionClusterAlreadyExistsFault extends S.TaggedErrorClass()("MultiRegionClusterAlreadyExistsFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "MultiRegionClusterAlreadyExistsFault",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError, C.withAlreadyExistsError) {
}
export class MultiRegionParameterGroupNotFoundFault extends S.TaggedErrorClass()("MultiRegionParameterGroupNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "MultiRegionParameterGroupNotFoundFault",
    httpResponseCode: 404,
})).pipe(C.withBadRequestError) {
}
export class InvalidParameterGroupStateFault extends S.TaggedErrorClass()("InvalidParameterGroupStateFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "InvalidParameterGroupState",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class ParameterGroupAlreadyExistsFault extends S.TaggedErrorClass()("ParameterGroupAlreadyExistsFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "ParameterGroupAlreadyExists",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError, C.withAlreadyExistsError) {
}
export class ParameterGroupQuotaExceededFault extends S.TaggedErrorClass()("ParameterGroupQuotaExceededFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "ParameterGroupQuotaExceeded",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class ClusterNotFoundFault extends S.TaggedErrorClass()("ClusterNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "ClusterNotFound", httpResponseCode: 404 })).pipe(C.withBadRequestError) {
}
export class InvalidClusterStateFault extends S.TaggedErrorClass()("InvalidClusterStateFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "InvalidClusterState", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class InvalidSubnet extends S.TaggedErrorClass()("InvalidSubnet", { message: S.optional(S.String) }, T.AwsQueryError({ code: "InvalidSubnet", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class SubnetGroupAlreadyExistsFault extends S.TaggedErrorClass()("SubnetGroupAlreadyExistsFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "SubnetGroupAlreadyExists", httpResponseCode: 400 })).pipe(C.withBadRequestError, C.withAlreadyExistsError) {
}
export class SubnetGroupQuotaExceededFault extends S.TaggedErrorClass()("SubnetGroupQuotaExceededFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "SubnetGroupQuotaExceeded", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class SubnetNotAllowedFault extends S.TaggedErrorClass()("SubnetNotAllowedFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "SubnetNotAllowedFault", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class SubnetQuotaExceededFault extends S.TaggedErrorClass()("SubnetQuotaExceededFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "SubnetQuotaExceededFault", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class UserAlreadyExistsFault extends S.TaggedErrorClass()("UserAlreadyExistsFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "UserAlreadyExists", httpResponseCode: 400 })).pipe(C.withBadRequestError, C.withAlreadyExistsError) {
}
export class UserQuotaExceededFault extends S.TaggedErrorClass()("UserQuotaExceededFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "UserQuotaExceeded", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class SubnetGroupInUseFault extends S.TaggedErrorClass()("SubnetGroupInUseFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "SubnetGroupInUse", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class InvalidUserStateFault extends S.TaggedErrorClass()("InvalidUserStateFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "InvalidUserState", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class ReservedNodeNotFoundFault extends S.TaggedErrorClass()("ReservedNodeNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "ReservedNodeNotFound", httpResponseCode: 404 })).pipe(C.withBadRequestError) {
}
export class ReservedNodesOfferingNotFoundFault extends S.TaggedErrorClass()("ReservedNodesOfferingNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "ReservedNodesOfferingNotFound",
    httpResponseCode: 404,
})).pipe(C.withBadRequestError) {
}
export class APICallRateForCustomerExceededFault extends S.TaggedErrorClass()("APICallRateForCustomerExceededFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "APICallRateForCustomerExceeded",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class InvalidKMSKeyFault extends S.TaggedErrorClass()("InvalidKMSKeyFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "InvalidKMSKeyFault", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class ShardNotFoundFault extends S.TaggedErrorClass()("ShardNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "ShardNotFoundFault", httpResponseCode: 404 })).pipe(C.withBadRequestError) {
}
export class TestFailoverNotAvailableFault extends S.TaggedErrorClass()("TestFailoverNotAvailableFault", { message: S.optional(S.String) }, T.AwsQueryError({
    code: "TestFailoverNotAvailableFault",
    httpResponseCode: 400,
})).pipe(C.withBadRequestError) {
}
export class InvalidARNFault extends S.TaggedErrorClass()("InvalidARNFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "InvalidARN", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class ReservedNodeAlreadyExistsFault extends S.TaggedErrorClass()("ReservedNodeAlreadyExistsFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "ReservedNodeAlreadyExists", httpResponseCode: 404 })).pipe(C.withBadRequestError, C.withAlreadyExistsError) {
}
export class ReservedNodeQuotaExceededFault extends S.TaggedErrorClass()("ReservedNodeQuotaExceededFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "ReservedNodeQuotaExceeded", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class TagNotFoundFault extends S.TaggedErrorClass()("TagNotFoundFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "TagNotFound", httpResponseCode: 404 })).pipe(C.withBadRequestError) {
}
export class InvalidNodeStateFault extends S.TaggedErrorClass()("InvalidNodeStateFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "InvalidNodeState", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class NoOperationFault extends S.TaggedErrorClass()("NoOperationFault", { message: S.optional(S.String) }, T.AwsQueryError({ code: "NoOperationFault", httpResponseCode: 400 })).pipe(C.withBadRequestError) {
}
export class SubnetInUse extends S.TaggedErrorClass()("SubnetInUse", { message: S.optional(S.String) }, T.AwsQueryError({ code: "SubnetInUse", httpResponseCode: 400 })).pipe(C.withBadRequestError, C.withDependencyViolationError) {
}
/**
 * Apply the service update to a list of clusters supplied. For more information on service updates and applying them, see Applying the service updates.
 */
export const batchUpdateCluster = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: BatchUpdateClusterRequest,
    output: BatchUpdateClusterResponse,
    errors: [InvalidParameterValueException, ServiceUpdateNotFoundFault],
}));
/**
 * Makes a copy of an existing snapshot.
 */
export const copySnapshot = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CopySnapshotRequest,
    output: CopySnapshotResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        InvalidSnapshotStateFault,
        ServiceLinkedRoleNotFoundFault,
        SnapshotAlreadyExistsFault,
        SnapshotNotFoundFault,
        SnapshotQuotaExceededFault,
        TagQuotaPerResourceExceeded,
    ],
}));
/**
 * Creates an Access Control List. For more information, see Authenticating users with Access Contol Lists (ACLs).
 */
export const createACL = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateACLRequest,
    output: CreateACLResponse,
    errors: [
        ACLAlreadyExistsFault,
        ACLQuotaExceededFault,
        DefaultUserRequired,
        DuplicateUserNameFault,
        InvalidParameterValueException,
        TagQuotaPerResourceExceeded,
        UserNotFoundFault,
    ],
}));
/**
 * Creates a cluster. All nodes in the cluster run the same protocol-compliant engine software.
 */
export const createCluster = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateClusterRequest,
    output: CreateClusterResponse,
    errors: [
        ACLNotFoundFault,
        ClusterAlreadyExistsFault,
        ClusterQuotaForCustomerExceededFault,
        InsufficientClusterCapacityFault,
        InvalidACLStateFault,
        InvalidCredentialsException,
        InvalidMultiRegionClusterStateFault,
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        InvalidVPCNetworkStateFault,
        MultiRegionClusterNotFoundFault,
        NodeQuotaForClusterExceededFault,
        NodeQuotaForCustomerExceededFault,
        ParameterGroupNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
        ShardsPerClusterQuotaExceededFault,
        SubnetGroupNotFoundFault,
        TagQuotaPerResourceExceeded,
    ],
}));
/**
 * Creates a new multi-Region cluster.
 */
export const createMultiRegionCluster = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateMultiRegionClusterRequest,
    output: CreateMultiRegionClusterResponse,
    errors: [
        ClusterQuotaForCustomerExceededFault,
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        MultiRegionClusterAlreadyExistsFault,
        MultiRegionParameterGroupNotFoundFault,
        TagQuotaPerResourceExceeded,
    ],
}));
/**
 * Creates a new MemoryDB parameter group. A parameter group is a collection of parameters and their values that are applied to all of the nodes in any cluster. For
 * more information, see Configuring engine parameters using parameter groups.
 */
export const createParameterGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateParameterGroupRequest,
    output: CreateParameterGroupResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterGroupStateFault,
        InvalidParameterValueException,
        ParameterGroupAlreadyExistsFault,
        ParameterGroupQuotaExceededFault,
        ServiceLinkedRoleNotFoundFault,
        TagQuotaPerResourceExceeded,
    ],
}));
/**
 * Creates a copy of an entire cluster at a specific moment in time.
 */
export const createSnapshot = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateSnapshotRequest,
    output: CreateSnapshotResponse,
    errors: [
        ClusterNotFoundFault,
        InvalidClusterStateFault,
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        ServiceLinkedRoleNotFoundFault,
        SnapshotAlreadyExistsFault,
        SnapshotQuotaExceededFault,
        TagQuotaPerResourceExceeded,
    ],
}));
/**
 * Creates a subnet group. A subnet group is a collection of subnets (typically private) that you can designate for your clusters running in an Amazon Virtual Private Cloud (VPC) environment.
 *
 * When you create a cluster in an Amazon VPC, you must specify a subnet group. MemoryDB uses that subnet group to choose a subnet and IP addresses within that subnet to associate with your nodes.
 * For more information, see Subnets and subnet groups.
 */
export const createSubnetGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateSubnetGroupRequest,
    output: CreateSubnetGroupResponse,
    errors: [
        InvalidSubnet,
        ServiceLinkedRoleNotFoundFault,
        SubnetGroupAlreadyExistsFault,
        SubnetGroupQuotaExceededFault,
        SubnetNotAllowedFault,
        SubnetQuotaExceededFault,
        TagQuotaPerResourceExceeded,
    ],
}));
/**
 * Creates a MemoryDB user. For more information, see Authenticating users with Access Contol Lists (ACLs).
 */
export const createUser = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateUserRequest,
    output: CreateUserResponse,
    errors: [
        DuplicateUserNameFault,
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        TagQuotaPerResourceExceeded,
        UserAlreadyExistsFault,
        UserQuotaExceededFault,
    ],
}));
/**
 * Deletes an Access Control List. The ACL must first be disassociated from the cluster before it can be deleted. For more information, see Authenticating users with Access Contol Lists (ACLs).
 */
export const deleteACL = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteACLRequest,
    output: DeleteACLResponse,
    errors: [
        ACLNotFoundFault,
        InvalidACLStateFault,
        InvalidParameterValueException,
    ],
}));
/**
 * Deletes a cluster. It also deletes all associated nodes and node endpoints.
 *
 * `CreateSnapshot` permission is required to create a final snapshot.
 * Without this permission, the API call will fail with an `Access Denied` exception.
 */
export const deleteCluster = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteClusterRequest,
    output: DeleteClusterResponse,
    errors: [
        ClusterNotFoundFault,
        InvalidClusterStateFault,
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        ServiceLinkedRoleNotFoundFault,
        SnapshotAlreadyExistsFault,
    ],
}));
/**
 * Deletes an existing multi-Region cluster.
 */
export const deleteMultiRegionCluster = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteMultiRegionClusterRequest,
    output: DeleteMultiRegionClusterResponse,
    errors: [
        InvalidMultiRegionClusterStateFault,
        InvalidParameterValueException,
        MultiRegionClusterNotFoundFault,
    ],
}));
/**
 * Deletes the specified parameter group. You cannot delete a parameter group if it is associated with any clusters.
 * You cannot delete the default parameter groups in your account.
 */
export const deleteParameterGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteParameterGroupRequest,
    output: DeleteParameterGroupResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterGroupStateFault,
        InvalidParameterValueException,
        ParameterGroupNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
    ],
}));
/**
 * Deletes an existing snapshot. When you receive a successful response from this operation, MemoryDB immediately begins deleting the snapshot; you cannot cancel or revert this operation.
 */
export const deleteSnapshot = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteSnapshotRequest,
    output: DeleteSnapshotResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        InvalidSnapshotStateFault,
        ServiceLinkedRoleNotFoundFault,
        SnapshotNotFoundFault,
    ],
}));
/**
 * Deletes a subnet group. You cannot delete a default subnet group or one that is associated with any clusters.
 */
export const deleteSubnetGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteSubnetGroupRequest,
    output: DeleteSubnetGroupResponse,
    errors: [
        ServiceLinkedRoleNotFoundFault,
        SubnetGroupInUseFault,
        SubnetGroupNotFoundFault,
    ],
}));
/**
 * Deletes a user. The user will be removed from all ACLs and in turn removed from all clusters.
 */
export const deleteUser = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteUserRequest,
    output: DeleteUserResponse,
    errors: [
        InvalidParameterValueException,
        InvalidUserStateFault,
        UserNotFoundFault,
    ],
}));
/**
 * Returns a list of ACLs.
 */
export const describeACLs = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeACLsRequest,
    output: DescribeACLsResponse,
    errors: [ACLNotFoundFault, InvalidParameterCombinationException],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "ACLs",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns information about all provisioned clusters if no cluster identifier is specified, or about a specific cluster if a cluster name is supplied.
 */
export const describeClusters = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeClustersRequest,
    output: DescribeClustersResponse,
    errors: [
        ClusterNotFoundFault,
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        ServiceLinkedRoleNotFoundFault,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "Clusters",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns a list of the available Redis OSS engine versions.
 */
export const describeEngineVersions = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeEngineVersionsRequest,
    output: DescribeEngineVersionsResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        ServiceLinkedRoleNotFoundFault,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "EngineVersions",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns events related to clusters, security groups, and parameter groups. You can obtain events specific to a particular cluster, security group, or parameter group by providing the name as a parameter.
 *
 * By default, only the events occurring within the last hour are returned; however, you can retrieve up to 14 days' worth of events if necessary.
 */
export const describeEvents = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeEventsRequest,
    output: DescribeEventsResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        ServiceLinkedRoleNotFoundFault,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "Events",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns details about one or more multi-Region clusters.
 */
export const describeMultiRegionClusters = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeMultiRegionClustersRequest,
    output: DescribeMultiRegionClustersResponse,
    errors: [
        ClusterNotFoundFault,
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        MultiRegionClusterNotFoundFault,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "MultiRegionClusters",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns a list of multi-region parameter groups.
 */
export const describeMultiRegionParameterGroups = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeMultiRegionParameterGroupsRequest,
    output: DescribeMultiRegionParameterGroupsResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        MultiRegionParameterGroupNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
    ],
}));
/**
 * Returns the detailed parameter list for a particular multi-region parameter group.
 */
export const describeMultiRegionParameters = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeMultiRegionParametersRequest,
    output: DescribeMultiRegionParametersResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        MultiRegionParameterGroupNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
    ],
}));
/**
 * Returns a list of parameter group descriptions. If a parameter group name is specified, the list contains only the descriptions for that group.
 */
export const describeParameterGroups = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeParameterGroupsRequest,
    output: DescribeParameterGroupsResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        ParameterGroupNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "ParameterGroups",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns the detailed parameter list for a particular parameter group.
 */
export const describeParameters = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeParametersRequest,
    output: DescribeParametersResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        ParameterGroupNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "Parameters",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns information about reserved nodes for this account, or about a specified reserved node.
 */
export const describeReservedNodes = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeReservedNodesRequest,
    output: DescribeReservedNodesResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        ReservedNodeNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "ReservedNodes",
        pageSize: "MaxResults",
    },
}));
/**
 * Lists available reserved node offerings.
 */
export const describeReservedNodesOfferings = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeReservedNodesOfferingsRequest,
    output: DescribeReservedNodesOfferingsResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        ReservedNodesOfferingNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "ReservedNodesOfferings",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns details of the service updates.
 */
export const describeServiceUpdates = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeServiceUpdatesRequest,
    output: DescribeServiceUpdatesResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "ServiceUpdates",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns information about cluster snapshots. By default, DescribeSnapshots lists all of your snapshots; it can optionally describe a single snapshot,
 * or just the snapshots associated with a particular cluster.
 */
export const describeSnapshots = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeSnapshotsRequest,
    output: DescribeSnapshotsResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        ServiceLinkedRoleNotFoundFault,
        SnapshotNotFoundFault,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "Snapshots",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns a list of subnet group descriptions. If a subnet group name is specified, the list contains only the description of that group.
 */
export const describeSubnetGroups = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeSubnetGroupsRequest,
    output: DescribeSubnetGroupsResponse,
    errors: [ServiceLinkedRoleNotFoundFault, SubnetGroupNotFoundFault],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "SubnetGroups",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns a list of users.
 */
export const describeUsers = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeUsersRequest,
    output: DescribeUsersResponse,
    errors: [InvalidParameterCombinationException, UserNotFoundFault],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "Users",
        pageSize: "MaxResults",
    },
}));
/**
 * Used to failover a shard. This API is designed for testing the behavior of your application in case of MemoryDB failover. It is not designed to be used as a production-level tool for initiating
 * a failover to overcome a problem you may have with the cluster. Moreover, in certain conditions such as large scale operational events, Amazon may block this API.
 */
export const failoverShard = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: FailoverShardRequest,
    output: FailoverShardResponse,
    errors: [
        APICallRateForCustomerExceededFault,
        ClusterNotFoundFault,
        InvalidClusterStateFault,
        InvalidKMSKeyFault,
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        ShardNotFoundFault,
        TestFailoverNotAvailableFault,
    ],
}));
/**
 * Lists the allowed updates for a multi-Region cluster.
 */
export const listAllowedMultiRegionClusterUpdates = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListAllowedMultiRegionClusterUpdatesRequest,
    output: ListAllowedMultiRegionClusterUpdatesResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        MultiRegionClusterNotFoundFault,
    ],
}));
/**
 * Lists all available node types that you can scale to from your cluster's current node type.
 *
 * When you use the UpdateCluster operation to scale your cluster, the value of the NodeType parameter must be one of the node types returned by this operation.
 */
export const listAllowedNodeTypeUpdates = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListAllowedNodeTypeUpdatesRequest,
    output: ListAllowedNodeTypeUpdatesResponse,
    errors: [
        ClusterNotFoundFault,
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        ServiceLinkedRoleNotFoundFault,
    ],
}));
/**
 * Lists all tags currently on a named resource. A tag is a key-value pair where the key and value are case-sensitive. You can use tags to categorize and track your MemoryDB resources. For more information, see Tagging your MemoryDB resources.
 *
 * When you add or remove tags from multi region clusters, you might not immediately see the latest effective tags in the ListTags API response due to it being eventually consistent specifically for multi region clusters. For more information, see Tagging your MemoryDB resources.
 */
export const listTags = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListTagsRequest,
    output: ListTagsResponse,
    errors: [
        ACLNotFoundFault,
        ClusterNotFoundFault,
        InvalidARNFault,
        InvalidClusterStateFault,
        MultiRegionClusterNotFoundFault,
        MultiRegionParameterGroupNotFoundFault,
        ParameterGroupNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
        SnapshotNotFoundFault,
        SubnetGroupNotFoundFault,
        UserNotFoundFault,
    ],
}));
/**
 * Allows you to purchase a reserved node offering. Reserved nodes are not eligible for cancellation and are non-refundable.
 */
export const purchaseReservedNodesOffering = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PurchaseReservedNodesOfferingRequest,
    output: PurchaseReservedNodesOfferingResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        ReservedNodeAlreadyExistsFault,
        ReservedNodeQuotaExceededFault,
        ReservedNodesOfferingNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
        TagQuotaPerResourceExceeded,
    ],
}));
/**
 * Modifies the parameters of a parameter group to the engine or system default value. You can reset specific parameters by submitting a list of parameter names. To reset the entire parameter group, specify the AllParameters and ParameterGroupName parameters.
 */
export const resetParameterGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ResetParameterGroupRequest,
    output: ResetParameterGroupResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterGroupStateFault,
        InvalidParameterValueException,
        ParameterGroupNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
    ],
}));
/**
 * Use this operation to add tags to a resource. A tag is a key-value pair where the key and value are case-sensitive. You can use tags to categorize and track all your MemoryDB resources. For more information, see Tagging your MemoryDB resources.
 *
 * When you add tags to multi region clusters, you might not immediately see the latest effective tags in the ListTags API response due to it being eventually consistent specifically for multi region clusters. For more information, see Tagging your MemoryDB resources.
 *
 * You can specify cost-allocation tags for your MemoryDB resources, Amazon generates a cost allocation report as a comma-separated value
 * (CSV) file with your usage and costs aggregated by your tags. You can apply tags that represent business categories
 * (such as cost centers, application names, or owners) to organize your costs across multiple services.
 *
 * For more information, see Using Cost Allocation Tags.
 */
export const tagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: TagResourceRequest,
    output: TagResourceResponse,
    errors: [
        ACLNotFoundFault,
        ClusterNotFoundFault,
        InvalidARNFault,
        InvalidClusterStateFault,
        InvalidParameterValueException,
        MultiRegionClusterNotFoundFault,
        MultiRegionParameterGroupNotFoundFault,
        ParameterGroupNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
        SnapshotNotFoundFault,
        SubnetGroupNotFoundFault,
        TagQuotaPerResourceExceeded,
        UserNotFoundFault,
    ],
}));
/**
 * Use this operation to remove tags on a resource. A tag is a key-value pair where the key and value are case-sensitive. You can use tags to categorize and track all your MemoryDB resources. For more information, see Tagging your MemoryDB resources.
 *
 * When you remove tags from multi region clusters, you might not immediately see the latest effective tags in the ListTags API response due to it being eventually consistent specifically for multi region clusters. For more information, see Tagging your MemoryDB resources.
 *
 * You can specify cost-allocation tags for your MemoryDB resources, Amazon generates a cost allocation report as a comma-separated value
 * (CSV) file with your usage and costs aggregated by your tags. You can apply tags that represent business categories
 * (such as cost centers, application names, or owners) to organize your costs across multiple services.
 *
 * For more information, see Using Cost Allocation Tags.
 */
export const untagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UntagResourceRequest,
    output: UntagResourceResponse,
    errors: [
        ACLNotFoundFault,
        ClusterNotFoundFault,
        InvalidARNFault,
        InvalidClusterStateFault,
        InvalidParameterValueException,
        MultiRegionClusterNotFoundFault,
        MultiRegionParameterGroupNotFoundFault,
        ParameterGroupNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
        SnapshotNotFoundFault,
        SubnetGroupNotFoundFault,
        TagNotFoundFault,
        UserNotFoundFault,
    ],
}));
/**
 * Changes the list of users that belong to the Access Control List.
 */
export const updateACL = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateACLRequest,
    output: UpdateACLResponse,
    errors: [
        ACLNotFoundFault,
        DefaultUserRequired,
        DuplicateUserNameFault,
        InvalidACLStateFault,
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        UserNotFoundFault,
    ],
}));
/**
 * Modifies the settings for a cluster. You can use this operation to change one or more cluster configuration settings by specifying the settings and the new values.
 */
export const updateCluster = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateClusterRequest,
    output: UpdateClusterResponse,
    errors: [
        ACLNotFoundFault,
        ClusterNotFoundFault,
        ClusterQuotaForCustomerExceededFault,
        InvalidACLStateFault,
        InvalidClusterStateFault,
        InvalidKMSKeyFault,
        InvalidNodeStateFault,
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        InvalidVPCNetworkStateFault,
        NodeQuotaForClusterExceededFault,
        NodeQuotaForCustomerExceededFault,
        NoOperationFault,
        ParameterGroupNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
        ShardsPerClusterQuotaExceededFault,
    ],
}));
/**
 * Updates the configuration of an existing multi-Region cluster.
 */
export const updateMultiRegionCluster = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateMultiRegionClusterRequest,
    output: UpdateMultiRegionClusterResponse,
    errors: [
        InvalidMultiRegionClusterStateFault,
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        MultiRegionClusterNotFoundFault,
        MultiRegionParameterGroupNotFoundFault,
    ],
}));
/**
 * Updates the parameters of a parameter group. You can modify up to 20 parameters in a single request by submitting a list parameter name and value pairs.
 */
export const updateParameterGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateParameterGroupRequest,
    output: UpdateParameterGroupResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterGroupStateFault,
        InvalidParameterValueException,
        ParameterGroupNotFoundFault,
        ServiceLinkedRoleNotFoundFault,
    ],
}));
/**
 * Updates a subnet group. For more information, see Updating a subnet group
 */
export const updateSubnetGroup = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateSubnetGroupRequest,
    output: UpdateSubnetGroupResponse,
    errors: [
        InvalidSubnet,
        ServiceLinkedRoleNotFoundFault,
        SubnetGroupNotFoundFault,
        SubnetInUse,
        SubnetNotAllowedFault,
        SubnetQuotaExceededFault,
    ],
}));
/**
 * Changes user password(s) and/or access string.
 */
export const updateUser = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateUserRequest,
    output: UpdateUserResponse,
    errors: [
        InvalidParameterCombinationException,
        InvalidParameterValueException,
        InvalidUserStateFault,
        UserNotFoundFault,
    ],
}));
//# sourceMappingURL=memorydb.js.map