@aws-sdk/client-finspace-data 3.42.0 → 3.47.0

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

@@ -5,72 +5,297 @@ export interface AccessDeniedException extends __SmithyException, $MetadataBeare
     $fault: "client";
     message?: string;
 }
-export declare namespace AccessDeniedException {
-    
-    const filterSensitiveLog: (obj: AccessDeniedException) => any;
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    message?: string;
 }
 export declare enum ChangeType {
     APPEND = "APPEND",
     MODIFY = "MODIFY",
     REPLACE = "REPLACE"
 }
-export declare enum FormatType {
-    CSV = "CSV",
-    JSON = "JSON",
-    PARQUET = "PARQUET",
-    XML = "XML"
-}
-export declare enum SourceType {
-    S3 = "S3"
-}
+
 export interface CreateChangesetRequest {
     
+    clientToken?: string;
+    
     datasetId: string | undefined;
     
     changeType: ChangeType | string | undefined;
     
-    sourceType: SourceType | string | undefined;
-    
     sourceParams: {
         [key: string]: string;
     } | undefined;
     
-    formatType?: FormatType | string;
-    
-    formatParams?: {
+    formatParams: {
         [key: string]: string;
-    };
+    } | undefined;
+}
+export declare namespace CreateChangesetRequest {
+    
+    const filterSensitiveLog: (obj: CreateChangesetRequest) => any;
+}
+
+export interface CreateChangesetResponse {
+    
+    datasetId?: string;
+    
+    changesetId?: string;
+}
+export declare namespace CreateChangesetResponse {
+    
+    const filterSensitiveLog: (obj: CreateChangesetResponse) => any;
+}
+
+export interface InternalServerException extends __SmithyException, $MetadataBearer {
+    name: "InternalServerException";
+    $fault: "server";
+    message?: string;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    message?: string;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+}
+
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    message?: string;
+}
+export declare enum DatasetKind {
+    NON_TABULAR = "NON_TABULAR",
+    TABULAR = "TABULAR"
+}
+
+export interface DatasetOwnerInfo {
+    
+    name?: string;
+    
+    phoneNumber?: string;
+    
+    email?: string;
+}
+export declare namespace DatasetOwnerInfo {
+    
+    const filterSensitiveLog: (obj: DatasetOwnerInfo) => any;
+}
+
+export interface ResourcePermission {
+    
+    permission?: string;
+}
+export declare namespace ResourcePermission {
+    
+    const filterSensitiveLog: (obj: ResourcePermission) => any;
+}
+
+export interface PermissionGroupParams {
+    
+    permissionGroupId?: string;
+    
+    datasetPermissions?: ResourcePermission[];
+}
+export declare namespace PermissionGroupParams {
+    
+    const filterSensitiveLog: (obj: PermissionGroupParams) => any;
+}
+export declare enum ColumnDataType {
+    BIGINT = "BIGINT",
+    BINARY = "BINARY",
+    BOOLEAN = "BOOLEAN",
+    CHAR = "CHAR",
+    DATE = "DATE",
+    DATETIME = "DATETIME",
+    DOUBLE = "DOUBLE",
+    FLOAT = "FLOAT",
+    INTEGER = "INTEGER",
+    SMALLINT = "SMALLINT",
+    STRING = "STRING",
+    TINYINT = "TINYINT"
+}
+
+export interface ColumnDefinition {
+    
+    dataType?: ColumnDataType | string;
+    
+    columnName?: string;
+    
+    columnDescription?: string;
+}
+export declare namespace ColumnDefinition {
+    
+    const filterSensitiveLog: (obj: ColumnDefinition) => any;
+}
+
+export interface SchemaDefinition {
+    
+    columns?: ColumnDefinition[];
+    
+    primaryKeyColumns?: string[];
+}
+export declare namespace SchemaDefinition {
+    
+    const filterSensitiveLog: (obj: SchemaDefinition) => any;
+}
+
+export interface SchemaUnion {
+    
+    tabularSchemaConfig?: SchemaDefinition;
+}
+export declare namespace SchemaUnion {
     
-    tags?: {
+    const filterSensitiveLog: (obj: SchemaUnion) => any;
+}
+
+export interface CreateDatasetRequest {
+    
+    clientToken?: string;
+    
+    datasetTitle: string | undefined;
+    
+    kind: DatasetKind | string | undefined;
+    
+    datasetDescription?: string;
+    
+    ownerInfo?: DatasetOwnerInfo;
+    
+    permissionGroupParams: PermissionGroupParams | undefined;
+    
+    alias?: string;
+    
+    schemaDefinition?: SchemaUnion;
+}
+export declare namespace CreateDatasetRequest {
+    
+    const filterSensitiveLog: (obj: CreateDatasetRequest) => any;
+}
+
+export interface CreateDatasetResponse {
+    
+    datasetId?: string;
+}
+export declare namespace CreateDatasetResponse {
+    
+    const filterSensitiveLog: (obj: CreateDatasetResponse) => any;
+}
+export declare enum ExportFileFormat {
+    DELIMITED_TEXT = "DELIMITED_TEXT",
+    PARQUET = "PARQUET"
+}
+
+export interface DataViewDestinationTypeParams {
+    
+    destinationType: string | undefined;
+    
+    s3DestinationExportFileFormat?: ExportFileFormat | string;
+    s3DestinationExportFileFormatOptions?: {
         [key: string]: string;
     };
 }
-export declare namespace CreateChangesetRequest {
+export declare namespace DataViewDestinationTypeParams {
     
-    const filterSensitiveLog: (obj: CreateChangesetRequest) => any;
+    const filterSensitiveLog: (obj: DataViewDestinationTypeParams) => any;
+}
+
+export interface CreateDataViewRequest {
+    
+    clientToken?: string;
+    
+    datasetId: string | undefined;
+    
+    autoUpdate?: boolean;
+    
+    sortColumns?: string[];
+    
+    partitionColumns?: string[];
+    
+    asOfTimestamp?: number;
+    
+    destinationTypeParams: DataViewDestinationTypeParams | undefined;
+}
+export declare namespace CreateDataViewRequest {
+    
+    const filterSensitiveLog: (obj: CreateDataViewRequest) => any;
+}
+
+export interface CreateDataViewResponse {
+    
+    datasetId?: string;
+    
+    dataViewId?: string;
+}
+export declare namespace CreateDataViewResponse {
+    
+    const filterSensitiveLog: (obj: CreateDataViewResponse) => any;
+}
+
+export interface DeleteDatasetRequest {
+    
+    clientToken?: string;
+    
+    datasetId: string | undefined;
+}
+export declare namespace DeleteDatasetRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDatasetRequest) => any;
+}
+
+export interface DeleteDatasetResponse {
+    
+    datasetId?: string;
+}
+export declare namespace DeleteDatasetResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDatasetResponse) => any;
+}
+
+export interface GetChangesetRequest {
+    
+    datasetId: string | undefined;
+    
+    changesetId: string | undefined;
+}
+export declare namespace GetChangesetRequest {
+    
+    const filterSensitiveLog: (obj: GetChangesetRequest) => any;
 }
 export declare enum ErrorCategory {
-    ACCESS_DENIED = "Missing_required_permission_to_perform_this_request",
-    CANCELLED = "Cancelled",
-    INTERNAL_SERVICE_EXCEPTION = "An_internal_error_has_occurred",
-    RESOURCE_NOT_FOUND = "One_or_more_inputs_to_this_request_were_not_found",
-    SERVICE_QUOTA_EXCEEDED = "Service_limits_have_been_exceeded",
-    THROTTLING = "The_system_temporarily_lacks_sufficient_resources_to_process_the_request",
-    USER_RECOVERABLE = "A_user_recoverable_error_has_occurred",
-    VALIDATION = "The_inputs_to_this_request_are_invalid"
+    ACCESS_DENIED = "ACCESS_DENIED",
+    CANCELLED = "CANCELLED",
+    INTERNAL_SERVICE_EXCEPTION = "INTERNAL_SERVICE_EXCEPTION",
+    RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND",
+    SERVICE_QUOTA_EXCEEDED = "SERVICE_QUOTA_EXCEEDED",
+    THROTTLING = "THROTTLING",
+    USER_RECOVERABLE = "USER_RECOVERABLE",
+    VALIDATION = "VALIDATION"
 }
 
-export interface ErrorInfo {
+export interface ChangesetErrorInfo {
     
     errorMessage?: string;
     
     errorCategory?: ErrorCategory | string;
 }
-export declare namespace ErrorInfo {
+export declare namespace ChangesetErrorInfo {
     
-    const filterSensitiveLog: (obj: ErrorInfo) => any;
+    const filterSensitiveLog: (obj: ChangesetErrorInfo) => any;
 }
-export declare enum ChangesetStatus {
+export declare enum IngestionStatus {
     FAILED = "FAILED",
     PENDING = "PENDING",
     RUNNING = "RUNNING",
@@ -78,9 +303,9 @@ export declare enum ChangesetStatus {
     SUCCESS = "SUCCESS"
 }
 
-export interface ChangesetInfo {
+export interface GetChangesetResponse {
     
-    id?: string;
+    changesetId?: string;
     
     changesetArn?: string;
     
@@ -88,83 +313,138 @@ export interface ChangesetInfo {
     
     changeType?: ChangeType | string;
     
-    sourceType?: SourceType | string;
-    
     sourceParams?: {
         [key: string]: string;
     };
     
-    formatType?: FormatType | string;
-    
     formatParams?: {
         [key: string]: string;
     };
     
-    createTimestamp?: Date;
+    createTime?: number;
     
-    status?: ChangesetStatus | string;
+    status?: IngestionStatus | string;
     
-    errorInfo?: ErrorInfo;
+    errorInfo?: ChangesetErrorInfo;
     
-    changesetLabels?: {
-        [key: string]: string;
-    };
+    activeUntilTimestamp?: number;
+    
+    activeFromTimestamp?: number;
     
     updatesChangesetId?: string;
     
     updatedByChangesetId?: string;
 }
-export declare namespace ChangesetInfo {
+export declare namespace GetChangesetResponse {
     
-    const filterSensitiveLog: (obj: ChangesetInfo) => any;
+    const filterSensitiveLog: (obj: GetChangesetResponse) => any;
 }
-export interface CreateChangesetResponse {
+
+export interface GetDatasetRequest {
     
-    changeset?: ChangesetInfo;
+    datasetId: string | undefined;
 }
-export declare namespace CreateChangesetResponse {
+export declare namespace GetDatasetRequest {
     
-    const filterSensitiveLog: (obj: CreateChangesetResponse) => any;
+    const filterSensitiveLog: (obj: GetDatasetRequest) => any;
+}
+export declare enum DatasetStatus {
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    SUCCESS = "SUCCESS"
 }
 
-export interface InternalServerException extends __SmithyException, $MetadataBearer {
-    name: "InternalServerException";
-    $fault: "server";
-    message?: string;
+export interface GetDatasetResponse {
+    
+    datasetId?: string;
+    
+    datasetArn?: string;
+    
+    datasetTitle?: string;
+    
+    kind?: DatasetKind | string;
+    
+    datasetDescription?: string;
+    
+    createTime?: number;
+    
+    lastModifiedTime?: number;
+    
+    schemaDefinition?: SchemaUnion;
+    
+    alias?: string;
+    
+    status?: DatasetStatus | string;
 }
-export declare namespace InternalServerException {
+export declare namespace GetDatasetResponse {
     
-    const filterSensitiveLog: (obj: InternalServerException) => any;
+    const filterSensitiveLog: (obj: GetDatasetResponse) => any;
 }
 
-export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "ResourceNotFoundException";
-    $fault: "client";
-    message?: string;
+export interface GetDataViewRequest {
+    
+    dataViewId: string | undefined;
+    
+    datasetId: string | undefined;
 }
-export declare namespace ResourceNotFoundException {
+export declare namespace GetDataViewRequest {
     
-    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+    const filterSensitiveLog: (obj: GetDataViewRequest) => any;
 }
 
-export interface ThrottlingException extends __SmithyException, $MetadataBearer {
-    name: "ThrottlingException";
-    $fault: "client";
+export interface DataViewErrorInfo {
+    
+    errorMessage?: string;
+    
+    errorCategory?: ErrorCategory | string;
 }
-export declare namespace ThrottlingException {
+export declare namespace DataViewErrorInfo {
     
-    const filterSensitiveLog: (obj: ThrottlingException) => any;
+    const filterSensitiveLog: (obj: DataViewErrorInfo) => any;
+}
+export declare enum DataViewStatus {
+    CANCELLED = "CANCELLED",
+    FAILED = "FAILED",
+    FAILED_CLEANUP_FAILED = "FAILED_CLEANUP_FAILED",
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    STARTING = "STARTING",
+    SUCCESS = "SUCCESS",
+    TIMEOUT = "TIMEOUT"
 }
 
-export interface ValidationException extends __SmithyException, $MetadataBearer {
-    name: "ValidationException";
-    $fault: "client";
-    message?: string;
+export interface GetDataViewResponse {
+    
+    autoUpdate?: boolean;
+    
+    partitionColumns?: string[];
+    
+    datasetId?: string;
+    
+    asOfTimestamp?: number;
+    
+    errorInfo?: DataViewErrorInfo;
+    
+    lastModifiedTime?: number;
+    
+    createTime?: number;
+    
+    sortColumns?: string[];
+    
+    dataViewId?: string;
+    
+    dataViewArn?: string;
+    
+    destinationTypeParams?: DataViewDestinationTypeParams;
+    
+    status?: DataViewStatus | string;
 }
-export declare namespace ValidationException {
+export declare namespace GetDataViewResponse {
     
-    const filterSensitiveLog: (obj: ValidationException) => any;
+    const filterSensitiveLog: (obj: GetDataViewResponse) => any;
 }
+
 export interface GetProgrammaticAccessCredentialsRequest {
     
     durationInMinutes?: number;
@@ -188,6 +468,7 @@ export declare namespace Credentials {
     
     const filterSensitiveLog: (obj: Credentials) => any;
 }
+
 export interface GetProgrammaticAccessCredentialsResponse {
     
     credentials?: Credentials;
@@ -222,3 +503,229 @@ export declare namespace GetWorkingLocationResponse {
     
     const filterSensitiveLog: (obj: GetWorkingLocationResponse) => any;
 }
+
+export interface ListChangesetsRequest {
+    
+    datasetId: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListChangesetsRequest {
+    
+    const filterSensitiveLog: (obj: ListChangesetsRequest) => any;
+}
+
+export interface ChangesetSummary {
+    
+    changesetId?: string;
+    
+    changesetArn?: string;
+    
+    datasetId?: string;
+    
+    changeType?: ChangeType | string;
+    
+    sourceParams?: {
+        [key: string]: string;
+    };
+    
+    formatParams?: {
+        [key: string]: string;
+    };
+    
+    createTime?: number;
+    
+    status?: IngestionStatus | string;
+    
+    errorInfo?: ChangesetErrorInfo;
+    
+    activeUntilTimestamp?: number;
+    
+    activeFromTimestamp?: number;
+    
+    updatesChangesetId?: string;
+    
+    updatedByChangesetId?: string;
+}
+export declare namespace ChangesetSummary {
+    
+    const filterSensitiveLog: (obj: ChangesetSummary) => any;
+}
+
+export interface ListChangesetsResponse {
+    
+    changesets?: ChangesetSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListChangesetsResponse {
+    
+    const filterSensitiveLog: (obj: ListChangesetsResponse) => any;
+}
+
+export interface ListDatasetsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListDatasetsRequest {
+    
+    const filterSensitiveLog: (obj: ListDatasetsRequest) => any;
+}
+
+export interface Dataset {
+    
+    datasetId?: string;
+    
+    datasetArn?: string;
+    
+    datasetTitle?: string;
+    
+    kind?: DatasetKind | string;
+    
+    datasetDescription?: string;
+    
+    ownerInfo?: DatasetOwnerInfo;
+    
+    createTime?: number;
+    
+    lastModifiedTime?: number;
+    
+    schemaDefinition?: SchemaUnion;
+    
+    alias?: string;
+}
+export declare namespace Dataset {
+    
+    const filterSensitiveLog: (obj: Dataset) => any;
+}
+
+export interface ListDatasetsResponse {
+    
+    datasets?: Dataset[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDatasetsResponse {
+    
+    const filterSensitiveLog: (obj: ListDatasetsResponse) => any;
+}
+
+export interface ListDataViewsRequest {
+    
+    datasetId: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListDataViewsRequest {
+    
+    const filterSensitiveLog: (obj: ListDataViewsRequest) => any;
+}
+
+export interface DataViewSummary {
+    
+    dataViewId?: string;
+    
+    dataViewArn?: string;
+    
+    datasetId?: string;
+    
+    asOfTimestamp?: number;
+    
+    partitionColumns?: string[];
+    
+    sortColumns?: string[];
+    
+    status?: DataViewStatus | string;
+    
+    errorInfo?: DataViewErrorInfo;
+    
+    destinationTypeProperties?: DataViewDestinationTypeParams;
+    
+    autoUpdate?: boolean;
+    
+    createTime?: number;
+    
+    lastModifiedTime?: number;
+}
+export declare namespace DataViewSummary {
+    
+    const filterSensitiveLog: (obj: DataViewSummary) => any;
+}
+export interface ListDataViewsResponse {
+    
+    nextToken?: string;
+    
+    dataViews?: DataViewSummary[];
+}
+export declare namespace ListDataViewsResponse {
+    
+    const filterSensitiveLog: (obj: ListDataViewsResponse) => any;
+}
+
+export interface UpdateChangesetRequest {
+    
+    clientToken?: string;
+    
+    datasetId: string | undefined;
+    
+    changesetId: string | undefined;
+    
+    sourceParams: {
+        [key: string]: string;
+    } | undefined;
+    
+    formatParams: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace UpdateChangesetRequest {
+    
+    const filterSensitiveLog: (obj: UpdateChangesetRequest) => any;
+}
+
+export interface UpdateChangesetResponse {
+    
+    changesetId?: string;
+    
+    datasetId?: string;
+}
+export declare namespace UpdateChangesetResponse {
+    
+    const filterSensitiveLog: (obj: UpdateChangesetResponse) => any;
+}
+
+export interface UpdateDatasetRequest {
+    
+    clientToken?: string;
+    
+    datasetId: string | undefined;
+    
+    datasetTitle: string | undefined;
+    
+    kind: DatasetKind | string | undefined;
+    
+    datasetDescription?: string;
+    
+    alias?: string;
+    
+    schemaDefinition?: SchemaUnion;
+}
+export declare namespace UpdateDatasetRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDatasetRequest) => any;
+}
+
+export interface UpdateDatasetResponse {
+    
+    datasetId?: string;
+}
+export declare namespace UpdateDatasetResponse {
+    
+    const filterSensitiveLog: (obj: UpdateDatasetResponse) => any;
+}