@aws-sdk/client-athena 3.934.0 → 3.935.0

package/dist-es/models/models_0.js

@@ -1,218 +1 @@
-import { AthenaServiceException as __BaseException } from "./AthenaServiceException";
-export const S3AclOption = {
-    BUCKET_OWNER_FULL_CONTROL: "BUCKET_OWNER_FULL_CONTROL",
-};
-export class InternalServerException extends __BaseException {
-    name = "InternalServerException";
-    $fault = "server";
-    Message;
-    constructor(opts) {
-        super({
-            name: "InternalServerException",
-            $fault: "server",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, InternalServerException.prototype);
-        this.Message = opts.Message;
-    }
-}
-export class InvalidRequestException extends __BaseException {
-    name = "InvalidRequestException";
-    $fault = "client";
-    AthenaErrorCode;
-    Message;
-    constructor(opts) {
-        super({
-            name: "InvalidRequestException",
-            $fault: "client",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, InvalidRequestException.prototype);
-        this.AthenaErrorCode = opts.AthenaErrorCode;
-        this.Message = opts.Message;
-    }
-}
-export const AuthenticationType = {
-    DIRECTORY_IDENTITY: "DIRECTORY_IDENTITY",
-};
-export const EncryptionOption = {
-    CSE_KMS: "CSE_KMS",
-    SSE_KMS: "SSE_KMS",
-    SSE_S3: "SSE_S3",
-};
-export const StatementType = {
-    DDL: "DDL",
-    DML: "DML",
-    UTILITY: "UTILITY",
-};
-export const QueryExecutionState = {
-    CANCELLED: "CANCELLED",
-    FAILED: "FAILED",
-    QUEUED: "QUEUED",
-    RUNNING: "RUNNING",
-    SUCCEEDED: "SUCCEEDED",
-};
-export const DataCatalogType = {
-    FEDERATED: "FEDERATED",
-    GLUE: "GLUE",
-    HIVE: "HIVE",
-    LAMBDA: "LAMBDA",
-};
-export const ConnectionType = {
-    BIGQUERY: "BIGQUERY",
-    CMDB: "CMDB",
-    DATALAKEGEN2: "DATALAKEGEN2",
-    DB2: "DB2",
-    DB2AS400: "DB2AS400",
-    DOCUMENTDB: "DOCUMENTDB",
-    DYNAMODB: "DYNAMODB",
-    GOOGLECLOUDSTORAGE: "GOOGLECLOUDSTORAGE",
-    HBASE: "HBASE",
-    MYSQL: "MYSQL",
-    OPENSEARCH: "OPENSEARCH",
-    ORACLE: "ORACLE",
-    POSTGRESQL: "POSTGRESQL",
-    REDSHIFT: "REDSHIFT",
-    SAPHANA: "SAPHANA",
-    SNOWFLAKE: "SNOWFLAKE",
-    SQLSERVER: "SQLSERVER",
-    SYNAPSE: "SYNAPSE",
-    TIMESTREAM: "TIMESTREAM",
-    TPCDS: "TPCDS",
-};
-export const DataCatalogStatus = {
-    CREATE_COMPLETE: "CREATE_COMPLETE",
-    CREATE_FAILED: "CREATE_FAILED",
-    CREATE_FAILED_CLEANUP_COMPLETE: "CREATE_FAILED_CLEANUP_COMPLETE",
-    CREATE_FAILED_CLEANUP_FAILED: "CREATE_FAILED_CLEANUP_FAILED",
-    CREATE_FAILED_CLEANUP_IN_PROGRESS: "CREATE_FAILED_CLEANUP_IN_PROGRESS",
-    CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
-    DELETE_COMPLETE: "DELETE_COMPLETE",
-    DELETE_FAILED: "DELETE_FAILED",
-    DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
-};
-export const ThrottleReason = {
-    CONCURRENT_QUERY_LIMIT_EXCEEDED: "CONCURRENT_QUERY_LIMIT_EXCEEDED",
-};
-export class TooManyRequestsException extends __BaseException {
-    name = "TooManyRequestsException";
-    $fault = "client";
-    Message;
-    Reason;
-    constructor(opts) {
-        super({
-            name: "TooManyRequestsException",
-            $fault: "client",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, TooManyRequestsException.prototype);
-        this.Message = opts.Message;
-        this.Reason = opts.Reason;
-    }
-}
-export class ResourceNotFoundException extends __BaseException {
-    name = "ResourceNotFoundException";
-    $fault = "client";
-    Message;
-    ResourceName;
-    constructor(opts) {
-        super({
-            name: "ResourceNotFoundException",
-            $fault: "client",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
-        this.Message = opts.Message;
-        this.ResourceName = opts.ResourceName;
-    }
-}
-export const NotebookType = {
-    IPYNB: "IPYNB",
-};
-export const CalculationExecutionState = {
-    CANCELED: "CANCELED",
-    CANCELING: "CANCELING",
-    COMPLETED: "COMPLETED",
-    CREATED: "CREATED",
-    CREATING: "CREATING",
-    FAILED: "FAILED",
-    QUEUED: "QUEUED",
-    RUNNING: "RUNNING",
-};
-export const CapacityAllocationStatus = {
-    FAILED: "FAILED",
-    PENDING: "PENDING",
-    SUCCEEDED: "SUCCEEDED",
-};
-export const CapacityReservationStatus = {
-    ACTIVE: "ACTIVE",
-    CANCELLED: "CANCELLED",
-    CANCELLING: "CANCELLING",
-    FAILED: "FAILED",
-    PENDING: "PENDING",
-    UPDATE_PENDING: "UPDATE_PENDING",
-};
-export class MetadataException extends __BaseException {
-    name = "MetadataException";
-    $fault = "client";
-    Message;
-    constructor(opts) {
-        super({
-            name: "MetadataException",
-            $fault: "client",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, MetadataException.prototype);
-        this.Message = opts.Message;
-    }
-}
-export const QueryResultType = {
-    DATA_MANIFEST: "DATA_MANIFEST",
-    DATA_ROWS: "DATA_ROWS",
-};
-export const ColumnNullable = {
-    NOT_NULL: "NOT_NULL",
-    NULLABLE: "NULLABLE",
-    UNKNOWN: "UNKNOWN",
-};
-export const SessionState = {
-    BUSY: "BUSY",
-    CREATED: "CREATED",
-    CREATING: "CREATING",
-    DEGRADED: "DEGRADED",
-    FAILED: "FAILED",
-    IDLE: "IDLE",
-    TERMINATED: "TERMINATED",
-    TERMINATING: "TERMINATING",
-};
-export const WorkGroupState = {
-    DISABLED: "DISABLED",
-    ENABLED: "ENABLED",
-};
-export const ExecutorState = {
-    CREATED: "CREATED",
-    CREATING: "CREATING",
-    FAILED: "FAILED",
-    REGISTERED: "REGISTERED",
-    TERMINATED: "TERMINATED",
-    TERMINATING: "TERMINATING",
-};
-export const ExecutorType = {
-    COORDINATOR: "COORDINATOR",
-    GATEWAY: "GATEWAY",
-    WORKER: "WORKER",
-};
-export class SessionAlreadyExistsException extends __BaseException {
-    name = "SessionAlreadyExistsException";
-    $fault = "client";
-    Message;
-    constructor(opts) {
-        super({
-            name: "SessionAlreadyExistsException",
-            $fault: "client",
-            ...opts,
-        });
-        Object.setPrototypeOf(this, SessionAlreadyExistsException.prototype);
-        this.Message = opts.Message;
-    }
-}
+export {};

package/dist-es/schemas/schemas_0.js

@@ -488,7 +488,7 @@ const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.athena";
 const n0 = "com.amazonaws.athena";
 import { TypeRegistry } from "@smithy/core/schema";
 import { AthenaServiceException as __AthenaServiceException } from "../models/AthenaServiceException";
-import { InternalServerException as __InternalServerException, InvalidRequestException as __InvalidRequestException, MetadataException as __MetadataException, ResourceNotFoundException as __ResourceNotFoundException, SessionAlreadyExistsException as __SessionAlreadyExistsException, TooManyRequestsException as __TooManyRequestsException, } from "../models/index";
+import { InternalServerException as __InternalServerException, InvalidRequestException as __InvalidRequestException, MetadataException as __MetadataException, ResourceNotFoundException as __ResourceNotFoundException, SessionAlreadyExistsException as __SessionAlreadyExistsException, TooManyRequestsException as __TooManyRequestsException, } from "../models/errors";
 export var AclConfiguration = [3, n0, _AC, 0, [_SAO], [0]];
 export var ApplicationDPUSizes = [3, n0, _ADPUS, 0, [_ARI, _SDPUS], [0, 64 | 1]];
 export var AthenaError = [3, n0, _AE, 0, [_EC, _ET, _R, _EM], [1, 1, 2, 0]];

package/dist-types/index.d.ts

@@ -20,5 +20,7 @@ export type { RuntimeExtension } from "./runtimeExtensions";
 export type { AthenaExtensionConfiguration } from "./extensionConfiguration";
 export * from "./commands";
 export * from "./pagination";
-export * from "./models";
+export * from "./models/enums";
+export * from "./models/errors";
+export type * from "./models/models_0";
 export { AthenaServiceException } from "./models/AthenaServiceException";

package/dist-types/models/enums.d.ts

@@ -0,0 +1,279 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const S3AclOption: {
+    readonly BUCKET_OWNER_FULL_CONTROL: "BUCKET_OWNER_FULL_CONTROL";
+};
+/**
+ * @public
+ */
+export type S3AclOption = (typeof S3AclOption)[keyof typeof S3AclOption];
+/**
+ * @public
+ * @enum
+ */
+export declare const AuthenticationType: {
+    readonly DIRECTORY_IDENTITY: "DIRECTORY_IDENTITY";
+};
+/**
+ * @public
+ */
+export type AuthenticationType = (typeof AuthenticationType)[keyof typeof AuthenticationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const EncryptionOption: {
+    readonly CSE_KMS: "CSE_KMS";
+    readonly SSE_KMS: "SSE_KMS";
+    readonly SSE_S3: "SSE_S3";
+};
+/**
+ * @public
+ */
+export type EncryptionOption = (typeof EncryptionOption)[keyof typeof EncryptionOption];
+/**
+ * @public
+ * @enum
+ */
+export declare const StatementType: {
+    readonly DDL: "DDL";
+    readonly DML: "DML";
+    readonly UTILITY: "UTILITY";
+};
+/**
+ * @public
+ */
+export type StatementType = (typeof StatementType)[keyof typeof StatementType];
+/**
+ * @public
+ * @enum
+ */
+export declare const QueryExecutionState: {
+    readonly CANCELLED: "CANCELLED";
+    readonly FAILED: "FAILED";
+    readonly QUEUED: "QUEUED";
+    readonly RUNNING: "RUNNING";
+    readonly SUCCEEDED: "SUCCEEDED";
+};
+/**
+ * @public
+ */
+export type QueryExecutionState = (typeof QueryExecutionState)[keyof typeof QueryExecutionState];
+/**
+ * @public
+ * @enum
+ */
+export declare const DataCatalogType: {
+    readonly FEDERATED: "FEDERATED";
+    readonly GLUE: "GLUE";
+    readonly HIVE: "HIVE";
+    readonly LAMBDA: "LAMBDA";
+};
+/**
+ * @public
+ */
+export type DataCatalogType = (typeof DataCatalogType)[keyof typeof DataCatalogType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConnectionType: {
+    readonly BIGQUERY: "BIGQUERY";
+    readonly CMDB: "CMDB";
+    readonly DATALAKEGEN2: "DATALAKEGEN2";
+    readonly DB2: "DB2";
+    readonly DB2AS400: "DB2AS400";
+    readonly DOCUMENTDB: "DOCUMENTDB";
+    readonly DYNAMODB: "DYNAMODB";
+    readonly GOOGLECLOUDSTORAGE: "GOOGLECLOUDSTORAGE";
+    readonly HBASE: "HBASE";
+    readonly MYSQL: "MYSQL";
+    readonly OPENSEARCH: "OPENSEARCH";
+    readonly ORACLE: "ORACLE";
+    readonly POSTGRESQL: "POSTGRESQL";
+    readonly REDSHIFT: "REDSHIFT";
+    readonly SAPHANA: "SAPHANA";
+    readonly SNOWFLAKE: "SNOWFLAKE";
+    readonly SQLSERVER: "SQLSERVER";
+    readonly SYNAPSE: "SYNAPSE";
+    readonly TIMESTREAM: "TIMESTREAM";
+    readonly TPCDS: "TPCDS";
+};
+/**
+ * @public
+ */
+export type ConnectionType = (typeof ConnectionType)[keyof typeof ConnectionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const DataCatalogStatus: {
+    readonly CREATE_COMPLETE: "CREATE_COMPLETE";
+    readonly CREATE_FAILED: "CREATE_FAILED";
+    readonly CREATE_FAILED_CLEANUP_COMPLETE: "CREATE_FAILED_CLEANUP_COMPLETE";
+    readonly CREATE_FAILED_CLEANUP_FAILED: "CREATE_FAILED_CLEANUP_FAILED";
+    readonly CREATE_FAILED_CLEANUP_IN_PROGRESS: "CREATE_FAILED_CLEANUP_IN_PROGRESS";
+    readonly CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS";
+    readonly DELETE_COMPLETE: "DELETE_COMPLETE";
+    readonly DELETE_FAILED: "DELETE_FAILED";
+    readonly DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS";
+};
+/**
+ * @public
+ */
+export type DataCatalogStatus = (typeof DataCatalogStatus)[keyof typeof DataCatalogStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ThrottleReason: {
+    readonly CONCURRENT_QUERY_LIMIT_EXCEEDED: "CONCURRENT_QUERY_LIMIT_EXCEEDED";
+};
+/**
+ * @public
+ */
+export type ThrottleReason = (typeof ThrottleReason)[keyof typeof ThrottleReason];
+/**
+ * @public
+ * @enum
+ */
+export declare const NotebookType: {
+    readonly IPYNB: "IPYNB";
+};
+/**
+ * @public
+ */
+export type NotebookType = (typeof NotebookType)[keyof typeof NotebookType];
+/**
+ * @public
+ * @enum
+ */
+export declare const CalculationExecutionState: {
+    readonly CANCELED: "CANCELED";
+    readonly CANCELING: "CANCELING";
+    readonly COMPLETED: "COMPLETED";
+    readonly CREATED: "CREATED";
+    readonly CREATING: "CREATING";
+    readonly FAILED: "FAILED";
+    readonly QUEUED: "QUEUED";
+    readonly RUNNING: "RUNNING";
+};
+/**
+ * @public
+ */
+export type CalculationExecutionState = (typeof CalculationExecutionState)[keyof typeof CalculationExecutionState];
+/**
+ * @public
+ * @enum
+ */
+export declare const CapacityAllocationStatus: {
+    readonly FAILED: "FAILED";
+    readonly PENDING: "PENDING";
+    readonly SUCCEEDED: "SUCCEEDED";
+};
+/**
+ * @public
+ */
+export type CapacityAllocationStatus = (typeof CapacityAllocationStatus)[keyof typeof CapacityAllocationStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const CapacityReservationStatus: {
+    readonly ACTIVE: "ACTIVE";
+    readonly CANCELLED: "CANCELLED";
+    readonly CANCELLING: "CANCELLING";
+    readonly FAILED: "FAILED";
+    readonly PENDING: "PENDING";
+    readonly UPDATE_PENDING: "UPDATE_PENDING";
+};
+/**
+ * @public
+ */
+export type CapacityReservationStatus = (typeof CapacityReservationStatus)[keyof typeof CapacityReservationStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const QueryResultType: {
+    readonly DATA_MANIFEST: "DATA_MANIFEST";
+    readonly DATA_ROWS: "DATA_ROWS";
+};
+/**
+ * @public
+ */
+export type QueryResultType = (typeof QueryResultType)[keyof typeof QueryResultType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ColumnNullable: {
+    readonly NOT_NULL: "NOT_NULL";
+    readonly NULLABLE: "NULLABLE";
+    readonly UNKNOWN: "UNKNOWN";
+};
+/**
+ * @public
+ */
+export type ColumnNullable = (typeof ColumnNullable)[keyof typeof ColumnNullable];
+/**
+ * @public
+ * @enum
+ */
+export declare const SessionState: {
+    readonly BUSY: "BUSY";
+    readonly CREATED: "CREATED";
+    readonly CREATING: "CREATING";
+    readonly DEGRADED: "DEGRADED";
+    readonly FAILED: "FAILED";
+    readonly IDLE: "IDLE";
+    readonly TERMINATED: "TERMINATED";
+    readonly TERMINATING: "TERMINATING";
+};
+/**
+ * @public
+ */
+export type SessionState = (typeof SessionState)[keyof typeof SessionState];
+/**
+ * @public
+ * @enum
+ */
+export declare const WorkGroupState: {
+    readonly DISABLED: "DISABLED";
+    readonly ENABLED: "ENABLED";
+};
+/**
+ * @public
+ */
+export type WorkGroupState = (typeof WorkGroupState)[keyof typeof WorkGroupState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExecutorState: {
+    readonly CREATED: "CREATED";
+    readonly CREATING: "CREATING";
+    readonly FAILED: "FAILED";
+    readonly REGISTERED: "REGISTERED";
+    readonly TERMINATED: "TERMINATED";
+    readonly TERMINATING: "TERMINATING";
+};
+/**
+ * @public
+ */
+export type ExecutorState = (typeof ExecutorState)[keyof typeof ExecutorState];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExecutorType: {
+    readonly COORDINATOR: "COORDINATOR";
+    readonly GATEWAY: "GATEWAY";
+    readonly WORKER: "WORKER";
+};
+/**
+ * @public
+ */
+export type ExecutorType = (typeof ExecutorType)[keyof typeof ExecutorType];

package/dist-types/models/errors.d.ts

@@ -0,0 +1,105 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { AthenaServiceException as __BaseException } from "./AthenaServiceException";
+import { ThrottleReason } from "./enums";
+/**
+ * <p>Indicates a platform issue, which may be due to a transient condition or
+ *             outage.</p>
+ * @public
+ */
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+/**
+ * <p>Indicates that something is wrong with the input to the request. For example, a
+ *             required parameter may be missing or out of range.</p>
+ * @public
+ */
+export declare class InvalidRequestException extends __BaseException {
+    readonly name: "InvalidRequestException";
+    readonly $fault: "client";
+    /**
+     * <p>The error code returned when the query execution failed to process, or when the
+     *             processing request for the named query failed.</p>
+     * @public
+     */
+    AthenaErrorCode?: string | undefined;
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidRequestException, __BaseException>);
+}
+/**
+ * <p>Indicates that the request was throttled.</p>
+ * @public
+ */
+export declare class TooManyRequestsException extends __BaseException {
+    readonly name: "TooManyRequestsException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * <p>The reason for the query throttling, for example, when it exceeds the concurrent query
+     *             limit.</p>
+     * @public
+     */
+    Reason?: ThrottleReason | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TooManyRequestsException, __BaseException>);
+}
+/**
+ * <p>A resource, such as a workgroup, was not found.</p>
+ * @public
+ */
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * <p>The name of the Amazon resource.</p>
+     * @public
+     */
+    ResourceName?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+/**
+ * <p>An exception that Athena received when it called a custom metastore.
+ *             Occurs if the error is not caused by user input (<code>InvalidRequestException</code>)
+ *             or from the Athena platform (<code>InternalServerException</code>). For
+ *             example, if a user-created Lambda function is missing permissions, the
+ *                 Lambda
+ *             <code>4XX</code> exception is returned in a <code>MetadataException</code>.</p>
+ * @public
+ */
+export declare class MetadataException extends __BaseException {
+    readonly name: "MetadataException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<MetadataException, __BaseException>);
+}
+/**
+ * <p>The specified session already exists.</p>
+ * @public
+ */
+export declare class SessionAlreadyExistsException extends __BaseException {
+    readonly name: "SessionAlreadyExistsException";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SessionAlreadyExistsException, __BaseException>);
+}