@aws-sdk/client-kendra 3.40.0 → 3.44.0

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

@@ -82,59 +82,149 @@ export declare namespace AdditionalResultAttribute {
     
     const filterSensitiveLog: (obj: AdditionalResultAttribute) => any;
 }
+export declare enum EntityType {
+    GROUP = "GROUP",
+    USER = "USER"
+}
 
-export declare type DocumentAttributeValue = DocumentAttributeValue.DateValueMember | DocumentAttributeValue.LongValueMember | DocumentAttributeValue.StringListValueMember | DocumentAttributeValue.StringValueMember | DocumentAttributeValue.$UnknownMember;
-export declare namespace DocumentAttributeValue {
+export interface EntityConfiguration {
+    
+    EntityId: string | undefined;
+    
+    EntityType: EntityType | string | undefined;
+}
+export declare namespace EntityConfiguration {
+    
+    const filterSensitiveLog: (obj: EntityConfiguration) => any;
+}
+export interface AssociateEntitiesToExperienceRequest {
+    
+    Id: string | undefined;
+    
+    IndexId: string | undefined;
+    
+    EntityList: EntityConfiguration[] | undefined;
+}
+export declare namespace AssociateEntitiesToExperienceRequest {
+    
+    const filterSensitiveLog: (obj: AssociateEntitiesToExperienceRequest) => any;
+}
+
+export interface FailedEntity {
+    
+    EntityId?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace FailedEntity {
+    
+    const filterSensitiveLog: (obj: FailedEntity) => any;
+}
+export interface AssociateEntitiesToExperienceResponse {
+    
+    FailedEntityList?: FailedEntity[];
+}
+export declare namespace AssociateEntitiesToExperienceResponse {
+    
+    const filterSensitiveLog: (obj: AssociateEntitiesToExperienceResponse) => any;
+}
+
+export interface InternalServerException extends __SmithyException, $MetadataBearer {
+    name: "InternalServerException";
+    $fault: "server";
+    Message?: string;
+}
+export declare namespace InternalServerException {
+    
+    const filterSensitiveLog: (obj: InternalServerException) => any;
+}
+
+export interface ResourceAlreadyExistException extends __SmithyException, $MetadataBearer {
+    name: "ResourceAlreadyExistException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceAlreadyExistException {
+    
+    const filterSensitiveLog: (obj: ResourceAlreadyExistException) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ThrottlingException {
+    
+    const filterSensitiveLog: (obj: ThrottlingException) => any;
+}
+
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ValidationException {
+    
+    const filterSensitiveLog: (obj: ValidationException) => any;
+}
+export declare enum Persona {
+    OWNER = "OWNER",
+    VIEWER = "VIEWER"
+}
+
+export interface EntityPersonaConfiguration {
+    
+    EntityId: string | undefined;
+    
+    Persona: Persona | string | undefined;
+}
+export declare namespace EntityPersonaConfiguration {
+    
+    const filterSensitiveLog: (obj: EntityPersonaConfiguration) => any;
+}
+export interface AssociatePersonasToEntitiesRequest {
+    
+    Id: string | undefined;
+    
+    IndexId: string | undefined;
+    
+    Personas: EntityPersonaConfiguration[] | undefined;
+}
+export declare namespace AssociatePersonasToEntitiesRequest {
+    
+    const filterSensitiveLog: (obj: AssociatePersonasToEntitiesRequest) => any;
+}
+export interface AssociatePersonasToEntitiesResponse {
+    
+    FailedEntityList?: FailedEntity[];
+}
+export declare namespace AssociatePersonasToEntitiesResponse {
+    
+    const filterSensitiveLog: (obj: AssociatePersonasToEntitiesResponse) => any;
+}
+
+export interface DocumentAttributeValue {
     
-    interface StringValueMember {
-        StringValue: string;
-        StringListValue?: never;
-        LongValue?: never;
-        DateValue?: never;
-        $unknown?: never;
-    }
-    
-    interface StringListValueMember {
-        StringValue?: never;
-        StringListValue: string[];
-        LongValue?: never;
-        DateValue?: never;
-        $unknown?: never;
-    }
-    
-    interface LongValueMember {
-        StringValue?: never;
-        StringListValue?: never;
-        LongValue: number;
-        DateValue?: never;
-        $unknown?: never;
-    }
-    
-    interface DateValueMember {
-        StringValue?: never;
-        StringListValue?: never;
-        LongValue?: never;
-        DateValue: Date;
-        $unknown?: never;
-    }
-    interface $UnknownMember {
-        StringValue?: never;
-        StringListValue?: never;
-        LongValue?: never;
-        DateValue?: never;
-        $unknown: [
-            string,
-            any
-        ];
-    }
-    interface Visitor<T> {
-        StringValue: (value: string) => T;
-        StringListValue: (value: string[]) => T;
-        LongValue: (value: number) => T;
-        DateValue: (value: Date) => T;
-        _: (name: string, value: any) => T;
-    }
-    const visit: <T>(value: DocumentAttributeValue, visitor: Visitor<T>) => T;
+    StringValue?: string;
+    
+    StringListValue?: string[];
+    
+    LongValue?: number;
+    
+    DateValue?: Date;
+}
+export declare namespace DocumentAttributeValue {
     
     const filterSensitiveLog: (obj: DocumentAttributeValue) => any;
 }
@@ -230,46 +320,6 @@ export declare namespace ConflictException {
     const filterSensitiveLog: (obj: ConflictException) => any;
 }
 
-export interface InternalServerException extends __SmithyException, $MetadataBearer {
-    name: "InternalServerException";
-    $fault: "server";
-    Message?: string;
-}
-export declare namespace InternalServerException {
-    
-    const filterSensitiveLog: (obj: InternalServerException) => any;
-}
-
-export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "ResourceNotFoundException";
-    $fault: "client";
-    Message?: string;
-}
-export declare namespace ResourceNotFoundException {
-    
-    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
-}
-
-export interface ThrottlingException extends __SmithyException, $MetadataBearer {
-    name: "ThrottlingException";
-    $fault: "client";
-    Message?: string;
-}
-export declare namespace ThrottlingException {
-    
-    const filterSensitiveLog: (obj: ThrottlingException) => any;
-}
-
-export interface ValidationException extends __SmithyException, $MetadataBearer {
-    name: "ValidationException";
-    $fault: "client";
-    Message?: string;
-}
-export declare namespace ValidationException {
-    
-    const filterSensitiveLog: (obj: ValidationException) => any;
-}
-
 export interface DocumentInfo {
     
     DocumentId: string | undefined;
@@ -336,6 +386,86 @@ export declare namespace BatchGetDocumentStatusResponse {
     
     const filterSensitiveLog: (obj: BatchGetDocumentStatusResponse) => any;
 }
+export declare enum ConditionOperator {
+    BeginsWith = "BeginsWith",
+    Contains = "Contains",
+    Equals = "Equals",
+    Exists = "Exists",
+    GreaterThan = "GreaterThan",
+    GreaterThanOrEquals = "GreaterThanOrEquals",
+    LessThan = "LessThan",
+    LessThanOrEquals = "LessThanOrEquals",
+    NotContains = "NotContains",
+    NotEquals = "NotEquals",
+    NotExists = "NotExists"
+}
+
+export interface DocumentAttributeCondition {
+    
+    ConditionDocumentAttributeKey: string | undefined;
+    
+    Operator: ConditionOperator | string | undefined;
+    
+    ConditionOnValue?: DocumentAttributeValue;
+}
+export declare namespace DocumentAttributeCondition {
+    
+    const filterSensitiveLog: (obj: DocumentAttributeCondition) => any;
+}
+
+export interface DocumentAttributeTarget {
+    
+    TargetDocumentAttributeKey?: string;
+    
+    TargetDocumentAttributeValueDeletion?: boolean;
+    
+    TargetDocumentAttributeValue?: DocumentAttributeValue;
+}
+export declare namespace DocumentAttributeTarget {
+    
+    const filterSensitiveLog: (obj: DocumentAttributeTarget) => any;
+}
+
+export interface InlineCustomDocumentEnrichmentConfiguration {
+    
+    Condition?: DocumentAttributeCondition;
+    
+    Target?: DocumentAttributeTarget;
+    
+    DocumentContentDeletion?: boolean;
+}
+export declare namespace InlineCustomDocumentEnrichmentConfiguration {
+    
+    const filterSensitiveLog: (obj: InlineCustomDocumentEnrichmentConfiguration) => any;
+}
+
+export interface HookConfiguration {
+    
+    InvocationCondition?: DocumentAttributeCondition;
+    
+    LambdaArn: string | undefined;
+    
+    S3Bucket: string | undefined;
+}
+export declare namespace HookConfiguration {
+    
+    const filterSensitiveLog: (obj: HookConfiguration) => any;
+}
+
+export interface CustomDocumentEnrichmentConfiguration {
+    
+    InlineConfigurations?: InlineCustomDocumentEnrichmentConfiguration[];
+    
+    PreExtractionHookConfiguration?: HookConfiguration;
+    
+    PostExtractionHookConfiguration?: HookConfiguration;
+    
+    RoleArn?: string;
+}
+export declare namespace CustomDocumentEnrichmentConfiguration {
+    
+    const filterSensitiveLog: (obj: CustomDocumentEnrichmentConfiguration) => any;
+}
 export declare enum ReadAccessType {
     ALLOW = "ALLOW",
     DENY = "DENY"
@@ -416,6 +546,8 @@ export interface BatchPutDocumentRequest {
     RoleArn?: string;
     
     Documents: Document[] | undefined;
+    
+    CustomDocumentEnrichmentConfiguration?: CustomDocumentEnrichmentConfiguration;
 }
 export declare namespace BatchPutDocumentRequest {
     
@@ -1213,6 +1345,8 @@ export interface CreateDataSourceRequest {
     ClientToken?: string;
     
     LanguageCode?: string;
+    
+    CustomDocumentEnrichmentConfiguration?: CustomDocumentEnrichmentConfiguration;
 }
 export declare namespace CreateDataSourceRequest {
     
@@ -1227,14 +1361,63 @@ export declare namespace CreateDataSourceResponse {
     const filterSensitiveLog: (obj: CreateDataSourceResponse) => any;
 }
 
-export interface ResourceAlreadyExistException extends __SmithyException, $MetadataBearer {
-    name: "ResourceAlreadyExistException";
-    $fault: "client";
-    Message?: string;
+export interface ContentSourceConfiguration {
+    
+    DataSourceIds?: string[];
+    
+    FaqIds?: string[];
+    
+    DirectPutContent?: boolean;
 }
-export declare namespace ResourceAlreadyExistException {
+export declare namespace ContentSourceConfiguration {
     
-    const filterSensitiveLog: (obj: ResourceAlreadyExistException) => any;
+    const filterSensitiveLog: (obj: ContentSourceConfiguration) => any;
+}
+
+export interface UserIdentityConfiguration {
+    
+    IdentityAttributeName?: string;
+}
+export declare namespace UserIdentityConfiguration {
+    
+    const filterSensitiveLog: (obj: UserIdentityConfiguration) => any;
+}
+
+export interface ExperienceConfiguration {
+    
+    ContentSourceConfiguration?: ContentSourceConfiguration;
+    
+    UserIdentityConfiguration?: UserIdentityConfiguration;
+}
+export declare namespace ExperienceConfiguration {
+    
+    const filterSensitiveLog: (obj: ExperienceConfiguration) => any;
+}
+export interface CreateExperienceRequest {
+    
+    Name: string | undefined;
+    
+    IndexId: string | undefined;
+    
+    RoleArn?: string;
+    
+    Configuration?: ExperienceConfiguration;
+    
+    Description?: string;
+    
+    ClientToken?: string;
+}
+export declare namespace CreateExperienceRequest {
+    
+    const filterSensitiveLog: (obj: CreateExperienceRequest) => any;
+}
+export interface CreateExperienceResponse {
+    
+    Id: string | undefined;
+}
+export declare namespace CreateExperienceResponse {
+    
+    const filterSensitiveLog: (obj: CreateExperienceResponse) => any;
 }
 export declare enum FaqFileFormat {
     CSV = "CSV",
@@ -1450,6 +1633,22 @@ export declare namespace DeleteDataSourceRequest {
     
     const filterSensitiveLog: (obj: DeleteDataSourceRequest) => any;
 }
+export interface DeleteExperienceRequest {
+    
+    Id: string | undefined;
+    
+    IndexId: string | undefined;
+}
+export declare namespace DeleteExperienceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteExperienceRequest) => any;
+}
+export interface DeleteExperienceResponse {
+}
+export declare namespace DeleteExperienceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteExperienceResponse) => any;
+}
 export interface DeleteFaqRequest {
     
     Id: string | undefined;
@@ -1546,11 +1745,71 @@ export interface DescribeDataSourceResponse {
     ErrorMessage?: string;
     
     LanguageCode?: string;
+    
+    CustomDocumentEnrichmentConfiguration?: CustomDocumentEnrichmentConfiguration;
 }
 export declare namespace DescribeDataSourceResponse {
     
     const filterSensitiveLog: (obj: DescribeDataSourceResponse) => any;
 }
+export interface DescribeExperienceRequest {
+    
+    Id: string | undefined;
+    
+    IndexId: string | undefined;
+}
+export declare namespace DescribeExperienceRequest {
+    
+    const filterSensitiveLog: (obj: DescribeExperienceRequest) => any;
+}
+export declare enum EndpointType {
+    HOME = "HOME"
+}
+
+export interface ExperienceEndpoint {
+    
+    EndpointType?: EndpointType | string;
+    
+    Endpoint?: string;
+}
+export declare namespace ExperienceEndpoint {
+    
+    const filterSensitiveLog: (obj: ExperienceEndpoint) => any;
+}
+export declare enum ExperienceStatus {
+    ACTIVE = "ACTIVE",
+    CREATING = "CREATING",
+    DELETING = "DELETING",
+    FAILED = "FAILED"
+}
+export interface DescribeExperienceResponse {
+    
+    Id?: string;
+    
+    IndexId?: string;
+    
+    Name?: string;
+    
+    Endpoints?: ExperienceEndpoint[];
+    
+    Configuration?: ExperienceConfiguration;
+    
+    CreatedAt?: Date;
+    
+    UpdatedAt?: Date;
+    
+    Description?: string;
+    
+    Status?: ExperienceStatus | string;
+    
+    RoleArn?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace DescribeExperienceResponse {
+    
+    const filterSensitiveLog: (obj: DescribeExperienceResponse) => any;
+}
 export interface DescribeFaqRequest {
     
     Id: string | undefined;
@@ -1941,6 +2200,46 @@ export declare namespace DescribeThesaurusResponse {
     
     const filterSensitiveLog: (obj: DescribeThesaurusResponse) => any;
 }
+export interface DisassociateEntitiesFromExperienceRequest {
+    
+    Id: string | undefined;
+    
+    IndexId: string | undefined;
+    
+    EntityList: EntityConfiguration[] | undefined;
+}
+export declare namespace DisassociateEntitiesFromExperienceRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateEntitiesFromExperienceRequest) => any;
+}
+export interface DisassociateEntitiesFromExperienceResponse {
+    
+    FailedEntityList?: FailedEntity[];
+}
+export declare namespace DisassociateEntitiesFromExperienceResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateEntitiesFromExperienceResponse) => any;
+}
+export interface DisassociatePersonasFromEntitiesRequest {
+    
+    Id: string | undefined;
+    
+    IndexId: string | undefined;
+    
+    EntityIds: string[] | undefined;
+}
+export declare namespace DisassociatePersonasFromEntitiesRequest {
+    
+    const filterSensitiveLog: (obj: DisassociatePersonasFromEntitiesRequest) => any;
+}
+export interface DisassociatePersonasFromEntitiesResponse {
+    
+    FailedEntityList?: FailedEntity[];
+}
+export declare namespace DisassociatePersonasFromEntitiesResponse {
+    
+    const filterSensitiveLog: (obj: DisassociatePersonasFromEntitiesResponse) => any;
+}
 export interface GetQuerySuggestionsRequest {
     
     IndexId: string | undefined;
@@ -2005,6 +2304,73 @@ export declare namespace GetQuerySuggestionsResponse {
     
     const filterSensitiveLog: (obj: GetQuerySuggestionsResponse) => any;
 }
+export declare enum Interval {
+    ONE_MONTH_AGO = "ONE_MONTH_AGO",
+    ONE_WEEK_AGO = "ONE_WEEK_AGO",
+    THIS_MONTH = "THIS_MONTH",
+    THIS_WEEK = "THIS_WEEK",
+    TWO_MONTHS_AGO = "TWO_MONTHS_AGO",
+    TWO_WEEKS_AGO = "TWO_WEEKS_AGO"
+}
+export declare enum MetricType {
+    AGG_QUERY_DOC_METRICS = "AGG_QUERY_DOC_METRICS",
+    DOCS_BY_CLICK_COUNT = "DOCS_BY_CLICK_COUNT",
+    QUERIES_BY_COUNT = "QUERIES_BY_COUNT",
+    QUERIES_BY_ZERO_CLICK_RATE = "QUERIES_BY_ZERO_CLICK_RATE",
+    QUERIES_BY_ZERO_RESULT_RATE = "QUERIES_BY_ZERO_RESULT_RATE",
+    TREND_QUERY_DOC_METRICS = "TREND_QUERY_DOC_METRICS"
+}
+export interface GetSnapshotsRequest {
+    
+    IndexId: string | undefined;
+    
+    Interval: Interval | string | undefined;
+    
+    MetricType: MetricType | string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace GetSnapshotsRequest {
+    
+    const filterSensitiveLog: (obj: GetSnapshotsRequest) => any;
+}
+
+export interface TimeRange {
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+}
+export declare namespace TimeRange {
+    
+    const filterSensitiveLog: (obj: TimeRange) => any;
+}
+export interface GetSnapshotsResponse {
+    
+    SnapShotTimeFilter?: TimeRange;
+    
+    SnapshotsDataHeader?: string[];
+    
+    SnapshotsData?: string[][];
+    
+    NextToken?: string;
+}
+export declare namespace GetSnapshotsResponse {
+    
+    const filterSensitiveLog: (obj: GetSnapshotsResponse) => any;
+}
+
+export interface InvalidRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRequestException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidRequestException {
+    
+    const filterSensitiveLog: (obj: InvalidRequestException) => any;
+}
 export interface ListDataSourcesRequest {
     
     IndexId: string | undefined;
@@ -2048,17 +2414,6 @@ export declare namespace ListDataSourcesResponse {
     
     const filterSensitiveLog: (obj: ListDataSourcesResponse) => any;
 }
-
-export interface TimeRange {
-    
-    StartTime?: Date;
-    
-    EndTime?: Date;
-}
-export declare namespace TimeRange {
-    
-    const filterSensitiveLog: (obj: TimeRange) => any;
-}
 export declare enum DataSourceSyncJobStatus {
     ABORTED = "ABORTED",
     FAILED = "FAILED",
@@ -2136,6 +2491,136 @@ export declare namespace ListDataSourceSyncJobsResponse {
     
     const filterSensitiveLog: (obj: ListDataSourceSyncJobsResponse) => any;
 }
+export interface ListEntityPersonasRequest {
+    
+    Id: string | undefined;
+    
+    IndexId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListEntityPersonasRequest {
+    
+    const filterSensitiveLog: (obj: ListEntityPersonasRequest) => any;
+}
+
+export interface PersonasSummary {
+    
+    EntityId?: string;
+    
+    Persona?: Persona | string;
+    
+    CreatedAt?: Date;
+    
+    UpdatedAt?: Date;
+}
+export declare namespace PersonasSummary {
+    
+    const filterSensitiveLog: (obj: PersonasSummary) => any;
+}
+export interface ListEntityPersonasResponse {
+    
+    SummaryItems?: PersonasSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListEntityPersonasResponse {
+    
+    const filterSensitiveLog: (obj: ListEntityPersonasResponse) => any;
+}
+export interface ListExperienceEntitiesRequest {
+    
+    Id: string | undefined;
+    
+    IndexId: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListExperienceEntitiesRequest {
+    
+    const filterSensitiveLog: (obj: ListExperienceEntitiesRequest) => any;
+}
+
+export interface EntityDisplayData {
+    
+    UserName?: string;
+    
+    GroupName?: string;
+    
+    IdentifiedUserName?: string;
+    
+    FirstName?: string;
+    
+    LastName?: string;
+}
+export declare namespace EntityDisplayData {
+    
+    const filterSensitiveLog: (obj: EntityDisplayData) => any;
+}
+
+export interface ExperienceEntitiesSummary {
+    
+    EntityId?: string;
+    
+    EntityType?: EntityType | string;
+    
+    DisplayData?: EntityDisplayData;
+}
+export declare namespace ExperienceEntitiesSummary {
+    
+    const filterSensitiveLog: (obj: ExperienceEntitiesSummary) => any;
+}
+export interface ListExperienceEntitiesResponse {
+    
+    SummaryItems?: ExperienceEntitiesSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListExperienceEntitiesResponse {
+    
+    const filterSensitiveLog: (obj: ListExperienceEntitiesResponse) => any;
+}
+export interface ListExperiencesRequest {
+    
+    IndexId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListExperiencesRequest {
+    
+    const filterSensitiveLog: (obj: ListExperiencesRequest) => any;
+}
+
+export interface ExperiencesSummary {
+    
+    Name?: string;
+    
+    Id?: string;
+    
+    CreatedAt?: Date;
+    
+    Status?: ExperienceStatus | string;
+    
+    Endpoints?: ExperienceEndpoint[];
+}
+export declare namespace ExperiencesSummary {
+    
+    const filterSensitiveLog: (obj: ExperiencesSummary) => any;
+}
+export interface ListExperiencesResponse {
+    
+    SummaryItems?: ExperiencesSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListExperiencesResponse {
+    
+    const filterSensitiveLog: (obj: ListExperiencesResponse) => any;
+}
 export interface ListFaqsRequest {
     
     IndexId: string | undefined;
@@ -2686,11 +3171,31 @@ export interface UpdateDataSourceRequest {
     RoleArn?: string;
     
     LanguageCode?: string;
+    
+    CustomDocumentEnrichmentConfiguration?: CustomDocumentEnrichmentConfiguration;
 }
 export declare namespace UpdateDataSourceRequest {
     
     const filterSensitiveLog: (obj: UpdateDataSourceRequest) => any;
 }
+export interface UpdateExperienceRequest {
+    
+    Id: string | undefined;
+    
+    Name?: string;
+    
+    IndexId: string | undefined;
+    
+    RoleArn?: string;
+    
+    Configuration?: ExperienceConfiguration;
+    
+    Description?: string;
+}
+export declare namespace UpdateExperienceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateExperienceRequest) => any;
+}
 export interface UpdateIndexRequest {
     
     Id: string | undefined;