@aws-sdk/client-finspace-data 3.50.0 → 3.53.0

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

@@ -0,0 +1,741 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { FinspaceDataServiceException as __BaseException } from "./FinspaceDataServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+export declare enum ChangeType {
+    APPEND = "APPEND",
+    MODIFY = "MODIFY",
+    REPLACE = "REPLACE"
+}
+
+export interface CreateChangesetRequest {
+    
+    clientToken?: string;
+    
+    datasetId: string | undefined;
+    
+    changeType: ChangeType | string | undefined;
+    
+    sourceParams: {
+        [key: string]: string;
+    } | undefined;
+    
+    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 declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+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 {
+    
+    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 DataViewDestinationTypeParams {
+    
+    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 = "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 ChangesetErrorInfo {
+    
+    errorMessage?: string;
+    
+    errorCategory?: ErrorCategory | string;
+}
+export declare namespace ChangesetErrorInfo {
+    
+    const filterSensitiveLog: (obj: ChangesetErrorInfo) => any;
+}
+export declare enum IngestionStatus {
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    STOP_REQUESTED = "STOP_REQUESTED",
+    SUCCESS = "SUCCESS"
+}
+
+export interface GetChangesetResponse {
+    
+    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 GetChangesetResponse {
+    
+    const filterSensitiveLog: (obj: GetChangesetResponse) => any;
+}
+
+export interface GetDatasetRequest {
+    
+    datasetId: string | undefined;
+}
+export declare namespace GetDatasetRequest {
+    
+    const filterSensitiveLog: (obj: GetDatasetRequest) => any;
+}
+export declare enum DatasetStatus {
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    SUCCESS = "SUCCESS"
+}
+
+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 GetDatasetResponse {
+    
+    const filterSensitiveLog: (obj: GetDatasetResponse) => any;
+}
+
+export interface GetDataViewRequest {
+    
+    dataViewId: string | undefined;
+    
+    datasetId: string | undefined;
+}
+export declare namespace GetDataViewRequest {
+    
+    const filterSensitiveLog: (obj: GetDataViewRequest) => any;
+}
+
+export interface DataViewErrorInfo {
+    
+    errorMessage?: string;
+    
+    errorCategory?: ErrorCategory | string;
+}
+export declare namespace DataViewErrorInfo {
+    
+    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 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 GetDataViewResponse {
+    
+    const filterSensitiveLog: (obj: GetDataViewResponse) => any;
+}
+
+export interface GetProgrammaticAccessCredentialsRequest {
+    
+    durationInMinutes?: number;
+    
+    environmentId: string | undefined;
+}
+export declare namespace GetProgrammaticAccessCredentialsRequest {
+    
+    const filterSensitiveLog: (obj: GetProgrammaticAccessCredentialsRequest) => any;
+}
+
+export interface Credentials {
+    
+    accessKeyId?: string;
+    
+    secretAccessKey?: string;
+    
+    sessionToken?: string;
+}
+export declare namespace Credentials {
+    
+    const filterSensitiveLog: (obj: Credentials) => any;
+}
+
+export interface GetProgrammaticAccessCredentialsResponse {
+    
+    credentials?: Credentials;
+    
+    durationInMinutes?: number;
+}
+export declare namespace GetProgrammaticAccessCredentialsResponse {
+    
+    const filterSensitiveLog: (obj: GetProgrammaticAccessCredentialsResponse) => any;
+}
+export declare enum LocationType {
+    INGESTION = "INGESTION",
+    SAGEMAKER = "SAGEMAKER"
+}
+export interface GetWorkingLocationRequest {
+    
+    locationType?: LocationType | string;
+}
+export declare namespace GetWorkingLocationRequest {
+    
+    const filterSensitiveLog: (obj: GetWorkingLocationRequest) => any;
+}
+export interface GetWorkingLocationResponse {
+    
+    s3Uri?: string;
+    
+    s3Path?: string;
+    
+    s3Bucket?: string;
+}
+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;
+}