@aws-sdk/client-firehose 3.933.0 → 3.935.0

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

@@ -0,0 +1,445 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const ProcessorParameterName: {
+    readonly BUFFER_INTERVAL_IN_SECONDS: "BufferIntervalInSeconds";
+    readonly BUFFER_SIZE_IN_MB: "BufferSizeInMBs";
+    readonly COMPRESSION_FORMAT: "CompressionFormat";
+    readonly DATA_MESSAGE_EXTRACTION: "DataMessageExtraction";
+    readonly Delimiter: "Delimiter";
+    readonly JSON_PARSING_ENGINE: "JsonParsingEngine";
+    readonly LAMBDA_ARN: "LambdaArn";
+    readonly LAMBDA_NUMBER_OF_RETRIES: "NumberOfRetries";
+    readonly METADATA_EXTRACTION_QUERY: "MetadataExtractionQuery";
+    readonly ROLE_ARN: "RoleArn";
+    readonly SUB_RECORD_TYPE: "SubRecordType";
+};
+/**
+ * @public
+ */
+export type ProcessorParameterName = (typeof ProcessorParameterName)[keyof typeof ProcessorParameterName];
+/**
+ * @public
+ * @enum
+ */
+export declare const ProcessorType: {
+    readonly AppendDelimiterToRecord: "AppendDelimiterToRecord";
+    readonly CloudWatchLogProcessing: "CloudWatchLogProcessing";
+    readonly Decompression: "Decompression";
+    readonly Lambda: "Lambda";
+    readonly MetadataExtraction: "MetadataExtraction";
+    readonly RecordDeAggregation: "RecordDeAggregation";
+};
+/**
+ * @public
+ */
+export type ProcessorType = (typeof ProcessorType)[keyof typeof ProcessorType];
+/**
+ * @public
+ * @enum
+ */
+export declare const AmazonOpenSearchServerlessS3BackupMode: {
+    readonly AllDocuments: "AllDocuments";
+    readonly FailedDocumentsOnly: "FailedDocumentsOnly";
+};
+/**
+ * @public
+ */
+export type AmazonOpenSearchServerlessS3BackupMode = (typeof AmazonOpenSearchServerlessS3BackupMode)[keyof typeof AmazonOpenSearchServerlessS3BackupMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const CompressionFormat: {
+    readonly GZIP: "GZIP";
+    readonly HADOOP_SNAPPY: "HADOOP_SNAPPY";
+    readonly SNAPPY: "Snappy";
+    readonly UNCOMPRESSED: "UNCOMPRESSED";
+    readonly ZIP: "ZIP";
+};
+/**
+ * @public
+ */
+export type CompressionFormat = (typeof CompressionFormat)[keyof typeof CompressionFormat];
+/**
+ * @public
+ * @enum
+ */
+export declare const NoEncryptionConfig: {
+    readonly NoEncryption: "NoEncryption";
+};
+/**
+ * @public
+ */
+export type NoEncryptionConfig = (typeof NoEncryptionConfig)[keyof typeof NoEncryptionConfig];
+/**
+ * @public
+ * @enum
+ */
+export declare const DefaultDocumentIdFormat: {
+    readonly FIREHOSE_DEFAULT: "FIREHOSE_DEFAULT";
+    readonly NO_DOCUMENT_ID: "NO_DOCUMENT_ID";
+};
+/**
+ * @public
+ */
+export type DefaultDocumentIdFormat = (typeof DefaultDocumentIdFormat)[keyof typeof DefaultDocumentIdFormat];
+/**
+ * @public
+ * @enum
+ */
+export declare const AmazonopensearchserviceIndexRotationPeriod: {
+    readonly NoRotation: "NoRotation";
+    readonly OneDay: "OneDay";
+    readonly OneHour: "OneHour";
+    readonly OneMonth: "OneMonth";
+    readonly OneWeek: "OneWeek";
+};
+/**
+ * @public
+ */
+export type AmazonopensearchserviceIndexRotationPeriod = (typeof AmazonopensearchserviceIndexRotationPeriod)[keyof typeof AmazonopensearchserviceIndexRotationPeriod];
+/**
+ * @public
+ * @enum
+ */
+export declare const AmazonopensearchserviceS3BackupMode: {
+    readonly AllDocuments: "AllDocuments";
+    readonly FailedDocumentsOnly: "FailedDocumentsOnly";
+};
+/**
+ * @public
+ */
+export type AmazonopensearchserviceS3BackupMode = (typeof AmazonopensearchserviceS3BackupMode)[keyof typeof AmazonopensearchserviceS3BackupMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const Connectivity: {
+    readonly PRIVATE: "PRIVATE";
+    readonly PUBLIC: "PUBLIC";
+};
+/**
+ * @public
+ */
+export type Connectivity = (typeof Connectivity)[keyof typeof Connectivity];
+/**
+ * @public
+ * @enum
+ */
+export declare const ContentEncoding: {
+    readonly GZIP: "GZIP";
+    readonly NONE: "NONE";
+};
+/**
+ * @public
+ */
+export type ContentEncoding = (typeof ContentEncoding)[keyof typeof ContentEncoding];
+/**
+ * @public
+ * @enum
+ */
+export declare const SSLMode: {
+    readonly Disabled: "Disabled";
+    readonly Enabled: "Enabled";
+};
+/**
+ * @public
+ */
+export type SSLMode = (typeof SSLMode)[keyof typeof SSLMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const DatabaseType: {
+    readonly MySQL: "MySQL";
+    readonly PostgreSQL: "PostgreSQL";
+};
+/**
+ * @public
+ */
+export type DatabaseType = (typeof DatabaseType)[keyof typeof DatabaseType];
+/**
+ * @public
+ * @enum
+ */
+export declare const KeyType: {
+    readonly AWS_OWNED_CMK: "AWS_OWNED_CMK";
+    readonly CUSTOMER_MANAGED_CMK: "CUSTOMER_MANAGED_CMK";
+};
+/**
+ * @public
+ */
+export type KeyType = (typeof KeyType)[keyof typeof KeyType];
+/**
+ * @public
+ * @enum
+ */
+export declare const DeliveryStreamType: {
+    readonly DatabaseAsSource: "DatabaseAsSource";
+    readonly DirectPut: "DirectPut";
+    readonly KinesisStreamAsSource: "KinesisStreamAsSource";
+    readonly MSKAsSource: "MSKAsSource";
+};
+/**
+ * @public
+ */
+export type DeliveryStreamType = (typeof DeliveryStreamType)[keyof typeof DeliveryStreamType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ElasticsearchIndexRotationPeriod: {
+    readonly NoRotation: "NoRotation";
+    readonly OneDay: "OneDay";
+    readonly OneHour: "OneHour";
+    readonly OneMonth: "OneMonth";
+    readonly OneWeek: "OneWeek";
+};
+/**
+ * @public
+ */
+export type ElasticsearchIndexRotationPeriod = (typeof ElasticsearchIndexRotationPeriod)[keyof typeof ElasticsearchIndexRotationPeriod];
+/**
+ * @public
+ * @enum
+ */
+export declare const ElasticsearchS3BackupMode: {
+    readonly AllDocuments: "AllDocuments";
+    readonly FailedDocumentsOnly: "FailedDocumentsOnly";
+};
+/**
+ * @public
+ */
+export type ElasticsearchS3BackupMode = (typeof ElasticsearchS3BackupMode)[keyof typeof ElasticsearchS3BackupMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const OrcCompression: {
+    readonly NONE: "NONE";
+    readonly SNAPPY: "SNAPPY";
+    readonly ZLIB: "ZLIB";
+};
+/**
+ * @public
+ */
+export type OrcCompression = (typeof OrcCompression)[keyof typeof OrcCompression];
+/**
+ * @public
+ * @enum
+ */
+export declare const OrcFormatVersion: {
+    readonly V0_11: "V0_11";
+    readonly V0_12: "V0_12";
+};
+/**
+ * @public
+ */
+export type OrcFormatVersion = (typeof OrcFormatVersion)[keyof typeof OrcFormatVersion];
+/**
+ * @public
+ * @enum
+ */
+export declare const ParquetCompression: {
+    readonly GZIP: "GZIP";
+    readonly SNAPPY: "SNAPPY";
+    readonly UNCOMPRESSED: "UNCOMPRESSED";
+};
+/**
+ * @public
+ */
+export type ParquetCompression = (typeof ParquetCompression)[keyof typeof ParquetCompression];
+/**
+ * @public
+ * @enum
+ */
+export declare const ParquetWriterVersion: {
+    readonly V1: "V1";
+    readonly V2: "V2";
+};
+/**
+ * @public
+ */
+export type ParquetWriterVersion = (typeof ParquetWriterVersion)[keyof typeof ParquetWriterVersion];
+/**
+ * @public
+ * @enum
+ */
+export declare const S3BackupMode: {
+    readonly Disabled: "Disabled";
+    readonly Enabled: "Enabled";
+};
+/**
+ * @public
+ */
+export type S3BackupMode = (typeof S3BackupMode)[keyof typeof S3BackupMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const HttpEndpointS3BackupMode: {
+    readonly AllData: "AllData";
+    readonly FailedDataOnly: "FailedDataOnly";
+};
+/**
+ * @public
+ */
+export type HttpEndpointS3BackupMode = (typeof HttpEndpointS3BackupMode)[keyof typeof HttpEndpointS3BackupMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const IcebergS3BackupMode: {
+    readonly AllData: "AllData";
+    readonly FailedDataOnly: "FailedDataOnly";
+};
+/**
+ * @public
+ */
+export type IcebergS3BackupMode = (typeof IcebergS3BackupMode)[keyof typeof IcebergS3BackupMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const RedshiftS3BackupMode: {
+    readonly Disabled: "Disabled";
+    readonly Enabled: "Enabled";
+};
+/**
+ * @public
+ */
+export type RedshiftS3BackupMode = (typeof RedshiftS3BackupMode)[keyof typeof RedshiftS3BackupMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const SnowflakeDataLoadingOption: {
+    readonly JSON_MAPPING: "JSON_MAPPING";
+    readonly VARIANT_CONTENT_AND_METADATA_MAPPING: "VARIANT_CONTENT_AND_METADATA_MAPPING";
+    readonly VARIANT_CONTENT_MAPPING: "VARIANT_CONTENT_MAPPING";
+};
+/**
+ * @public
+ */
+export type SnowflakeDataLoadingOption = (typeof SnowflakeDataLoadingOption)[keyof typeof SnowflakeDataLoadingOption];
+/**
+ * @public
+ * @enum
+ */
+export declare const SnowflakeS3BackupMode: {
+    readonly AllData: "AllData";
+    readonly FailedDataOnly: "FailedDataOnly";
+};
+/**
+ * @public
+ */
+export type SnowflakeS3BackupMode = (typeof SnowflakeS3BackupMode)[keyof typeof SnowflakeS3BackupMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const HECEndpointType: {
+    readonly Event: "Event";
+    readonly Raw: "Raw";
+};
+/**
+ * @public
+ */
+export type HECEndpointType = (typeof HECEndpointType)[keyof typeof HECEndpointType];
+/**
+ * @public
+ * @enum
+ */
+export declare const SplunkS3BackupMode: {
+    readonly AllEvents: "AllEvents";
+    readonly FailedEventsOnly: "FailedEventsOnly";
+};
+/**
+ * @public
+ */
+export type SplunkS3BackupMode = (typeof SplunkS3BackupMode)[keyof typeof SplunkS3BackupMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const DeliveryStreamFailureType: {
+    readonly CREATE_ENI_FAILED: "CREATE_ENI_FAILED";
+    readonly CREATE_KMS_GRANT_FAILED: "CREATE_KMS_GRANT_FAILED";
+    readonly DELETE_ENI_FAILED: "DELETE_ENI_FAILED";
+    readonly DISABLED_KMS_KEY: "DISABLED_KMS_KEY";
+    readonly ENI_ACCESS_DENIED: "ENI_ACCESS_DENIED";
+    readonly INVALID_KMS_KEY: "INVALID_KMS_KEY";
+    readonly KMS_ACCESS_DENIED: "KMS_ACCESS_DENIED";
+    readonly KMS_KEY_NOT_FOUND: "KMS_KEY_NOT_FOUND";
+    readonly KMS_OPT_IN_REQUIRED: "KMS_OPT_IN_REQUIRED";
+    readonly RETIRE_KMS_GRANT_FAILED: "RETIRE_KMS_GRANT_FAILED";
+    readonly SECURITY_GROUP_ACCESS_DENIED: "SECURITY_GROUP_ACCESS_DENIED";
+    readonly SECURITY_GROUP_NOT_FOUND: "SECURITY_GROUP_NOT_FOUND";
+    readonly SUBNET_ACCESS_DENIED: "SUBNET_ACCESS_DENIED";
+    readonly SUBNET_NOT_FOUND: "SUBNET_NOT_FOUND";
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+    readonly VPC_ENDPOINT_SERVICE_NAME_NOT_FOUND: "VPC_ENDPOINT_SERVICE_NAME_NOT_FOUND";
+    readonly VPC_INTERFACE_ENDPOINT_SERVICE_ACCESS_DENIED: "VPC_INTERFACE_ENDPOINT_SERVICE_ACCESS_DENIED";
+};
+/**
+ * @public
+ */
+export type DeliveryStreamFailureType = (typeof DeliveryStreamFailureType)[keyof typeof DeliveryStreamFailureType];
+/**
+ * @public
+ * @enum
+ */
+export declare const SnapshotRequestedBy: {
+    readonly FIREHOSE: "FIREHOSE";
+    readonly USER: "USER";
+};
+/**
+ * @public
+ */
+export type SnapshotRequestedBy = (typeof SnapshotRequestedBy)[keyof typeof SnapshotRequestedBy];
+/**
+ * @public
+ * @enum
+ */
+export declare const SnapshotStatus: {
+    readonly COMPLETE: "COMPLETE";
+    readonly IN_PROGRESS: "IN_PROGRESS";
+    readonly SUSPENDED: "SUSPENDED";
+};
+/**
+ * @public
+ */
+export type SnapshotStatus = (typeof SnapshotStatus)[keyof typeof SnapshotStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const DeliveryStreamEncryptionStatus: {
+    readonly DISABLED: "DISABLED";
+    readonly DISABLING: "DISABLING";
+    readonly DISABLING_FAILED: "DISABLING_FAILED";
+    readonly ENABLED: "ENABLED";
+    readonly ENABLING: "ENABLING";
+    readonly ENABLING_FAILED: "ENABLING_FAILED";
+};
+/**
+ * @public
+ */
+export type DeliveryStreamEncryptionStatus = (typeof DeliveryStreamEncryptionStatus)[keyof typeof DeliveryStreamEncryptionStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const DeliveryStreamStatus: {
+    readonly ACTIVE: "ACTIVE";
+    readonly CREATING: "CREATING";
+    readonly CREATING_FAILED: "CREATING_FAILED";
+    readonly DELETING: "DELETING";
+    readonly DELETING_FAILED: "DELETING_FAILED";
+};
+/**
+ * @public
+ */
+export type DeliveryStreamStatus = (typeof DeliveryStreamStatus)[keyof typeof DeliveryStreamStatus];

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

@@ -0,0 +1,108 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { FirehoseServiceException as __BaseException } from "./FirehoseServiceException";
+/**
+ * <p>Another modification has already happened. Fetch <code>VersionId</code> again and use
+ *          it to update the destination.</p>
+ * @public
+ */
+export declare class ConcurrentModificationException extends __BaseException {
+    readonly name: "ConcurrentModificationException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ConcurrentModificationException, __BaseException>);
+}
+/**
+ * <p>The specified input parameter has a value that is not valid.</p>
+ * @public
+ */
+export declare class InvalidArgumentException extends __BaseException {
+    readonly name: "InvalidArgumentException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidArgumentException, __BaseException>);
+}
+/**
+ * <p>Firehose throws this exception when an attempt to put records or to start
+ *          or stop Firehose stream encryption fails. This happens when the KMS service throws one of
+ *          the following exception types: <code>AccessDeniedException</code>,
+ *             <code>InvalidStateException</code>, <code>DisabledException</code>, or
+ *             <code>NotFoundException</code>.</p>
+ * @public
+ */
+export declare class InvalidKMSResourceException extends __BaseException {
+    readonly name: "InvalidKMSResourceException";
+    readonly $fault: "client";
+    code?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidKMSResourceException, __BaseException>);
+}
+/**
+ * <p>You have already reached the limit for a requested resource.</p>
+ * @public
+ */
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+/**
+ * <p>The resource is already in use and not available for this operation.</p>
+ * @public
+ */
+export declare class ResourceInUseException extends __BaseException {
+    readonly name: "ResourceInUseException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceInUseException, __BaseException>);
+}
+/**
+ * <p>The specified resource could not be found.</p>
+ * @public
+ */
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+/**
+ * <p>Only requests from CloudWatch Logs are supported when CloudWatch Logs decompression is enabled.</p>
+ * @public
+ */
+export declare class InvalidSourceException extends __BaseException {
+    readonly name: "InvalidSourceException";
+    readonly $fault: "client";
+    code?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidSourceException, __BaseException>);
+}
+/**
+ * <p>The service is unavailable. Back off and retry the operation. If you continue to see
+ *          the exception, throughput limits for the Firehose stream may have been exceeded. For more
+ *          information about limits and how to request an increase, see <a href="https://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon Firehose
+ *          Limits</a>.</p>
+ * @public
+ */
+export declare class ServiceUnavailableException extends __BaseException {
+    readonly name: "ServiceUnavailableException";
+    readonly $fault: "server";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>);
+}