import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
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";
import { SensitiveString } from "../sensitive.js";
const ns = T.XmlNamespace("http://es.amazonaws.com/doc/2015-01-01/");
const svc = T.AwsApiService({
    sdkId: "Elasticsearch Service",
    serviceShapeName: "AmazonElasticsearchService2015",
});
const auth = T.AwsAuthSigv4({ name: "es" });
const ver = T.ServiceVersion("2015-01-01");
const proto = T.AwsProtocolsRestJson1();
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://es-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://es-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")) {
                        if ("aws" === _.getAttr(PartitionResult, "name")) {
                            return e(`https://aos.${Region}.api.aws`);
                        }
                        if ("aws-cn" === _.getAttr(PartitionResult, "name")) {
                            return e(`https://aos.${Region}.api.amazonwebservices.com.cn`);
                        }
                        if ("aws-us-gov" === _.getAttr(PartitionResult, "name")) {
                            return e(`https://aos.${Region}.api.aws`);
                        }
                        return e(`https://es.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("DualStack is enabled but this partition does not support DualStack");
                }
                return e(`https://es.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const AcceptInboundCrossClusterSearchConnectionRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CrossClusterSearchConnectionId: S.String.pipe(T.HttpLabel("CrossClusterSearchConnectionId")),
}).pipe(T.all(ns, T.Http({
    method: "PUT",
    uri: "/2015-01-01/es/ccs/inboundConnection/{CrossClusterSearchConnectionId}/accept",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "AcceptInboundCrossClusterSearchConnectionRequest",
});
export const DomainInformation = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    OwnerId: S.optional(S.String),
    DomainName: S.String,
    Region: S.optional(S.String),
})).annotate({
    identifier: "DomainInformation",
});
export const InboundCrossClusterSearchConnectionStatusCode = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const InboundCrossClusterSearchConnectionStatus = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    StatusCode: S.optional(InboundCrossClusterSearchConnectionStatusCode),
    Message: S.optional(S.String),
})).annotate({
    identifier: "InboundCrossClusterSearchConnectionStatus",
});
export const InboundCrossClusterSearchConnection = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SourceDomainInfo: S.optional(DomainInformation),
    DestinationDomainInfo: S.optional(DomainInformation),
    CrossClusterSearchConnectionId: S.optional(S.String),
    ConnectionStatus: S.optional(InboundCrossClusterSearchConnectionStatus),
})).annotate({
    identifier: "InboundCrossClusterSearchConnection",
});
export const AcceptInboundCrossClusterSearchConnectionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CrossClusterSearchConnection: S.optional(InboundCrossClusterSearchConnection),
}).pipe(ns)).annotate({
    identifier: "AcceptInboundCrossClusterSearchConnectionResponse",
});
export const Tag = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Key: S.String, Value: S.String })).annotate({ identifier: "Tag" });
export const TagList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Tag);
export const AddTagsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ARN: S.String, TagList: TagList }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/2015-01-01/tags" }), svc, auth, proto, ver, rules))).annotate({ identifier: "AddTagsRequest" });
export const AddTagsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "AddTagsResponse",
});
export const AssociatePackageRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PackageID: S.String.pipe(T.HttpLabel("PackageID")),
    DomainName: S.String.pipe(T.HttpLabel("DomainName")),
}).pipe(T.all(ns, T.Http({
    method: "POST",
    uri: "/2015-01-01/packages/associate/{PackageID}/{DomainName}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "AssociatePackageRequest",
});
export const PackageType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DomainPackageStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ErrorDetails = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ErrorType: S.optional(S.String),
    ErrorMessage: S.optional(S.String),
})).annotate({ identifier: "ErrorDetails" });
export const DomainPackageDetails = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PackageID: S.optional(S.String),
    PackageName: S.optional(S.String),
    PackageType: S.optional(PackageType),
    LastUpdated: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    DomainName: S.optional(S.String),
    DomainPackageStatus: S.optional(DomainPackageStatus),
    PackageVersion: S.optional(S.String),
    ReferencePath: S.optional(S.String),
    ErrorDetails: S.optional(ErrorDetails),
})).annotate({
    identifier: "DomainPackageDetails",
});
export const AssociatePackageResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainPackageDetails: S.optional(DomainPackageDetails) }).pipe(ns)).annotate({
    identifier: "AssociatePackageResponse",
});
export const AuthorizeVpcEndpointAccessRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String.pipe(T.HttpLabel("DomainName")),
    Account: S.String,
}).pipe(T.all(ns, T.Http({
    method: "POST",
    uri: "/2015-01-01/es/domain/{DomainName}/authorizeVpcEndpointAccess",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "AuthorizeVpcEndpointAccessRequest",
});
export const PrincipalType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const AuthorizedPrincipal = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PrincipalType: S.optional(PrincipalType),
    Principal: S.optional(S.String),
})).annotate({
    identifier: "AuthorizedPrincipal",
});
export const AuthorizeVpcEndpointAccessResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AuthorizedPrincipal: AuthorizedPrincipal }).pipe(ns)).annotate({
    identifier: "AuthorizeVpcEndpointAccessResponse",
});
export const CancelDomainConfigChangeRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String.pipe(T.HttpLabel("DomainName")),
    DryRun: S.optional(S.Boolean),
}).pipe(T.all(ns, T.Http({
    method: "POST",
    uri: "/2015-01-01/es/domain/{DomainName}/config/cancel",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "CancelDomainConfigChangeRequest",
});
export const GUIDList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const CancelledChangeProperty = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PropertyName: S.optional(S.String),
    CancelledValue: S.optional(S.String),
    ActiveValue: S.optional(S.String),
})).annotate({
    identifier: "CancelledChangeProperty",
});
export const CancelledChangePropertyList = /*@__PURE__*/ /*#__PURE__*/ S.Array(CancelledChangeProperty);
export const CancelDomainConfigChangeResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DryRun: S.optional(S.Boolean),
    CancelledChangeIds: S.optional(GUIDList),
    CancelledChangeProperties: S.optional(CancelledChangePropertyList),
}).pipe(ns)).annotate({
    identifier: "CancelDomainConfigChangeResponse",
});
export const CancelElasticsearchServiceSoftwareUpdateRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String }).pipe(T.all(ns, T.Http({
    method: "POST",
    uri: "/2015-01-01/es/serviceSoftwareUpdate/cancel",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "CancelElasticsearchServiceSoftwareUpdateRequest",
});
export const DeploymentStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ServiceSoftwareOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CurrentVersion: S.optional(S.String),
    NewVersion: S.optional(S.String),
    UpdateAvailable: S.optional(S.Boolean),
    Cancellable: S.optional(S.Boolean),
    UpdateStatus: S.optional(DeploymentStatus),
    Description: S.optional(S.String),
    AutomatedUpdateDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    OptionalDeployment: S.optional(S.Boolean),
})).annotate({
    identifier: "ServiceSoftwareOptions",
});
export const CancelElasticsearchServiceSoftwareUpdateResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ServiceSoftwareOptions: S.optional(ServiceSoftwareOptions),
}).pipe(ns)).annotate({
    identifier: "CancelElasticsearchServiceSoftwareUpdateResponse",
});
export const ESPartitionInstanceType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ZoneAwarenessConfig = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AvailabilityZoneCount: S.optional(S.Number) })).annotate({
    identifier: "ZoneAwarenessConfig",
});
export const ESWarmPartitionInstanceType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ColdStorageOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Enabled: S.Boolean })).annotate({
    identifier: "ColdStorageOptions",
});
export const ElasticsearchClusterConfig = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    InstanceType: S.optional(ESPartitionInstanceType),
    InstanceCount: S.optional(S.Number),
    DedicatedMasterEnabled: S.optional(S.Boolean),
    ZoneAwarenessEnabled: S.optional(S.Boolean),
    ZoneAwarenessConfig: S.optional(ZoneAwarenessConfig),
    DedicatedMasterType: S.optional(ESPartitionInstanceType),
    DedicatedMasterCount: S.optional(S.Number),
    WarmEnabled: S.optional(S.Boolean),
    WarmType: S.optional(ESWarmPartitionInstanceType),
    WarmCount: S.optional(S.Number),
    ColdStorageOptions: S.optional(ColdStorageOptions),
})).annotate({
    identifier: "ElasticsearchClusterConfig",
});
export const VolumeType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const EBSOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EBSEnabled: S.optional(S.Boolean),
    VolumeType: S.optional(VolumeType),
    VolumeSize: S.optional(S.Number),
    Iops: S.optional(S.Number),
    Throughput: S.optional(S.Number),
})).annotate({ identifier: "EBSOptions" });
export const SnapshotOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ AutomatedSnapshotStartHour: S.optional(S.Number) })).annotate({
    identifier: "SnapshotOptions",
});
export const StringList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const VPCOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SubnetIds: S.optional(StringList),
    SecurityGroupIds: S.optional(StringList),
})).annotate({ identifier: "VPCOptions" });
export const CognitoOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Enabled: S.optional(S.Boolean),
    UserPoolId: S.optional(S.String),
    IdentityPoolId: S.optional(S.String),
    RoleArn: S.optional(S.String),
})).annotate({ identifier: "CognitoOptions" });
export const EncryptionAtRestOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Enabled: S.optional(S.Boolean),
    KmsKeyId: S.optional(S.String),
})).annotate({
    identifier: "EncryptionAtRestOptions",
});
export const NodeToNodeEncryptionOptions = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Enabled: S.optional(S.Boolean) })).annotate({
    identifier: "NodeToNodeEncryptionOptions",
});
export const AdvancedOptions = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const LogType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const LogPublishingOption = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CloudWatchLogsLogGroupArn: S.optional(S.String),
    Enabled: S.optional(S.Boolean),
})).annotate({
    identifier: "LogPublishingOption",
});
export const LogPublishingOptions = /*@__PURE__*/ /*#__PURE__*/ S.Record(LogType, LogPublishingOption.pipe(S.optional));
export const TLSSecurityPolicy = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DomainEndpointOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EnforceHTTPS: S.optional(S.Boolean),
    TLSSecurityPolicy: S.optional(TLSSecurityPolicy),
    CustomEndpointEnabled: S.optional(S.Boolean),
    CustomEndpoint: S.optional(S.String),
    CustomEndpointCertificateArn: S.optional(S.String),
})).annotate({
    identifier: "DomainEndpointOptions",
});
export const MasterUserOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MasterUserARN: S.optional(S.String),
    MasterUserName: S.optional(SensitiveString),
    MasterUserPassword: S.optional(SensitiveString),
})).annotate({
    identifier: "MasterUserOptions",
});
export const SAMLIdp = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ MetadataContent: S.String, EntityId: S.String })).annotate({ identifier: "SAMLIdp" });
export const SAMLOptionsInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Enabled: S.optional(S.Boolean),
    Idp: S.optional(SAMLIdp),
    MasterUserName: S.optional(SensitiveString),
    MasterBackendRole: S.optional(S.String),
    SubjectKey: S.optional(S.String),
    RolesKey: S.optional(S.String),
    SessionTimeoutMinutes: S.optional(S.Number),
})).annotate({
    identifier: "SAMLOptionsInput",
});
export const AdvancedSecurityOptionsInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Enabled: S.optional(S.Boolean),
    InternalUserDatabaseEnabled: S.optional(S.Boolean),
    MasterUserOptions: S.optional(MasterUserOptions),
    SAMLOptions: S.optional(SAMLOptionsInput),
    AnonymousAuthEnabled: S.optional(S.Boolean),
})).annotate({
    identifier: "AdvancedSecurityOptionsInput",
});
export const AutoTuneDesiredState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const TimeUnit = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Duration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Value: S.optional(S.Number), Unit: S.optional(TimeUnit) })).annotate({ identifier: "Duration" });
export const AutoTuneMaintenanceSchedule = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    StartAt: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Duration: S.optional(Duration),
    CronExpressionForRecurrence: S.optional(S.String),
})).annotate({
    identifier: "AutoTuneMaintenanceSchedule",
});
export const AutoTuneMaintenanceScheduleList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(AutoTuneMaintenanceSchedule);
export const AutoTuneOptionsInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DesiredState: S.optional(AutoTuneDesiredState),
    MaintenanceSchedules: S.optional(AutoTuneMaintenanceScheduleList),
})).annotate({
    identifier: "AutoTuneOptionsInput",
});
export const DeploymentStrategy = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DeploymentStrategyOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DeploymentStrategy: DeploymentStrategy })).annotate({
    identifier: "DeploymentStrategyOptions",
});
export const CreateElasticsearchDomainRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String,
    ElasticsearchVersion: S.optional(S.String),
    ElasticsearchClusterConfig: S.optional(ElasticsearchClusterConfig),
    EBSOptions: S.optional(EBSOptions),
    AccessPolicies: S.optional(S.String),
    SnapshotOptions: S.optional(SnapshotOptions),
    VPCOptions: S.optional(VPCOptions),
    CognitoOptions: S.optional(CognitoOptions),
    EncryptionAtRestOptions: S.optional(EncryptionAtRestOptions),
    NodeToNodeEncryptionOptions: S.optional(NodeToNodeEncryptionOptions),
    AdvancedOptions: S.optional(AdvancedOptions),
    LogPublishingOptions: S.optional(LogPublishingOptions),
    DomainEndpointOptions: S.optional(DomainEndpointOptions),
    AdvancedSecurityOptions: S.optional(AdvancedSecurityOptionsInput),
    AutoTuneOptions: S.optional(AutoTuneOptionsInput),
    TagList: S.optional(TagList),
    DeploymentStrategyOptions: S.optional(DeploymentStrategyOptions),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/2015-01-01/es/domain" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateElasticsearchDomainRequest",
});
export const EndpointsMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const VPCDerivedInfo = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    VPCId: S.optional(S.String),
    SubnetIds: S.optional(StringList),
    AvailabilityZones: S.optional(StringList),
    SecurityGroupIds: S.optional(StringList),
})).annotate({ identifier: "VPCDerivedInfo" });
export const SAMLOptionsOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Enabled: S.optional(S.Boolean),
    Idp: S.optional(SAMLIdp),
    SubjectKey: S.optional(S.String),
    RolesKey: S.optional(S.String),
    SessionTimeoutMinutes: S.optional(S.Number),
})).annotate({
    identifier: "SAMLOptionsOutput",
});
export const AdvancedSecurityOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Enabled: S.optional(S.Boolean),
    InternalUserDatabaseEnabled: S.optional(S.Boolean),
    SAMLOptions: S.optional(SAMLOptionsOutput),
    AnonymousAuthDisableDate: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    AnonymousAuthEnabled: S.optional(S.Boolean),
})).annotate({
    identifier: "AdvancedSecurityOptions",
});
export const AutoTuneState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const AutoTuneOptionsOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    State: S.optional(AutoTuneState),
    ErrorMessage: S.optional(S.String),
})).annotate({
    identifier: "AutoTuneOptionsOutput",
});
export const ConfigChangeStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const InitiatedBy = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ChangeProgressDetails = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ChangeId: S.optional(S.String),
    Message: S.optional(S.String),
    ConfigChangeStatus: S.optional(ConfigChangeStatus),
    StartTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastUpdatedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    InitiatedBy: S.optional(InitiatedBy),
})).annotate({
    identifier: "ChangeProgressDetails",
});
export const DomainProcessingStatusType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const PropertyValueType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ModifyingProperties = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    ActiveValue: S.optional(S.String),
    PendingValue: S.optional(S.String),
    ValueType: S.optional(PropertyValueType),
})).annotate({
    identifier: "ModifyingProperties",
});
export const ModifyingPropertiesList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ModifyingProperties);
export const ElasticsearchDomainStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainId: S.String,
    DomainName: S.String,
    ARN: S.String,
    Created: S.optional(S.Boolean),
    Deleted: S.optional(S.Boolean),
    Endpoint: S.optional(S.String),
    Endpoints: S.optional(EndpointsMap),
    Processing: S.optional(S.Boolean),
    UpgradeProcessing: S.optional(S.Boolean),
    ElasticsearchVersion: S.optional(S.String),
    ElasticsearchClusterConfig: ElasticsearchClusterConfig,
    EBSOptions: S.optional(EBSOptions),
    AccessPolicies: S.optional(S.String),
    SnapshotOptions: S.optional(SnapshotOptions),
    VPCOptions: S.optional(VPCDerivedInfo),
    CognitoOptions: S.optional(CognitoOptions),
    EncryptionAtRestOptions: S.optional(EncryptionAtRestOptions),
    NodeToNodeEncryptionOptions: S.optional(NodeToNodeEncryptionOptions),
    AdvancedOptions: S.optional(AdvancedOptions),
    LogPublishingOptions: S.optional(LogPublishingOptions),
    ServiceSoftwareOptions: S.optional(ServiceSoftwareOptions),
    DomainEndpointOptions: S.optional(DomainEndpointOptions),
    AdvancedSecurityOptions: S.optional(AdvancedSecurityOptions),
    AutoTuneOptions: S.optional(AutoTuneOptionsOutput),
    ChangeProgressDetails: S.optional(ChangeProgressDetails),
    DomainProcessingStatus: S.optional(DomainProcessingStatusType),
    ModifyingProperties: S.optional(ModifyingPropertiesList),
    DeploymentStrategyOptions: S.optional(DeploymentStrategyOptions),
})).annotate({
    identifier: "ElasticsearchDomainStatus",
});
export const CreateElasticsearchDomainResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainStatus: S.optional(ElasticsearchDomainStatus) }).pipe(ns)).annotate({
    identifier: "CreateElasticsearchDomainResponse",
});
export const CreateOutboundCrossClusterSearchConnectionRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SourceDomainInfo: DomainInformation,
    DestinationDomainInfo: DomainInformation,
    ConnectionAlias: S.String,
}).pipe(T.all(ns, T.Http({
    method: "POST",
    uri: "/2015-01-01/es/ccs/outboundConnection",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateOutboundCrossClusterSearchConnectionRequest",
});
export const OutboundCrossClusterSearchConnectionStatusCode = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const OutboundCrossClusterSearchConnectionStatus = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    StatusCode: S.optional(OutboundCrossClusterSearchConnectionStatusCode),
    Message: S.optional(S.String),
})).annotate({
    identifier: "OutboundCrossClusterSearchConnectionStatus",
});
export const CreateOutboundCrossClusterSearchConnectionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SourceDomainInfo: S.optional(DomainInformation),
    DestinationDomainInfo: S.optional(DomainInformation),
    ConnectionAlias: S.optional(S.String),
    ConnectionStatus: S.optional(OutboundCrossClusterSearchConnectionStatus),
    CrossClusterSearchConnectionId: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "CreateOutboundCrossClusterSearchConnectionResponse",
});
export const PackageSource = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ S3BucketName: S.optional(S.String), S3Key: S.optional(S.String) })).annotate({ identifier: "PackageSource" });
export const CreatePackageRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PackageName: S.String,
    PackageType: PackageType,
    PackageDescription: S.optional(S.String),
    PackageSource: PackageSource,
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/2015-01-01/packages" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreatePackageRequest",
});
export const PackageStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const PackageDetails = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PackageID: S.optional(S.String),
    PackageName: S.optional(S.String),
    PackageType: S.optional(PackageType),
    PackageDescription: S.optional(S.String),
    PackageStatus: S.optional(PackageStatus),
    CreatedAt: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastUpdatedAt: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    AvailablePackageVersion: S.optional(S.String),
    ErrorDetails: S.optional(ErrorDetails),
})).annotate({ identifier: "PackageDetails" });
export const CreatePackageResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ PackageDetails: S.optional(PackageDetails) }).pipe(ns)).annotate({
    identifier: "CreatePackageResponse",
});
export const CreateVpcEndpointRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainArn: S.String,
    VpcOptions: VPCOptions,
    ClientToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/2015-01-01/es/vpcEndpoints" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateVpcEndpointRequest",
});
export const VpcEndpointStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const VpcEndpoint = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    VpcEndpointId: S.optional(S.String),
    VpcEndpointOwner: S.optional(S.String),
    DomainArn: S.optional(S.String),
    VpcOptions: S.optional(VPCDerivedInfo),
    Status: S.optional(VpcEndpointStatus),
    Endpoint: S.optional(S.String),
})).annotate({ identifier: "VpcEndpoint" });
export const CreateVpcEndpointResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ VpcEndpoint: VpcEndpoint }).pipe(ns)).annotate({
    identifier: "CreateVpcEndpointResponse",
});
export const DeleteElasticsearchDomainRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String.pipe(T.HttpLabel("DomainName")) }).pipe(T.all(ns, T.Http({ method: "DELETE", uri: "/2015-01-01/es/domain/{DomainName}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteElasticsearchDomainRequest",
});
export const DeleteElasticsearchDomainResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainStatus: S.optional(ElasticsearchDomainStatus) }).pipe(ns)).annotate({
    identifier: "DeleteElasticsearchDomainResponse",
});
export const DeleteElasticsearchServiceRoleRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteElasticsearchServiceRoleRequest",
});
export const DeleteElasticsearchServiceRoleResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "DeleteElasticsearchServiceRoleResponse",
});
export const DeleteInboundCrossClusterSearchConnectionRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CrossClusterSearchConnectionId: S.String.pipe(T.HttpLabel("CrossClusterSearchConnectionId")),
}).pipe(T.all(ns, T.Http({
    method: "DELETE",
    uri: "/2015-01-01/es/ccs/inboundConnection/{CrossClusterSearchConnectionId}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteInboundCrossClusterSearchConnectionRequest",
});
export const DeleteInboundCrossClusterSearchConnectionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CrossClusterSearchConnection: S.optional(InboundCrossClusterSearchConnection),
}).pipe(ns)).annotate({
    identifier: "DeleteInboundCrossClusterSearchConnectionResponse",
});
export const DeleteOutboundCrossClusterSearchConnectionRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CrossClusterSearchConnectionId: S.String.pipe(T.HttpLabel("CrossClusterSearchConnectionId")),
}).pipe(T.all(ns, T.Http({
    method: "DELETE",
    uri: "/2015-01-01/es/ccs/outboundConnection/{CrossClusterSearchConnectionId}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteOutboundCrossClusterSearchConnectionRequest",
});
export const OutboundCrossClusterSearchConnection = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SourceDomainInfo: S.optional(DomainInformation),
    DestinationDomainInfo: S.optional(DomainInformation),
    CrossClusterSearchConnectionId: S.optional(S.String),
    ConnectionAlias: S.optional(S.String),
    ConnectionStatus: S.optional(OutboundCrossClusterSearchConnectionStatus),
})).annotate({
    identifier: "OutboundCrossClusterSearchConnection",
});
export const DeleteOutboundCrossClusterSearchConnectionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CrossClusterSearchConnection: S.optional(OutboundCrossClusterSearchConnection),
}).pipe(ns)).annotate({
    identifier: "DeleteOutboundCrossClusterSearchConnectionResponse",
});
export const DeletePackageRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ PackageID: S.String.pipe(T.HttpLabel("PackageID")) }).pipe(T.all(ns, T.Http({ method: "DELETE", uri: "/2015-01-01/packages/{PackageID}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeletePackageRequest",
});
export const DeletePackageResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ PackageDetails: S.optional(PackageDetails) }).pipe(ns)).annotate({
    identifier: "DeletePackageResponse",
});
export const DeleteVpcEndpointRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    VpcEndpointId: S.String.pipe(T.HttpLabel("VpcEndpointId")),
}).pipe(T.all(ns, T.Http({
    method: "DELETE",
    uri: "/2015-01-01/es/vpcEndpoints/{VpcEndpointId}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteVpcEndpointRequest",
});
export const VpcEndpointSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    VpcEndpointId: S.optional(S.String),
    VpcEndpointOwner: S.optional(S.String),
    DomainArn: S.optional(S.String),
    Status: S.optional(VpcEndpointStatus),
})).annotate({
    identifier: "VpcEndpointSummary",
});
export const DeleteVpcEndpointResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ VpcEndpointSummary: VpcEndpointSummary }).pipe(ns)).annotate({
    identifier: "DeleteVpcEndpointResponse",
});
export const DescribeDomainAutoTunesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String.pipe(T.HttpLabel("DomainName")),
    MaxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    NextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(ns, T.Http({
    method: "GET",
    uri: "/2015-01-01/es/domain/{DomainName}/autoTunes",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeDomainAutoTunesRequest",
});
export const AutoTuneType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ScheduledAutoTuneActionType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ScheduledAutoTuneSeverityType = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const ScheduledAutoTuneDetails = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Date: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    ActionType: S.optional(ScheduledAutoTuneActionType),
    Action: S.optional(S.String),
    Severity: S.optional(ScheduledAutoTuneSeverityType),
})).annotate({
    identifier: "ScheduledAutoTuneDetails",
});
export const AutoTuneDetails = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ScheduledAutoTuneDetails: S.optional(ScheduledAutoTuneDetails) })).annotate({
    identifier: "AutoTuneDetails",
});
export const AutoTune = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AutoTuneType: S.optional(AutoTuneType),
    AutoTuneDetails: S.optional(AutoTuneDetails),
})).annotate({ identifier: "AutoTune" });
export const AutoTuneList = /*@__PURE__*/ /*#__PURE__*/ S.Array(AutoTune);
export const DescribeDomainAutoTunesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AutoTunes: S.optional(AutoTuneList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "DescribeDomainAutoTunesResponse",
});
export const DescribeDomainChangeProgressRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String.pipe(T.HttpLabel("DomainName")),
    ChangeId: S.optional(S.String).pipe(T.HttpQuery("changeid")),
}).pipe(T.all(ns, T.Http({
    method: "GET",
    uri: "/2015-01-01/es/domain/{DomainName}/progress",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeDomainChangeProgressRequest",
});
export const OverallChangeStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ChangeProgressStage = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Status: S.optional(S.String),
    Description: S.optional(S.String),
    LastUpdated: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({
    identifier: "ChangeProgressStage",
});
export const ChangeProgressStageList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ChangeProgressStage);
export const ChangeProgressStatusDetails = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ChangeId: S.optional(S.String),
    StartTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Status: S.optional(OverallChangeStatus),
    PendingProperties: S.optional(StringList),
    CompletedProperties: S.optional(StringList),
    TotalNumberOfStages: S.optional(S.Number),
    ChangeProgressStages: S.optional(ChangeProgressStageList),
    ConfigChangeStatus: S.optional(ConfigChangeStatus),
    LastUpdatedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    InitiatedBy: S.optional(InitiatedBy),
})).annotate({
    identifier: "ChangeProgressStatusDetails",
});
export const DescribeDomainChangeProgressResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ChangeProgressStatus: S.optional(ChangeProgressStatusDetails),
}).pipe(ns)).annotate({
    identifier: "DescribeDomainChangeProgressResponse",
});
export const DescribeElasticsearchDomainRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String.pipe(T.HttpLabel("DomainName")) }).pipe(T.all(ns, T.Http({ method: "GET", uri: "/2015-01-01/es/domain/{DomainName}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeElasticsearchDomainRequest",
});
export const DescribeElasticsearchDomainResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainStatus: ElasticsearchDomainStatus }).pipe(ns)).annotate({
    identifier: "DescribeElasticsearchDomainResponse",
});
export const DescribeElasticsearchDomainConfigRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String.pipe(T.HttpLabel("DomainName")) }).pipe(T.all(ns, T.Http({
    method: "GET",
    uri: "/2015-01-01/es/domain/{DomainName}/config",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeElasticsearchDomainConfigRequest",
});
export const OptionState = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const OptionStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CreationDate: S.Date.pipe(T.TimestampFormat("epoch-seconds")),
    UpdateDate: S.Date.pipe(T.TimestampFormat("epoch-seconds")),
    UpdateVersion: S.optional(S.Number),
    State: OptionState,
    PendingDeletion: S.optional(S.Boolean),
})).annotate({ identifier: "OptionStatus" });
export const ElasticsearchVersionStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Options: S.String, Status: OptionStatus })).annotate({
    identifier: "ElasticsearchVersionStatus",
});
export const ElasticsearchClusterConfigStatus = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Options: ElasticsearchClusterConfig, Status: OptionStatus })).annotate({
    identifier: "ElasticsearchClusterConfigStatus",
});
export const EBSOptionsStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Options: EBSOptions, Status: OptionStatus })).annotate({
    identifier: "EBSOptionsStatus",
});
export const AccessPoliciesStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Options: S.String, Status: OptionStatus })).annotate({
    identifier: "AccessPoliciesStatus",
});
export const SnapshotOptionsStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Options: SnapshotOptions, Status: OptionStatus })).annotate({
    identifier: "SnapshotOptionsStatus",
});
export const VPCDerivedInfoStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Options: VPCDerivedInfo, Status: OptionStatus })).annotate({
    identifier: "VPCDerivedInfoStatus",
});
export const CognitoOptionsStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Options: CognitoOptions, Status: OptionStatus })).annotate({
    identifier: "CognitoOptionsStatus",
});
export const EncryptionAtRestOptionsStatus = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Options: EncryptionAtRestOptions, Status: OptionStatus })).annotate({
    identifier: "EncryptionAtRestOptionsStatus",
});
export const NodeToNodeEncryptionOptionsStatus = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Options: NodeToNodeEncryptionOptions, Status: OptionStatus })).annotate({
    identifier: "NodeToNodeEncryptionOptionsStatus",
});
export const AdvancedOptionsStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Options: AdvancedOptions, Status: OptionStatus })).annotate({
    identifier: "AdvancedOptionsStatus",
});
export const LogPublishingOptionsStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Options: S.optional(LogPublishingOptions),
    Status: S.optional(OptionStatus),
})).annotate({
    identifier: "LogPublishingOptionsStatus",
});
export const DomainEndpointOptionsStatus = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Options: DomainEndpointOptions, Status: OptionStatus })).annotate({
    identifier: "DomainEndpointOptionsStatus",
});
export const AdvancedSecurityOptionsStatus = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Options: AdvancedSecurityOptions, Status: OptionStatus })).annotate({
    identifier: "AdvancedSecurityOptionsStatus",
});
export const RollbackOnDisable = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const AutoTuneOptions = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DesiredState: S.optional(AutoTuneDesiredState),
    RollbackOnDisable: S.optional(RollbackOnDisable),
    MaintenanceSchedules: S.optional(AutoTuneMaintenanceScheduleList),
})).annotate({
    identifier: "AutoTuneOptions",
});
export const AutoTuneStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CreationDate: S.Date.pipe(T.TimestampFormat("epoch-seconds")),
    UpdateDate: S.Date.pipe(T.TimestampFormat("epoch-seconds")),
    UpdateVersion: S.optional(S.Number),
    State: AutoTuneState,
    ErrorMessage: S.optional(S.String),
    PendingDeletion: S.optional(S.Boolean),
})).annotate({ identifier: "AutoTuneStatus" });
export const AutoTuneOptionsStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Options: S.optional(AutoTuneOptions),
    Status: S.optional(AutoTuneStatus),
})).annotate({
    identifier: "AutoTuneOptionsStatus",
});
export const DeploymentStrategyOptionsStatus = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Options: DeploymentStrategyOptions, Status: OptionStatus })).annotate({
    identifier: "DeploymentStrategyOptionsStatus",
});
export const ElasticsearchDomainConfig = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ElasticsearchVersion: S.optional(ElasticsearchVersionStatus),
    ElasticsearchClusterConfig: S.optional(ElasticsearchClusterConfigStatus),
    EBSOptions: S.optional(EBSOptionsStatus),
    AccessPolicies: S.optional(AccessPoliciesStatus),
    SnapshotOptions: S.optional(SnapshotOptionsStatus),
    VPCOptions: S.optional(VPCDerivedInfoStatus),
    CognitoOptions: S.optional(CognitoOptionsStatus),
    EncryptionAtRestOptions: S.optional(EncryptionAtRestOptionsStatus),
    NodeToNodeEncryptionOptions: S.optional(NodeToNodeEncryptionOptionsStatus),
    AdvancedOptions: S.optional(AdvancedOptionsStatus),
    LogPublishingOptions: S.optional(LogPublishingOptionsStatus),
    DomainEndpointOptions: S.optional(DomainEndpointOptionsStatus),
    AdvancedSecurityOptions: S.optional(AdvancedSecurityOptionsStatus),
    AutoTuneOptions: S.optional(AutoTuneOptionsStatus),
    ChangeProgressDetails: S.optional(ChangeProgressDetails),
    ModifyingProperties: S.optional(ModifyingPropertiesList),
    DeploymentStrategyOptions: S.optional(DeploymentStrategyOptionsStatus),
})).annotate({
    identifier: "ElasticsearchDomainConfig",
});
export const DescribeElasticsearchDomainConfigResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainConfig: ElasticsearchDomainConfig }).pipe(ns)).annotate({
    identifier: "DescribeElasticsearchDomainConfigResponse",
});
export const DomainNameList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const DescribeElasticsearchDomainsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainNames: DomainNameList }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/2015-01-01/es/domain-info" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeElasticsearchDomainsRequest",
});
export const ElasticsearchDomainStatusList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ElasticsearchDomainStatus);
export const DescribeElasticsearchDomainsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainStatusList: ElasticsearchDomainStatusList }).pipe(ns)).annotate({
    identifier: "DescribeElasticsearchDomainsResponse",
});
export const DescribeElasticsearchInstanceTypeLimitsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.optional(S.String).pipe(T.HttpQuery("domainName")),
    InstanceType: ESPartitionInstanceType.pipe(T.HttpLabel("InstanceType")),
    ElasticsearchVersion: S.String.pipe(T.HttpLabel("ElasticsearchVersion")),
}).pipe(T.all(ns, T.Http({
    method: "GET",
    uri: "/2015-01-01/es/instanceTypeLimits/{ElasticsearchVersion}/{InstanceType}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeElasticsearchInstanceTypeLimitsRequest",
});
export const LimitValueList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const StorageTypeLimit = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    LimitName: S.optional(S.String),
    LimitValues: S.optional(LimitValueList),
})).annotate({
    identifier: "StorageTypeLimit",
});
export const StorageTypeLimitList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(StorageTypeLimit);
export const StorageType = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    StorageTypeName: S.optional(S.String),
    StorageSubTypeName: S.optional(S.String),
    StorageTypeLimits: S.optional(StorageTypeLimitList),
})).annotate({ identifier: "StorageType" });
export const StorageTypeList = /*@__PURE__*/ /*#__PURE__*/ S.Array(StorageType);
export const InstanceCountLimits = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MinimumInstanceCount: S.optional(S.Number),
    MaximumInstanceCount: S.optional(S.Number),
})).annotate({
    identifier: "InstanceCountLimits",
});
export const InstanceLimits = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ InstanceCountLimits: S.optional(InstanceCountLimits) })).annotate({ identifier: "InstanceLimits" });
export const AdditionalLimit = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    LimitName: S.optional(S.String),
    LimitValues: S.optional(LimitValueList),
})).annotate({
    identifier: "AdditionalLimit",
});
export const AdditionalLimitList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(AdditionalLimit);
export const Limits = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    StorageTypes: S.optional(StorageTypeList),
    InstanceLimits: S.optional(InstanceLimits),
    AdditionalLimits: S.optional(AdditionalLimitList),
})).annotate({ identifier: "Limits" });
export const LimitsByRole = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, Limits.pipe(S.optional));
export const DescribeElasticsearchInstanceTypeLimitsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ LimitsByRole: S.optional(LimitsByRole) }).pipe(ns)).annotate({
    identifier: "DescribeElasticsearchInstanceTypeLimitsResponse",
});
export const ValueStringList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const Filter = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.optional(S.String), Values: S.optional(ValueStringList) })).annotate({ identifier: "Filter" });
export const FilterList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Filter);
export const DescribeInboundCrossClusterSearchConnectionsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Filters: S.optional(FilterList),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({
    method: "POST",
    uri: "/2015-01-01/es/ccs/inboundConnection/search",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeInboundCrossClusterSearchConnectionsRequest",
});
export const InboundCrossClusterSearchConnections = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(InboundCrossClusterSearchConnection);
export const DescribeInboundCrossClusterSearchConnectionsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CrossClusterSearchConnections: S.optional(InboundCrossClusterSearchConnections),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "DescribeInboundCrossClusterSearchConnectionsResponse",
});
export const DescribeOutboundCrossClusterSearchConnectionsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Filters: S.optional(FilterList),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({
    method: "POST",
    uri: "/2015-01-01/es/ccs/outboundConnection/search",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeOutboundCrossClusterSearchConnectionsRequest",
});
export const OutboundCrossClusterSearchConnections = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(OutboundCrossClusterSearchConnection);
export const DescribeOutboundCrossClusterSearchConnectionsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CrossClusterSearchConnections: S.optional(OutboundCrossClusterSearchConnections),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "DescribeOutboundCrossClusterSearchConnectionsResponse",
});
export const DescribePackagesFilterName = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const DescribePackagesFilterValues = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const DescribePackagesFilter = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(DescribePackagesFilterName),
    Value: S.optional(DescribePackagesFilterValues),
})).annotate({
    identifier: "DescribePackagesFilter",
});
export const DescribePackagesFilterList = /*@__PURE__*/ /*#__PURE__*/ S.Array(DescribePackagesFilter);
export const DescribePackagesRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Filters: S.optional(DescribePackagesFilterList),
    MaxResults: S.optional(S.Number),
    NextToken: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/2015-01-01/packages/describe" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribePackagesRequest",
});
export const PackageDetailsList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PackageDetails);
export const DescribePackagesResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PackageDetailsList: S.optional(PackageDetailsList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "DescribePackagesResponse",
});
export const DescribeReservedElasticsearchInstanceOfferingsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReservedElasticsearchInstanceOfferingId: S.optional(S.String).pipe(T.HttpQuery("offeringId")),
    MaxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    NextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(ns, T.Http({
    method: "GET",
    uri: "/2015-01-01/es/reservedInstanceOfferings",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeReservedElasticsearchInstanceOfferingsRequest",
});
export const ReservedElasticsearchInstancePaymentOption = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
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 ReservedElasticsearchInstanceOffering = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReservedElasticsearchInstanceOfferingId: S.optional(S.String),
    ElasticsearchInstanceType: S.optional(ESPartitionInstanceType),
    Duration: S.optional(S.Number),
    FixedPrice: S.optional(S.Number),
    UsagePrice: S.optional(S.Number),
    CurrencyCode: S.optional(S.String),
    PaymentOption: S.optional(ReservedElasticsearchInstancePaymentOption),
    RecurringCharges: S.optional(RecurringChargeList),
})).annotate({
    identifier: "ReservedElasticsearchInstanceOffering",
});
export const ReservedElasticsearchInstanceOfferingList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ReservedElasticsearchInstanceOffering.pipe(T.XmlName("ReservedElasticsearchInstanceOffering")).annotate({ identifier: "ReservedElasticsearchInstanceOffering" }));
export const DescribeReservedElasticsearchInstanceOfferingsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    ReservedElasticsearchInstanceOfferings: S.optional(ReservedElasticsearchInstanceOfferingList),
}).pipe(ns)).annotate({
    identifier: "DescribeReservedElasticsearchInstanceOfferingsResponse",
});
export const DescribeReservedElasticsearchInstancesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReservedElasticsearchInstanceId: S.optional(S.String).pipe(T.HttpQuery("reservationId")),
    MaxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    NextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(ns, T.Http({ method: "GET", uri: "/2015-01-01/es/reservedInstances" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeReservedElasticsearchInstancesRequest",
});
export const ReservedElasticsearchInstance = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReservationName: S.optional(S.String),
    ReservedElasticsearchInstanceId: S.optional(S.String),
    ReservedElasticsearchInstanceOfferingId: S.optional(S.String),
    ElasticsearchInstanceType: S.optional(ESPartitionInstanceType),
    StartTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Duration: S.optional(S.Number),
    FixedPrice: S.optional(S.Number),
    UsagePrice: S.optional(S.Number),
    CurrencyCode: S.optional(S.String),
    ElasticsearchInstanceCount: S.optional(S.Number),
    State: S.optional(S.String),
    PaymentOption: S.optional(ReservedElasticsearchInstancePaymentOption),
    RecurringCharges: S.optional(RecurringChargeList),
})).annotate({
    identifier: "ReservedElasticsearchInstance",
});
export const ReservedElasticsearchInstanceList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ReservedElasticsearchInstance);
export const DescribeReservedElasticsearchInstancesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String),
    ReservedElasticsearchInstances: S.optional(ReservedElasticsearchInstanceList),
}).pipe(ns)).annotate({
    identifier: "DescribeReservedElasticsearchInstancesResponse",
});
export const VpcEndpointIdList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const DescribeVpcEndpointsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ VpcEndpointIds: VpcEndpointIdList }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/2015-01-01/es/vpcEndpoints/describe" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribeVpcEndpointsRequest",
});
export const VpcEndpoints = /*@__PURE__*/ /*#__PURE__*/ S.Array(VpcEndpoint);
export const VpcEndpointErrorCode = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const VpcEndpointError = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    VpcEndpointId: S.optional(S.String),
    ErrorCode: S.optional(VpcEndpointErrorCode),
    ErrorMessage: S.optional(S.String),
})).annotate({
    identifier: "VpcEndpointError",
});
export const VpcEndpointErrorList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(VpcEndpointError);
export const DescribeVpcEndpointsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    VpcEndpoints: VpcEndpoints,
    VpcEndpointErrors: VpcEndpointErrorList,
}).pipe(ns)).annotate({
    identifier: "DescribeVpcEndpointsResponse",
});
export const DissociatePackageRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PackageID: S.String.pipe(T.HttpLabel("PackageID")),
    DomainName: S.String.pipe(T.HttpLabel("DomainName")),
}).pipe(T.all(ns, T.Http({
    method: "POST",
    uri: "/2015-01-01/packages/dissociate/{PackageID}/{DomainName}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "DissociatePackageRequest",
});
export const DissociatePackageResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainPackageDetails: S.optional(DomainPackageDetails) }).pipe(ns)).annotate({
    identifier: "DissociatePackageResponse",
});
export const GetCompatibleElasticsearchVersionsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.optional(S.String).pipe(T.HttpQuery("domainName")),
}).pipe(T.all(ns, T.Http({ method: "GET", uri: "/2015-01-01/es/compatibleVersions" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetCompatibleElasticsearchVersionsRequest",
});
export const ElasticsearchVersionList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const CompatibleVersionsMap = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SourceVersion: S.optional(S.String),
    TargetVersions: S.optional(ElasticsearchVersionList),
})).annotate({
    identifier: "CompatibleVersionsMap",
});
export const CompatibleElasticsearchVersionsList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(CompatibleVersionsMap);
export const GetCompatibleElasticsearchVersionsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CompatibleElasticsearchVersions: S.optional(CompatibleElasticsearchVersionsList),
}).pipe(ns)).annotate({
    identifier: "GetCompatibleElasticsearchVersionsResponse",
});
export const GetPackageVersionHistoryRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PackageID: S.String.pipe(T.HttpLabel("PackageID")),
    MaxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    NextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(ns, T.Http({
    method: "GET",
    uri: "/2015-01-01/packages/{PackageID}/history",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetPackageVersionHistoryRequest",
});
export const PackageVersionHistory = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PackageVersion: S.optional(S.String),
    CommitMessage: S.optional(S.String),
    CreatedAt: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({
    identifier: "PackageVersionHistory",
});
export const PackageVersionHistoryList = /*@__PURE__*/ /*#__PURE__*/ S.Array(PackageVersionHistory);
export const GetPackageVersionHistoryResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PackageID: S.optional(S.String),
    PackageVersionHistoryList: S.optional(PackageVersionHistoryList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "GetPackageVersionHistoryResponse",
});
export const GetUpgradeHistoryRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String.pipe(T.HttpLabel("DomainName")),
    MaxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    NextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(ns, T.Http({
    method: "GET",
    uri: "/2015-01-01/es/upgradeDomain/{DomainName}/history",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetUpgradeHistoryRequest",
});
export const UpgradeStatus = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const UpgradeStep = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Issues = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const UpgradeStepItem = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    UpgradeStep: S.optional(UpgradeStep),
    UpgradeStepStatus: S.optional(UpgradeStatus),
    Issues: S.optional(Issues),
    ProgressPercent: S.optional(S.Number),
})).annotate({
    identifier: "UpgradeStepItem",
});
export const UpgradeStepsList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(UpgradeStepItem);
export const UpgradeHistory = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    UpgradeName: S.optional(S.String),
    StartTimestamp: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    UpgradeStatus: S.optional(UpgradeStatus),
    StepsList: S.optional(UpgradeStepsList),
})).annotate({ identifier: "UpgradeHistory" });
export const UpgradeHistoryList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(UpgradeHistory);
export const GetUpgradeHistoryResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    UpgradeHistories: S.optional(UpgradeHistoryList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "GetUpgradeHistoryResponse",
});
export const GetUpgradeStatusRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String.pipe(T.HttpLabel("DomainName")) }).pipe(T.all(ns, T.Http({
    method: "GET",
    uri: "/2015-01-01/es/upgradeDomain/{DomainName}/status",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetUpgradeStatusRequest",
});
export const GetUpgradeStatusResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    UpgradeStep: S.optional(UpgradeStep),
    StepStatus: S.optional(UpgradeStatus),
    UpgradeName: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "GetUpgradeStatusResponse",
});
export const EngineType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ListDomainNamesRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EngineType: S.optional(EngineType).pipe(T.HttpQuery("engineType")),
}).pipe(T.all(ns, T.Http({ method: "GET", uri: "/2015-01-01/domain" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListDomainNamesRequest",
});
export const DomainInfo = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.optional(S.String),
    EngineType: S.optional(EngineType),
})).annotate({ identifier: "DomainInfo" });
export const DomainInfoList = /*@__PURE__*/ /*#__PURE__*/ S.Array(DomainInfo);
export const ListDomainNamesResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainNames: S.optional(DomainInfoList) }).pipe(ns)).annotate({
    identifier: "ListDomainNamesResponse",
});
export const ListDomainsForPackageRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PackageID: S.String.pipe(T.HttpLabel("PackageID")),
    MaxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    NextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(ns, T.Http({
    method: "GET",
    uri: "/2015-01-01/packages/{PackageID}/domains",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListDomainsForPackageRequest",
});
export const DomainPackageDetailsList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(DomainPackageDetails);
export const ListDomainsForPackageResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainPackageDetailsList: S.optional(DomainPackageDetailsList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListDomainsForPackageResponse",
});
export const ListElasticsearchInstanceTypesRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ElasticsearchVersion: S.String.pipe(T.HttpLabel("ElasticsearchVersion")),
    DomainName: S.optional(S.String).pipe(T.HttpQuery("domainName")),
    MaxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    NextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(ns, T.Http({
    method: "GET",
    uri: "/2015-01-01/es/instanceTypes/{ElasticsearchVersion}",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListElasticsearchInstanceTypesRequest",
});
export const ElasticsearchInstanceTypeList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ESPartitionInstanceType);
export const ListElasticsearchInstanceTypesResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ElasticsearchInstanceTypes: S.optional(ElasticsearchInstanceTypeList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListElasticsearchInstanceTypesResponse",
});
export const ListElasticsearchVersionsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MaxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    NextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(ns, T.Http({ method: "GET", uri: "/2015-01-01/es/versions" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListElasticsearchVersionsRequest",
});
export const ListElasticsearchVersionsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ElasticsearchVersions: S.optional(ElasticsearchVersionList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListElasticsearchVersionsResponse",
});
export const ListPackagesForDomainRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String.pipe(T.HttpLabel("DomainName")),
    MaxResults: S.optional(S.Number).pipe(T.HttpQuery("maxResults")),
    NextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(ns, T.Http({
    method: "GET",
    uri: "/2015-01-01/domain/{DomainName}/packages",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListPackagesForDomainRequest",
});
export const ListPackagesForDomainResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainPackageDetailsList: S.optional(DomainPackageDetailsList),
    NextToken: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "ListPackagesForDomainResponse",
});
export const ListTagsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ARN: S.String.pipe(T.HttpQuery("arn")) }).pipe(T.all(ns, T.Http({ method: "GET", uri: "/2015-01-01/tags" }), 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 ListVpcEndpointAccessRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String.pipe(T.HttpLabel("DomainName")),
    NextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(ns, T.Http({
    method: "GET",
    uri: "/2015-01-01/es/domain/{DomainName}/listVpcEndpointAccess",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListVpcEndpointAccessRequest",
});
export const AuthorizedPrincipalList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(AuthorizedPrincipal);
export const ListVpcEndpointAccessResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    AuthorizedPrincipalList: AuthorizedPrincipalList,
    NextToken: S.String,
}).pipe(ns)).annotate({
    identifier: "ListVpcEndpointAccessResponse",
});
export const ListVpcEndpointsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(ns, T.Http({ method: "GET", uri: "/2015-01-01/es/vpcEndpoints" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListVpcEndpointsRequest",
});
export const VpcEndpointSummaryList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(VpcEndpointSummary);
export const ListVpcEndpointsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    VpcEndpointSummaryList: VpcEndpointSummaryList,
    NextToken: S.String,
}).pipe(ns)).annotate({
    identifier: "ListVpcEndpointsResponse",
});
export const ListVpcEndpointsForDomainRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String.pipe(T.HttpLabel("DomainName")),
    NextToken: S.optional(S.String).pipe(T.HttpQuery("nextToken")),
}).pipe(T.all(ns, T.Http({
    method: "GET",
    uri: "/2015-01-01/es/domain/{DomainName}/vpcEndpoints",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListVpcEndpointsForDomainRequest",
});
export const ListVpcEndpointsForDomainResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    VpcEndpointSummaryList: VpcEndpointSummaryList,
    NextToken: S.String,
}).pipe(ns)).annotate({
    identifier: "ListVpcEndpointsForDomainResponse",
});
export const PurchaseReservedElasticsearchInstanceOfferingRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReservedElasticsearchInstanceOfferingId: S.String,
    ReservationName: S.String,
    InstanceCount: S.optional(S.Number),
}).pipe(T.all(ns, T.Http({
    method: "POST",
    uri: "/2015-01-01/es/purchaseReservedInstanceOffering",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "PurchaseReservedElasticsearchInstanceOfferingRequest",
});
export const PurchaseReservedElasticsearchInstanceOfferingResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ReservedElasticsearchInstanceId: S.optional(S.String),
    ReservationName: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "PurchaseReservedElasticsearchInstanceOfferingResponse",
});
export const RejectInboundCrossClusterSearchConnectionRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CrossClusterSearchConnectionId: S.String.pipe(T.HttpLabel("CrossClusterSearchConnectionId")),
}).pipe(T.all(ns, T.Http({
    method: "PUT",
    uri: "/2015-01-01/es/ccs/inboundConnection/{CrossClusterSearchConnectionId}/reject",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "RejectInboundCrossClusterSearchConnectionRequest",
});
export const RejectInboundCrossClusterSearchConnectionResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    CrossClusterSearchConnection: S.optional(InboundCrossClusterSearchConnection),
}).pipe(ns)).annotate({
    identifier: "RejectInboundCrossClusterSearchConnectionResponse",
});
export const RemoveTagsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ARN: S.String, TagKeys: StringList }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/2015-01-01/tags-removal" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "RemoveTagsRequest",
});
export const RemoveTagsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "RemoveTagsResponse",
});
export const RevokeVpcEndpointAccessRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String.pipe(T.HttpLabel("DomainName")),
    Account: S.String,
}).pipe(T.all(ns, T.Http({
    method: "POST",
    uri: "/2015-01-01/es/domain/{DomainName}/revokeVpcEndpointAccess",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "RevokeVpcEndpointAccessRequest",
});
export const RevokeVpcEndpointAccessResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "RevokeVpcEndpointAccessResponse",
});
export const StartElasticsearchServiceSoftwareUpdateRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DomainName: S.String }).pipe(T.all(ns, T.Http({
    method: "POST",
    uri: "/2015-01-01/es/serviceSoftwareUpdate/start",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartElasticsearchServiceSoftwareUpdateRequest",
});
export const StartElasticsearchServiceSoftwareUpdateResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ServiceSoftwareOptions: S.optional(ServiceSoftwareOptions),
}).pipe(ns)).annotate({
    identifier: "StartElasticsearchServiceSoftwareUpdateResponse",
});
export const UpdateElasticsearchDomainConfigRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String.pipe(T.HttpLabel("DomainName")),
    ElasticsearchClusterConfig: S.optional(ElasticsearchClusterConfig),
    EBSOptions: S.optional(EBSOptions),
    SnapshotOptions: S.optional(SnapshotOptions),
    VPCOptions: S.optional(VPCOptions),
    CognitoOptions: S.optional(CognitoOptions),
    AdvancedOptions: S.optional(AdvancedOptions),
    AccessPolicies: S.optional(S.String),
    LogPublishingOptions: S.optional(LogPublishingOptions),
    DomainEndpointOptions: S.optional(DomainEndpointOptions),
    AdvancedSecurityOptions: S.optional(AdvancedSecurityOptionsInput),
    NodeToNodeEncryptionOptions: S.optional(NodeToNodeEncryptionOptions),
    EncryptionAtRestOptions: S.optional(EncryptionAtRestOptions),
    AutoTuneOptions: S.optional(AutoTuneOptions),
    DryRun: S.optional(S.Boolean),
    DeploymentStrategyOptions: S.optional(DeploymentStrategyOptions),
}).pipe(T.all(ns, T.Http({
    method: "POST",
    uri: "/2015-01-01/es/domain/{DomainName}/config",
}), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateElasticsearchDomainConfigRequest",
});
export const DryRunResults = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DeploymentType: S.optional(S.String),
    Message: S.optional(S.String),
})).annotate({ identifier: "DryRunResults" });
export const UpdateElasticsearchDomainConfigResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainConfig: ElasticsearchDomainConfig,
    DryRunResults: S.optional(DryRunResults),
}).pipe(ns)).annotate({
    identifier: "UpdateElasticsearchDomainConfigResponse",
});
export const UpdatePackageRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PackageID: S.String,
    PackageSource: PackageSource,
    PackageDescription: S.optional(S.String),
    CommitMessage: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/2015-01-01/packages/update" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdatePackageRequest",
});
export const UpdatePackageResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ PackageDetails: S.optional(PackageDetails) }).pipe(ns)).annotate({
    identifier: "UpdatePackageResponse",
});
export const UpdateVpcEndpointRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ VpcEndpointId: S.String, VpcOptions: VPCOptions }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/2015-01-01/es/vpcEndpoints/update" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateVpcEndpointRequest",
});
export const UpdateVpcEndpointResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ VpcEndpoint: VpcEndpoint }).pipe(ns)).annotate({
    identifier: "UpdateVpcEndpointResponse",
});
export const UpgradeElasticsearchDomainRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.String,
    TargetVersion: S.String,
    PerformCheckOnly: S.optional(S.Boolean),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/2015-01-01/es/upgradeDomain" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpgradeElasticsearchDomainRequest",
});
export const UpgradeElasticsearchDomainResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DomainName: S.optional(S.String),
    TargetVersion: S.optional(S.String),
    PerformCheckOnly: S.optional(S.Boolean),
    ChangeProgressDetails: S.optional(ChangeProgressDetails),
}).pipe(ns)).annotate({
    identifier: "UpgradeElasticsearchDomainResponse",
});
//# Errors
export class DisabledOperationException extends S.TaggedErrorClass()("DisabledOperationException", { message: S.optional(S.String) }).pipe(C.withConflictError) {
}
export class LimitExceededException extends S.TaggedErrorClass()("LimitExceededException", { message: S.optional(S.String) }).pipe(C.withConflictError) {
}
export class ResourceNotFoundException extends S.TaggedErrorClass()("ResourceNotFoundException", { message: S.optional(S.String) }).pipe(C.withConflictError) {
}
export class BaseException extends S.TaggedErrorClass()("BaseException", { message: S.optional(S.String) }) {
}
export class InternalException extends S.TaggedErrorClass()("InternalException", { message: S.optional(S.String) }).pipe(C.withServerError) {
}
export class ValidationException extends S.TaggedErrorClass()("ValidationException", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class AccessDeniedException extends S.TaggedErrorClass()("AccessDeniedException", { message: S.optional(S.String) }).pipe(C.withAuthError) {
}
export class ConflictException extends S.TaggedErrorClass()("ConflictException", { message: S.optional(S.String) }).pipe(C.withConflictError) {
}
export class InvalidTypeException extends S.TaggedErrorClass()("InvalidTypeException", { message: S.optional(S.String) }).pipe(C.withConflictError) {
}
export class ResourceAlreadyExistsException extends S.TaggedErrorClass()("ResourceAlreadyExistsException", { message: S.optional(S.String) }).pipe(C.withConflictError, C.withAlreadyExistsError) {
}
export class InvalidPaginationTokenException extends S.TaggedErrorClass()("InvalidPaginationTokenException", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
/**
 * Allows the destination domain owner to accept an inbound cross-cluster search connection request.
 */
export const acceptInboundCrossClusterSearchConnection = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: AcceptInboundCrossClusterSearchConnectionRequest,
    output: AcceptInboundCrossClusterSearchConnectionResponse,
    errors: [
        DisabledOperationException,
        LimitExceededException,
        ResourceNotFoundException,
    ],
}));
/**
 * Attaches tags to an existing Elasticsearch domain. Tags are a set of case-sensitive key value pairs. An Elasticsearch domain may have up to 10 tags. See
 * Tagging Amazon Elasticsearch Service Domains for more information.
 */
export const addTags = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: AddTagsRequest,
    output: AddTagsResponse,
    errors: [
        BaseException,
        InternalException,
        LimitExceededException,
        ValidationException,
    ],
}));
/**
 * Associates a package with an Amazon ES domain.
 */
export const associatePackage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: AssociatePackageRequest,
    output: AssociatePackageResponse,
    errors: [
        AccessDeniedException,
        BaseException,
        ConflictException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Provides access to an Amazon OpenSearch Service domain through the use of an interface VPC endpoint.
 */
export const authorizeVpcEndpointAccess = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: AuthorizeVpcEndpointAccessRequest,
    output: AuthorizeVpcEndpointAccessResponse,
    errors: [
        BaseException,
        DisabledOperationException,
        InternalException,
        LimitExceededException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Cancels a pending configuration change on an Amazon OpenSearch Service domain.
 */
export const cancelDomainConfigChange = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CancelDomainConfigChangeRequest,
    output: CancelDomainConfigChangeResponse,
    errors: [
        BaseException,
        DisabledOperationException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Cancels a scheduled service software update for an Amazon ES domain. You can only perform this operation before the `AutomatedUpdateDate` and when the `UpdateStatus` is in the `PENDING_UPDATE` state.
 */
export const cancelElasticsearchServiceSoftwareUpdate = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CancelElasticsearchServiceSoftwareUpdateRequest,
    output: CancelElasticsearchServiceSoftwareUpdateResponse,
    errors: [
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Creates a new Elasticsearch domain. For more information,
 * see Creating Elasticsearch Domains in the *Amazon Elasticsearch Service Developer Guide*.
 */
export const createElasticsearchDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateElasticsearchDomainRequest,
    output: CreateElasticsearchDomainResponse,
    errors: [
        BaseException,
        DisabledOperationException,
        InternalException,
        InvalidTypeException,
        LimitExceededException,
        ResourceAlreadyExistsException,
        ValidationException,
    ],
}));
/**
 * Creates a new cross-cluster search connection from a source domain to a destination domain.
 */
export const createOutboundCrossClusterSearchConnection = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateOutboundCrossClusterSearchConnectionRequest,
    output: CreateOutboundCrossClusterSearchConnectionResponse,
    errors: [
        DisabledOperationException,
        InternalException,
        LimitExceededException,
        ResourceAlreadyExistsException,
    ],
}));
/**
 * Create a package for use with Amazon ES domains.
 */
export const createPackage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreatePackageRequest,
    output: CreatePackageResponse,
    errors: [
        AccessDeniedException,
        BaseException,
        InternalException,
        InvalidTypeException,
        LimitExceededException,
        ResourceAlreadyExistsException,
        ValidationException,
    ],
}));
/**
 * Creates an Amazon OpenSearch Service-managed VPC endpoint.
 */
export const createVpcEndpoint = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateVpcEndpointRequest,
    output: CreateVpcEndpointResponse,
    errors: [
        BaseException,
        ConflictException,
        DisabledOperationException,
        InternalException,
        LimitExceededException,
        ValidationException,
    ],
}));
/**
 * Permanently deletes the specified Elasticsearch domain and all of its data. Once a domain is deleted, it cannot be recovered.
 */
export const deleteElasticsearchDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteElasticsearchDomainRequest,
    output: DeleteElasticsearchDomainResponse,
    errors: [
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Deletes the service-linked role that Elasticsearch Service uses to manage and maintain VPC domains. Role deletion will fail if any existing VPC domains use the role. You must delete any such Elasticsearch domains before deleting the role. See Deleting Elasticsearch Service Role in *VPC Endpoints for Amazon Elasticsearch Service Domains*.
 */
export const deleteElasticsearchServiceRole = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteElasticsearchServiceRoleRequest,
    output: DeleteElasticsearchServiceRoleResponse,
    errors: [BaseException, InternalException, ValidationException],
}));
/**
 * Allows the destination domain owner to delete an existing inbound cross-cluster search connection.
 */
export const deleteInboundCrossClusterSearchConnection = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteInboundCrossClusterSearchConnectionRequest,
    output: DeleteInboundCrossClusterSearchConnectionResponse,
    errors: [DisabledOperationException, ResourceNotFoundException],
}));
/**
 * Allows the source domain owner to delete an existing outbound cross-cluster search connection.
 */
export const deleteOutboundCrossClusterSearchConnection = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteOutboundCrossClusterSearchConnectionRequest,
    output: DeleteOutboundCrossClusterSearchConnectionResponse,
    errors: [DisabledOperationException, ResourceNotFoundException],
}));
/**
 * Delete the package.
 */
export const deletePackage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeletePackageRequest,
    output: DeletePackageResponse,
    errors: [
        AccessDeniedException,
        BaseException,
        ConflictException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Deletes an Amazon OpenSearch Service-managed interface VPC endpoint.
 */
export const deleteVpcEndpoint = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteVpcEndpointRequest,
    output: DeleteVpcEndpointResponse,
    errors: [
        BaseException,
        DisabledOperationException,
        InternalException,
        ResourceNotFoundException,
    ],
}));
/**
 * Provides scheduled Auto-Tune action details for the Elasticsearch domain, such as Auto-Tune action type, description, severity, and scheduled date.
 */
export const describeDomainAutoTunes = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeDomainAutoTunesRequest,
    output: DescribeDomainAutoTunesResponse,
    errors: [
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns information about the current blue/green deployment happening on a domain, including
 * a change ID, status, and progress stages.
 */
export const describeDomainChangeProgress = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeDomainChangeProgressRequest,
    output: DescribeDomainChangeProgressResponse,
    errors: [
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Returns domain configuration information about the specified Elasticsearch domain, including the domain ID, domain endpoint, and domain ARN.
 */
export const describeElasticsearchDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeElasticsearchDomainRequest,
    output: DescribeElasticsearchDomainResponse,
    errors: [
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Provides cluster configuration information about the specified Elasticsearch domain, such as the state, creation date, update version, and update date for cluster options.
 */
export const describeElasticsearchDomainConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeElasticsearchDomainConfigRequest,
    output: DescribeElasticsearchDomainConfigResponse,
    errors: [
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Returns domain configuration information about the specified Elasticsearch domains, including the domain ID, domain endpoint, and domain ARN.
 */
export const describeElasticsearchDomains = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeElasticsearchDomainsRequest,
    output: DescribeElasticsearchDomainsResponse,
    errors: [BaseException, InternalException, ValidationException],
}));
/**
 * Describe Elasticsearch Limits for a given InstanceType and ElasticsearchVersion.
 * When modifying existing Domain, specify the
 *
 * DomainName
 *
 * to know what Limits are supported for modifying.
 */
export const describeElasticsearchInstanceTypeLimits = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeElasticsearchInstanceTypeLimitsRequest,
    output: DescribeElasticsearchInstanceTypeLimitsResponse,
    errors: [
        BaseException,
        InternalException,
        InvalidTypeException,
        LimitExceededException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Lists all the inbound cross-cluster search connections for a destination domain.
 */
export const describeInboundCrossClusterSearchConnections = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeInboundCrossClusterSearchConnectionsRequest,
    output: DescribeInboundCrossClusterSearchConnectionsResponse,
    errors: [DisabledOperationException, InvalidPaginationTokenException],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "MaxResults",
    },
}));
/**
 * Lists all the outbound cross-cluster search connections for a source domain.
 */
export const describeOutboundCrossClusterSearchConnections = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeOutboundCrossClusterSearchConnectionsRequest,
    output: DescribeOutboundCrossClusterSearchConnectionsResponse,
    errors: [DisabledOperationException, InvalidPaginationTokenException],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "MaxResults",
    },
}));
/**
 * Describes all packages available to Amazon ES. Includes options for filtering, limiting the number of results, and pagination.
 */
export const describePackages = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribePackagesRequest,
    output: DescribePackagesResponse,
    errors: [
        AccessDeniedException,
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "MaxResults",
    },
}));
/**
 * Lists available reserved Elasticsearch instance offerings.
 */
export const describeReservedElasticsearchInstanceOfferings = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeReservedElasticsearchInstanceOfferingsRequest,
    output: DescribeReservedElasticsearchInstanceOfferingsResponse,
    errors: [
        DisabledOperationException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns information about reserved Elasticsearch instances for this account.
 */
export const describeReservedElasticsearchInstances = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: DescribeReservedElasticsearchInstancesRequest,
    output: DescribeReservedElasticsearchInstancesResponse,
    errors: [
        DisabledOperationException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "MaxResults",
    },
}));
/**
 * Describes one or more Amazon OpenSearch Service-managed VPC endpoints.
 */
export const describeVpcEndpoints = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribeVpcEndpointsRequest,
    output: DescribeVpcEndpointsResponse,
    errors: [
        BaseException,
        DisabledOperationException,
        InternalException,
        ValidationException,
    ],
}));
/**
 * Dissociates a package from the Amazon ES domain.
 */
export const dissociatePackage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DissociatePackageRequest,
    output: DissociatePackageResponse,
    errors: [
        AccessDeniedException,
        BaseException,
        ConflictException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Returns a list of upgrade compatible Elastisearch versions.
 * You can optionally pass a
 *
 * DomainName
 *
 * to get all upgrade compatible Elasticsearch versions for that specific domain.
 */
export const getCompatibleElasticsearchVersions = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetCompatibleElasticsearchVersionsRequest,
    output: GetCompatibleElasticsearchVersionsResponse,
    errors: [
        BaseException,
        DisabledOperationException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Returns a list of versions of the package, along with their creation time and commit message.
 */
export const getPackageVersionHistory = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: GetPackageVersionHistoryRequest,
    output: GetPackageVersionHistoryResponse,
    errors: [
        AccessDeniedException,
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "MaxResults",
    },
}));
/**
 * Retrieves the complete history of the last 10 upgrades that were performed on the domain.
 */
export const getUpgradeHistory = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: GetUpgradeHistoryRequest,
    output: GetUpgradeHistoryResponse,
    errors: [
        BaseException,
        DisabledOperationException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "MaxResults",
    },
}));
/**
 * Retrieves the latest status of the last upgrade or upgrade eligibility check that was performed on the domain.
 */
export const getUpgradeStatus = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetUpgradeStatusRequest,
    output: GetUpgradeStatusResponse,
    errors: [
        BaseException,
        DisabledOperationException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Returns the name of all Elasticsearch domains owned by the current user's account.
 */
export const listDomainNames = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListDomainNamesRequest,
    output: ListDomainNamesResponse,
    errors: [BaseException, ValidationException],
}));
/**
 * Lists all Amazon ES domains associated with the package.
 */
export const listDomainsForPackage = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListDomainsForPackageRequest,
    output: ListDomainsForPackageResponse,
    errors: [
        AccessDeniedException,
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "MaxResults",
    },
}));
/**
 * List all Elasticsearch instance types that are supported for given ElasticsearchVersion
 */
export const listElasticsearchInstanceTypes = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListElasticsearchInstanceTypesRequest,
    output: ListElasticsearchInstanceTypesResponse,
    errors: [
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "MaxResults",
    },
}));
/**
 * List all supported Elasticsearch versions
 */
export const listElasticsearchVersions = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListElasticsearchVersionsRequest,
    output: ListElasticsearchVersionsResponse,
    errors: [
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "MaxResults",
    },
}));
/**
 * Lists all packages associated with the Amazon ES domain.
 */
export const listPackagesForDomain = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListPackagesForDomainRequest,
    output: ListPackagesForDomainResponse,
    errors: [
        AccessDeniedException,
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        pageSize: "MaxResults",
    },
}));
/**
 * Returns all tags for the given Elasticsearch domain.
 */
export const listTags = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListTagsRequest,
    output: ListTagsResponse,
    errors: [
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Retrieves information about each principal that is allowed to access a
 * given Amazon OpenSearch Service domain through the use of an interface VPC endpoint.
 */
export const listVpcEndpointAccess = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListVpcEndpointAccessRequest,
    output: ListVpcEndpointAccessResponse,
    errors: [
        BaseException,
        DisabledOperationException,
        InternalException,
        ResourceNotFoundException,
    ],
}));
/**
 * Retrieves all Amazon OpenSearch Service-managed VPC endpoints in the current account and Region.
 */
export const listVpcEndpoints = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListVpcEndpointsRequest,
    output: ListVpcEndpointsResponse,
    errors: [BaseException, DisabledOperationException, InternalException],
}));
/**
 * Retrieves all Amazon OpenSearch Service-managed VPC endpoints associated with a particular domain.
 */
export const listVpcEndpointsForDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListVpcEndpointsForDomainRequest,
    output: ListVpcEndpointsForDomainResponse,
    errors: [
        BaseException,
        DisabledOperationException,
        InternalException,
        ResourceNotFoundException,
    ],
}));
/**
 * Allows you to purchase reserved Elasticsearch instances.
 */
export const purchaseReservedElasticsearchInstanceOffering = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: PurchaseReservedElasticsearchInstanceOfferingRequest,
    output: PurchaseReservedElasticsearchInstanceOfferingResponse,
    errors: [
        DisabledOperationException,
        InternalException,
        LimitExceededException,
        ResourceAlreadyExistsException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Allows the destination domain owner to reject an inbound cross-cluster search connection request.
 */
export const rejectInboundCrossClusterSearchConnection = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RejectInboundCrossClusterSearchConnectionRequest,
    output: RejectInboundCrossClusterSearchConnectionResponse,
    errors: [DisabledOperationException, ResourceNotFoundException],
}));
/**
 * Removes the specified set of tags from the specified Elasticsearch domain.
 */
export const removeTags = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RemoveTagsRequest,
    output: RemoveTagsResponse,
    errors: [BaseException, InternalException, ValidationException],
}));
/**
 * Revokes access to an Amazon OpenSearch Service domain that was provided through an interface
 * VPC endpoint.
 */
export const revokeVpcEndpointAccess = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: RevokeVpcEndpointAccessRequest,
    output: RevokeVpcEndpointAccessResponse,
    errors: [
        BaseException,
        DisabledOperationException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Schedules a service software update for an Amazon ES domain.
 */
export const startElasticsearchServiceSoftwareUpdate = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartElasticsearchServiceSoftwareUpdateRequest,
    output: StartElasticsearchServiceSoftwareUpdateResponse,
    errors: [
        BaseException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Modifies the cluster configuration of the specified Elasticsearch domain, setting as setting the instance type and the number of instances.
 */
export const updateElasticsearchDomainConfig = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateElasticsearchDomainConfigRequest,
    output: UpdateElasticsearchDomainConfigResponse,
    errors: [
        BaseException,
        InternalException,
        InvalidTypeException,
        LimitExceededException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Updates a package for use with Amazon ES domains.
 */
export const updatePackage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdatePackageRequest,
    output: UpdatePackageResponse,
    errors: [
        AccessDeniedException,
        BaseException,
        InternalException,
        LimitExceededException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Modifies an Amazon OpenSearch Service-managed interface VPC endpoint.
 */
export const updateVpcEndpoint = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateVpcEndpointRequest,
    output: UpdateVpcEndpointResponse,
    errors: [
        BaseException,
        ConflictException,
        DisabledOperationException,
        InternalException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Allows you to either upgrade your domain or perform an Upgrade eligibility check to a compatible Elasticsearch version.
 */
export const upgradeElasticsearchDomain = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpgradeElasticsearchDomainRequest,
    output: UpgradeElasticsearchDomainResponse,
    errors: [
        BaseException,
        DisabledOperationException,
        InternalException,
        ResourceAlreadyExistsException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
//# sourceMappingURL=elasticsearch-service.js.map