@aws-sdk/client-cloudsearch 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,1082 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { CloudSearchServiceException as __BaseException } from "./CloudSearchServiceException";
+
+export declare class BaseException extends __BaseException {
+    readonly name: "BaseException";
+    readonly $fault: "client";
+    
+    Code?: string;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<BaseException, __BaseException>);
+}
+
+export interface BuildSuggestersRequest {
+    
+    DomainName: string | undefined;
+}
+export declare namespace BuildSuggestersRequest {
+    
+    const filterSensitiveLog: (obj: BuildSuggestersRequest) => any;
+}
+
+export interface BuildSuggestersResponse {
+    
+    FieldNames?: string[];
+}
+export declare namespace BuildSuggestersResponse {
+    
+    const filterSensitiveLog: (obj: BuildSuggestersResponse) => any;
+}
+
+export declare class InternalException extends __BaseException {
+    readonly name: "InternalException";
+    readonly $fault: "server";
+    
+    Code?: string;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InternalException, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    Code?: string;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    
+    Code?: string;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+
+export interface CreateDomainRequest {
+    
+    DomainName: string | undefined;
+}
+export declare namespace CreateDomainRequest {
+    
+    const filterSensitiveLog: (obj: CreateDomainRequest) => any;
+}
+
+export interface ServiceEndpoint {
+    
+    Endpoint?: string;
+}
+export declare namespace ServiceEndpoint {
+    
+    const filterSensitiveLog: (obj: ServiceEndpoint) => any;
+}
+export interface Limits {
+    MaximumReplicationCount: number | undefined;
+    MaximumPartitionCount: number | undefined;
+}
+export declare namespace Limits {
+    
+    const filterSensitiveLog: (obj: Limits) => any;
+}
+
+export interface DomainStatus {
+    
+    DomainId: string | undefined;
+    
+    DomainName: string | undefined;
+    
+    ARN?: string;
+    
+    Created?: boolean;
+    
+    Deleted?: boolean;
+    
+    DocService?: ServiceEndpoint;
+    
+    SearchService?: ServiceEndpoint;
+    
+    RequiresIndexDocuments: boolean | undefined;
+    
+    Processing?: boolean;
+    
+    SearchInstanceType?: string;
+    
+    SearchPartitionCount?: number;
+    
+    SearchInstanceCount?: number;
+    Limits?: Limits;
+}
+export declare namespace DomainStatus {
+    
+    const filterSensitiveLog: (obj: DomainStatus) => any;
+}
+
+export interface CreateDomainResponse {
+    
+    DomainStatus?: DomainStatus;
+}
+export declare namespace CreateDomainResponse {
+    
+    const filterSensitiveLog: (obj: CreateDomainResponse) => any;
+}
+
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    
+    Code?: string;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+
+export declare class ResourceAlreadyExistsException extends __BaseException {
+    readonly name: "ResourceAlreadyExistsException";
+    readonly $fault: "client";
+    
+    Code?: string;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceAlreadyExistsException, __BaseException>);
+}
+export declare type AlgorithmicStemming = "full" | "light" | "minimal" | "none";
+
+export interface AnalysisOptions {
+    
+    Synonyms?: string;
+    
+    Stopwords?: string;
+    
+    StemmingDictionary?: string;
+    
+    JapaneseTokenizationDictionary?: string;
+    
+    AlgorithmicStemming?: AlgorithmicStemming | string;
+}
+export declare namespace AnalysisOptions {
+    
+    const filterSensitiveLog: (obj: AnalysisOptions) => any;
+}
+export declare type AnalysisSchemeLanguage = "ar" | "bg" | "ca" | "cs" | "da" | "de" | "el" | "en" | "es" | "eu" | "fa" | "fi" | "fr" | "ga" | "gl" | "he" | "hi" | "hu" | "hy" | "id" | "it" | "ja" | "ko" | "lv" | "mul" | "nl" | "no" | "pt" | "ro" | "ru" | "sv" | "th" | "tr" | "zh-Hans" | "zh-Hant";
+
+export interface AnalysisScheme {
+    
+    AnalysisSchemeName: string | undefined;
+    
+    AnalysisSchemeLanguage: AnalysisSchemeLanguage | string | undefined;
+    
+    AnalysisOptions?: AnalysisOptions;
+}
+export declare namespace AnalysisScheme {
+    
+    const filterSensitiveLog: (obj: AnalysisScheme) => any;
+}
+
+export interface DefineAnalysisSchemeRequest {
+    
+    DomainName: string | undefined;
+    
+    AnalysisScheme: AnalysisScheme | undefined;
+}
+export declare namespace DefineAnalysisSchemeRequest {
+    
+    const filterSensitiveLog: (obj: DefineAnalysisSchemeRequest) => any;
+}
+export declare type OptionState = "Active" | "FailedToValidate" | "Processing" | "RequiresIndexDocuments";
+
+export interface OptionStatus {
+    
+    CreationDate: Date | undefined;
+    
+    UpdateDate: Date | undefined;
+    
+    UpdateVersion?: number;
+    
+    State: OptionState | string | undefined;
+    
+    PendingDeletion?: boolean;
+}
+export declare namespace OptionStatus {
+    
+    const filterSensitiveLog: (obj: OptionStatus) => any;
+}
+
+export interface AnalysisSchemeStatus {
+    
+    Options: AnalysisScheme | undefined;
+    
+    Status: OptionStatus | undefined;
+}
+export declare namespace AnalysisSchemeStatus {
+    
+    const filterSensitiveLog: (obj: AnalysisSchemeStatus) => any;
+}
+
+export interface DefineAnalysisSchemeResponse {
+    
+    AnalysisScheme: AnalysisSchemeStatus | undefined;
+}
+export declare namespace DefineAnalysisSchemeResponse {
+    
+    const filterSensitiveLog: (obj: DefineAnalysisSchemeResponse) => any;
+}
+
+export declare class InvalidTypeException extends __BaseException {
+    readonly name: "InvalidTypeException";
+    readonly $fault: "client";
+    
+    Code?: string;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidTypeException, __BaseException>);
+}
+
+export interface Expression {
+    
+    ExpressionName: string | undefined;
+    
+    ExpressionValue: string | undefined;
+}
+export declare namespace Expression {
+    
+    const filterSensitiveLog: (obj: Expression) => any;
+}
+
+export interface DefineExpressionRequest {
+    
+    DomainName: string | undefined;
+    
+    Expression: Expression | undefined;
+}
+export declare namespace DefineExpressionRequest {
+    
+    const filterSensitiveLog: (obj: DefineExpressionRequest) => any;
+}
+
+export interface ExpressionStatus {
+    
+    Options: Expression | undefined;
+    
+    Status: OptionStatus | undefined;
+}
+export declare namespace ExpressionStatus {
+    
+    const filterSensitiveLog: (obj: ExpressionStatus) => any;
+}
+
+export interface DefineExpressionResponse {
+    
+    Expression: ExpressionStatus | undefined;
+}
+export declare namespace DefineExpressionResponse {
+    
+    const filterSensitiveLog: (obj: DefineExpressionResponse) => any;
+}
+
+export interface DateArrayOptions {
+    
+    DefaultValue?: string;
+    
+    SourceFields?: string;
+    
+    FacetEnabled?: boolean;
+    
+    SearchEnabled?: boolean;
+    
+    ReturnEnabled?: boolean;
+}
+export declare namespace DateArrayOptions {
+    
+    const filterSensitiveLog: (obj: DateArrayOptions) => any;
+}
+
+export interface DateOptions {
+    
+    DefaultValue?: string;
+    
+    SourceField?: string;
+    
+    FacetEnabled?: boolean;
+    
+    SearchEnabled?: boolean;
+    
+    ReturnEnabled?: boolean;
+    
+    SortEnabled?: boolean;
+}
+export declare namespace DateOptions {
+    
+    const filterSensitiveLog: (obj: DateOptions) => any;
+}
+
+export interface DoubleArrayOptions {
+    
+    DefaultValue?: number;
+    
+    SourceFields?: string;
+    
+    FacetEnabled?: boolean;
+    
+    SearchEnabled?: boolean;
+    
+    ReturnEnabled?: boolean;
+}
+export declare namespace DoubleArrayOptions {
+    
+    const filterSensitiveLog: (obj: DoubleArrayOptions) => any;
+}
+
+export interface DoubleOptions {
+    
+    DefaultValue?: number;
+    
+    SourceField?: string;
+    
+    FacetEnabled?: boolean;
+    
+    SearchEnabled?: boolean;
+    
+    ReturnEnabled?: boolean;
+    
+    SortEnabled?: boolean;
+}
+export declare namespace DoubleOptions {
+    
+    const filterSensitiveLog: (obj: DoubleOptions) => any;
+}
+export declare type IndexFieldType = "date" | "date-array" | "double" | "double-array" | "int" | "int-array" | "latlon" | "literal" | "literal-array" | "text" | "text-array";
+
+export interface IntArrayOptions {
+    
+    DefaultValue?: number;
+    
+    SourceFields?: string;
+    
+    FacetEnabled?: boolean;
+    
+    SearchEnabled?: boolean;
+    
+    ReturnEnabled?: boolean;
+}
+export declare namespace IntArrayOptions {
+    
+    const filterSensitiveLog: (obj: IntArrayOptions) => any;
+}
+
+export interface IntOptions {
+    
+    DefaultValue?: number;
+    
+    SourceField?: string;
+    
+    FacetEnabled?: boolean;
+    
+    SearchEnabled?: boolean;
+    
+    ReturnEnabled?: boolean;
+    
+    SortEnabled?: boolean;
+}
+export declare namespace IntOptions {
+    
+    const filterSensitiveLog: (obj: IntOptions) => any;
+}
+
+export interface LatLonOptions {
+    
+    DefaultValue?: string;
+    
+    SourceField?: string;
+    
+    FacetEnabled?: boolean;
+    
+    SearchEnabled?: boolean;
+    
+    ReturnEnabled?: boolean;
+    
+    SortEnabled?: boolean;
+}
+export declare namespace LatLonOptions {
+    
+    const filterSensitiveLog: (obj: LatLonOptions) => any;
+}
+
+export interface LiteralArrayOptions {
+    
+    DefaultValue?: string;
+    
+    SourceFields?: string;
+    
+    FacetEnabled?: boolean;
+    
+    SearchEnabled?: boolean;
+    
+    ReturnEnabled?: boolean;
+}
+export declare namespace LiteralArrayOptions {
+    
+    const filterSensitiveLog: (obj: LiteralArrayOptions) => any;
+}
+
+export interface LiteralOptions {
+    
+    DefaultValue?: string;
+    
+    SourceField?: string;
+    
+    FacetEnabled?: boolean;
+    
+    SearchEnabled?: boolean;
+    
+    ReturnEnabled?: boolean;
+    
+    SortEnabled?: boolean;
+}
+export declare namespace LiteralOptions {
+    
+    const filterSensitiveLog: (obj: LiteralOptions) => any;
+}
+
+export interface TextArrayOptions {
+    
+    DefaultValue?: string;
+    
+    SourceFields?: string;
+    
+    ReturnEnabled?: boolean;
+    
+    HighlightEnabled?: boolean;
+    
+    AnalysisScheme?: string;
+}
+export declare namespace TextArrayOptions {
+    
+    const filterSensitiveLog: (obj: TextArrayOptions) => any;
+}
+
+export interface TextOptions {
+    
+    DefaultValue?: string;
+    
+    SourceField?: string;
+    
+    ReturnEnabled?: boolean;
+    
+    SortEnabled?: boolean;
+    
+    HighlightEnabled?: boolean;
+    
+    AnalysisScheme?: string;
+}
+export declare namespace TextOptions {
+    
+    const filterSensitiveLog: (obj: TextOptions) => any;
+}
+
+export interface IndexField {
+    
+    IndexFieldName: string | undefined;
+    
+    IndexFieldType: IndexFieldType | string | undefined;
+    
+    IntOptions?: IntOptions;
+    
+    DoubleOptions?: DoubleOptions;
+    
+    LiteralOptions?: LiteralOptions;
+    
+    TextOptions?: TextOptions;
+    
+    DateOptions?: DateOptions;
+    
+    LatLonOptions?: LatLonOptions;
+    
+    IntArrayOptions?: IntArrayOptions;
+    
+    DoubleArrayOptions?: DoubleArrayOptions;
+    
+    LiteralArrayOptions?: LiteralArrayOptions;
+    
+    TextArrayOptions?: TextArrayOptions;
+    
+    DateArrayOptions?: DateArrayOptions;
+}
+export declare namespace IndexField {
+    
+    const filterSensitiveLog: (obj: IndexField) => any;
+}
+
+export interface DefineIndexFieldRequest {
+    
+    DomainName: string | undefined;
+    
+    IndexField: IndexField | undefined;
+}
+export declare namespace DefineIndexFieldRequest {
+    
+    const filterSensitiveLog: (obj: DefineIndexFieldRequest) => any;
+}
+
+export interface IndexFieldStatus {
+    
+    Options: IndexField | undefined;
+    
+    Status: OptionStatus | undefined;
+}
+export declare namespace IndexFieldStatus {
+    
+    const filterSensitiveLog: (obj: IndexFieldStatus) => any;
+}
+
+export interface DefineIndexFieldResponse {
+    
+    IndexField: IndexFieldStatus | undefined;
+}
+export declare namespace DefineIndexFieldResponse {
+    
+    const filterSensitiveLog: (obj: DefineIndexFieldResponse) => any;
+}
+export declare type SuggesterFuzzyMatching = "high" | "low" | "none";
+
+export interface DocumentSuggesterOptions {
+    
+    SourceField: string | undefined;
+    
+    FuzzyMatching?: SuggesterFuzzyMatching | string;
+    
+    SortExpression?: string;
+}
+export declare namespace DocumentSuggesterOptions {
+    
+    const filterSensitiveLog: (obj: DocumentSuggesterOptions) => any;
+}
+
+export interface Suggester {
+    
+    SuggesterName: string | undefined;
+    
+    DocumentSuggesterOptions: DocumentSuggesterOptions | undefined;
+}
+export declare namespace Suggester {
+    
+    const filterSensitiveLog: (obj: Suggester) => any;
+}
+
+export interface DefineSuggesterRequest {
+    
+    DomainName: string | undefined;
+    
+    Suggester: Suggester | undefined;
+}
+export declare namespace DefineSuggesterRequest {
+    
+    const filterSensitiveLog: (obj: DefineSuggesterRequest) => any;
+}
+
+export interface SuggesterStatus {
+    
+    Options: Suggester | undefined;
+    
+    Status: OptionStatus | undefined;
+}
+export declare namespace SuggesterStatus {
+    
+    const filterSensitiveLog: (obj: SuggesterStatus) => any;
+}
+
+export interface DefineSuggesterResponse {
+    
+    Suggester: SuggesterStatus | undefined;
+}
+export declare namespace DefineSuggesterResponse {
+    
+    const filterSensitiveLog: (obj: DefineSuggesterResponse) => any;
+}
+
+export interface DeleteAnalysisSchemeRequest {
+    
+    DomainName: string | undefined;
+    
+    AnalysisSchemeName: string | undefined;
+}
+export declare namespace DeleteAnalysisSchemeRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAnalysisSchemeRequest) => any;
+}
+
+export interface DeleteAnalysisSchemeResponse {
+    
+    AnalysisScheme: AnalysisSchemeStatus | undefined;
+}
+export declare namespace DeleteAnalysisSchemeResponse {
+    
+    const filterSensitiveLog: (obj: DeleteAnalysisSchemeResponse) => any;
+}
+
+export interface DeleteDomainRequest {
+    
+    DomainName: string | undefined;
+}
+export declare namespace DeleteDomainRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDomainRequest) => any;
+}
+
+export interface DeleteDomainResponse {
+    
+    DomainStatus?: DomainStatus;
+}
+export declare namespace DeleteDomainResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDomainResponse) => any;
+}
+
+export interface DeleteExpressionRequest {
+    
+    DomainName: string | undefined;
+    
+    ExpressionName: string | undefined;
+}
+export declare namespace DeleteExpressionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteExpressionRequest) => any;
+}
+
+export interface DeleteExpressionResponse {
+    
+    Expression: ExpressionStatus | undefined;
+}
+export declare namespace DeleteExpressionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteExpressionResponse) => any;
+}
+
+export interface DeleteIndexFieldRequest {
+    
+    DomainName: string | undefined;
+    
+    IndexFieldName: string | undefined;
+}
+export declare namespace DeleteIndexFieldRequest {
+    
+    const filterSensitiveLog: (obj: DeleteIndexFieldRequest) => any;
+}
+
+export interface DeleteIndexFieldResponse {
+    
+    IndexField: IndexFieldStatus | undefined;
+}
+export declare namespace DeleteIndexFieldResponse {
+    
+    const filterSensitiveLog: (obj: DeleteIndexFieldResponse) => any;
+}
+
+export interface DeleteSuggesterRequest {
+    
+    DomainName: string | undefined;
+    
+    SuggesterName: string | undefined;
+}
+export declare namespace DeleteSuggesterRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSuggesterRequest) => any;
+}
+
+export interface DeleteSuggesterResponse {
+    
+    Suggester: SuggesterStatus | undefined;
+}
+export declare namespace DeleteSuggesterResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSuggesterResponse) => any;
+}
+
+export interface DescribeAnalysisSchemesRequest {
+    
+    DomainName: string | undefined;
+    
+    AnalysisSchemeNames?: string[];
+    
+    Deployed?: boolean;
+}
+export declare namespace DescribeAnalysisSchemesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAnalysisSchemesRequest) => any;
+}
+
+export interface DescribeAnalysisSchemesResponse {
+    
+    AnalysisSchemes: AnalysisSchemeStatus[] | undefined;
+}
+export declare namespace DescribeAnalysisSchemesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAnalysisSchemesResponse) => any;
+}
+
+export interface DescribeAvailabilityOptionsRequest {
+    
+    DomainName: string | undefined;
+    
+    Deployed?: boolean;
+}
+export declare namespace DescribeAvailabilityOptionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAvailabilityOptionsRequest) => any;
+}
+
+export interface AvailabilityOptionsStatus {
+    
+    Options: boolean | undefined;
+    
+    Status: OptionStatus | undefined;
+}
+export declare namespace AvailabilityOptionsStatus {
+    
+    const filterSensitiveLog: (obj: AvailabilityOptionsStatus) => any;
+}
+
+export interface DescribeAvailabilityOptionsResponse {
+    
+    AvailabilityOptions?: AvailabilityOptionsStatus;
+}
+export declare namespace DescribeAvailabilityOptionsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAvailabilityOptionsResponse) => any;
+}
+
+export declare class DisabledOperationException extends __BaseException {
+    readonly name: "DisabledOperationException";
+    readonly $fault: "client";
+    
+    Code?: string;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DisabledOperationException, __BaseException>);
+}
+
+export interface DescribeDomainEndpointOptionsRequest {
+    
+    DomainName: string | undefined;
+    
+    Deployed?: boolean;
+}
+export declare namespace DescribeDomainEndpointOptionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDomainEndpointOptionsRequest) => any;
+}
+export declare enum TLSSecurityPolicy {
+    POLICY_MIN_TLS_1_0_2019_07 = "Policy-Min-TLS-1-0-2019-07",
+    POLICY_MIN_TLS_1_2_2019_07 = "Policy-Min-TLS-1-2-2019-07"
+}
+
+export interface DomainEndpointOptions {
+    
+    EnforceHTTPS?: boolean;
+    
+    TLSSecurityPolicy?: TLSSecurityPolicy | string;
+}
+export declare namespace DomainEndpointOptions {
+    
+    const filterSensitiveLog: (obj: DomainEndpointOptions) => any;
+}
+
+export interface DomainEndpointOptionsStatus {
+    
+    Options: DomainEndpointOptions | undefined;
+    
+    Status: OptionStatus | undefined;
+}
+export declare namespace DomainEndpointOptionsStatus {
+    
+    const filterSensitiveLog: (obj: DomainEndpointOptionsStatus) => any;
+}
+
+export interface DescribeDomainEndpointOptionsResponse {
+    
+    DomainEndpointOptions?: DomainEndpointOptionsStatus;
+}
+export declare namespace DescribeDomainEndpointOptionsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDomainEndpointOptionsResponse) => any;
+}
+
+export interface DescribeDomainsRequest {
+    
+    DomainNames?: string[];
+}
+export declare namespace DescribeDomainsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDomainsRequest) => any;
+}
+
+export interface DescribeDomainsResponse {
+    
+    DomainStatusList: DomainStatus[] | undefined;
+}
+export declare namespace DescribeDomainsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDomainsResponse) => any;
+}
+
+export interface DescribeExpressionsRequest {
+    
+    DomainName: string | undefined;
+    
+    ExpressionNames?: string[];
+    
+    Deployed?: boolean;
+}
+export declare namespace DescribeExpressionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeExpressionsRequest) => any;
+}
+
+export interface DescribeExpressionsResponse {
+    
+    Expressions: ExpressionStatus[] | undefined;
+}
+export declare namespace DescribeExpressionsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeExpressionsResponse) => any;
+}
+
+export interface DescribeIndexFieldsRequest {
+    
+    DomainName: string | undefined;
+    
+    FieldNames?: string[];
+    
+    Deployed?: boolean;
+}
+export declare namespace DescribeIndexFieldsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeIndexFieldsRequest) => any;
+}
+
+export interface DescribeIndexFieldsResponse {
+    
+    IndexFields: IndexFieldStatus[] | undefined;
+}
+export declare namespace DescribeIndexFieldsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeIndexFieldsResponse) => any;
+}
+
+export interface DescribeScalingParametersRequest {
+    
+    DomainName: string | undefined;
+}
+export declare namespace DescribeScalingParametersRequest {
+    
+    const filterSensitiveLog: (obj: DescribeScalingParametersRequest) => any;
+}
+export declare type PartitionInstanceType = "search.2xlarge" | "search.large" | "search.m1.large" | "search.m1.small" | "search.m2.2xlarge" | "search.m2.xlarge" | "search.m3.2xlarge" | "search.m3.large" | "search.m3.medium" | "search.m3.xlarge" | "search.medium" | "search.previousgeneration.2xlarge" | "search.previousgeneration.large" | "search.previousgeneration.small" | "search.previousgeneration.xlarge" | "search.small" | "search.xlarge";
+
+export interface ScalingParameters {
+    
+    DesiredInstanceType?: PartitionInstanceType | string;
+    
+    DesiredReplicationCount?: number;
+    
+    DesiredPartitionCount?: number;
+}
+export declare namespace ScalingParameters {
+    
+    const filterSensitiveLog: (obj: ScalingParameters) => any;
+}
+
+export interface ScalingParametersStatus {
+    
+    Options: ScalingParameters | undefined;
+    
+    Status: OptionStatus | undefined;
+}
+export declare namespace ScalingParametersStatus {
+    
+    const filterSensitiveLog: (obj: ScalingParametersStatus) => any;
+}
+
+export interface DescribeScalingParametersResponse {
+    
+    ScalingParameters: ScalingParametersStatus | undefined;
+}
+export declare namespace DescribeScalingParametersResponse {
+    
+    const filterSensitiveLog: (obj: DescribeScalingParametersResponse) => any;
+}
+
+export interface DescribeServiceAccessPoliciesRequest {
+    
+    DomainName: string | undefined;
+    
+    Deployed?: boolean;
+}
+export declare namespace DescribeServiceAccessPoliciesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeServiceAccessPoliciesRequest) => any;
+}
+
+export interface AccessPoliciesStatus {
+    
+    Options: string | undefined;
+    
+    Status: OptionStatus | undefined;
+}
+export declare namespace AccessPoliciesStatus {
+    
+    const filterSensitiveLog: (obj: AccessPoliciesStatus) => any;
+}
+
+export interface DescribeServiceAccessPoliciesResponse {
+    
+    AccessPolicies: AccessPoliciesStatus | undefined;
+}
+export declare namespace DescribeServiceAccessPoliciesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeServiceAccessPoliciesResponse) => any;
+}
+
+export interface DescribeSuggestersRequest {
+    
+    DomainName: string | undefined;
+    
+    SuggesterNames?: string[];
+    
+    Deployed?: boolean;
+}
+export declare namespace DescribeSuggestersRequest {
+    
+    const filterSensitiveLog: (obj: DescribeSuggestersRequest) => any;
+}
+
+export interface DescribeSuggestersResponse {
+    
+    Suggesters: SuggesterStatus[] | undefined;
+}
+export declare namespace DescribeSuggestersResponse {
+    
+    const filterSensitiveLog: (obj: DescribeSuggestersResponse) => any;
+}
+
+export interface IndexDocumentsRequest {
+    
+    DomainName: string | undefined;
+}
+export declare namespace IndexDocumentsRequest {
+    
+    const filterSensitiveLog: (obj: IndexDocumentsRequest) => any;
+}
+
+export interface IndexDocumentsResponse {
+    
+    FieldNames?: string[];
+}
+export declare namespace IndexDocumentsResponse {
+    
+    const filterSensitiveLog: (obj: IndexDocumentsResponse) => any;
+}
+
+export interface ListDomainNamesResponse {
+    
+    DomainNames?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListDomainNamesResponse {
+    
+    const filterSensitiveLog: (obj: ListDomainNamesResponse) => any;
+}
+
+export interface UpdateAvailabilityOptionsRequest {
+    
+    DomainName: string | undefined;
+    
+    MultiAZ: boolean | undefined;
+}
+export declare namespace UpdateAvailabilityOptionsRequest {
+    
+    const filterSensitiveLog: (obj: UpdateAvailabilityOptionsRequest) => any;
+}
+
+export interface UpdateAvailabilityOptionsResponse {
+    
+    AvailabilityOptions?: AvailabilityOptionsStatus;
+}
+export declare namespace UpdateAvailabilityOptionsResponse {
+    
+    const filterSensitiveLog: (obj: UpdateAvailabilityOptionsResponse) => any;
+}
+
+export interface UpdateDomainEndpointOptionsRequest {
+    
+    DomainName: string | undefined;
+    
+    DomainEndpointOptions: DomainEndpointOptions | undefined;
+}
+export declare namespace UpdateDomainEndpointOptionsRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDomainEndpointOptionsRequest) => any;
+}
+
+export interface UpdateDomainEndpointOptionsResponse {
+    
+    DomainEndpointOptions?: DomainEndpointOptionsStatus;
+}
+export declare namespace UpdateDomainEndpointOptionsResponse {
+    
+    const filterSensitiveLog: (obj: UpdateDomainEndpointOptionsResponse) => any;
+}
+
+export interface UpdateScalingParametersRequest {
+    
+    DomainName: string | undefined;
+    
+    ScalingParameters: ScalingParameters | undefined;
+}
+export declare namespace UpdateScalingParametersRequest {
+    
+    const filterSensitiveLog: (obj: UpdateScalingParametersRequest) => any;
+}
+
+export interface UpdateScalingParametersResponse {
+    
+    ScalingParameters: ScalingParametersStatus | undefined;
+}
+export declare namespace UpdateScalingParametersResponse {
+    
+    const filterSensitiveLog: (obj: UpdateScalingParametersResponse) => any;
+}
+
+export interface UpdateServiceAccessPoliciesRequest {
+    
+    DomainName: string | undefined;
+    
+    AccessPolicies: string | undefined;
+}
+export declare namespace UpdateServiceAccessPoliciesRequest {
+    
+    const filterSensitiveLog: (obj: UpdateServiceAccessPoliciesRequest) => any;
+}
+
+export interface UpdateServiceAccessPoliciesResponse {
+    
+    AccessPolicies: AccessPoliciesStatus | undefined;
+}
+export declare namespace UpdateServiceAccessPoliciesResponse {
+    
+    const filterSensitiveLog: (obj: UpdateServiceAccessPoliciesResponse) => any;
+}