@aws-sdk/client-timestream-influxdb 3.910.0 → 3.913.0

package/dist-cjs/endpoint/ruleset.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ruleSet = void 0;
 const s = "required", t = "fn", u = "argv", v = "ref";
-const a = true, b = "isSet", c = "booleanEquals", d = "error", e = "endpoint", f = "tree", g = "PartitionResult", h = { [s]: false, "type": "String" }, i = { [s]: true, "default": false, "type": "Boolean" }, j = { [v]: "Endpoint" }, k = { [t]: c, [u]: [{ [v]: "UseFIPS" }, true] }, l = { [t]: c, [u]: [{ [v]: "UseDualStack" }, true] }, m = {}, n = { [t]: "getAttr", [u]: [{ [v]: g }, "supportsFIPS"] }, o = { [t]: c, [u]: [true, { [t]: "getAttr", [u]: [{ [v]: g }, "supportsDualStack"] }] }, p = [k], q = [l], r = [{ [v]: "Region" }];
+const a = true, b = "isSet", c = "booleanEquals", d = "error", e = "endpoint", f = "tree", g = "PartitionResult", h = { [s]: false, "type": "string" }, i = { [s]: true, "default": false, "type": "boolean" }, j = { [v]: "Endpoint" }, k = { [t]: c, [u]: [{ [v]: "UseFIPS" }, true] }, l = { [t]: c, [u]: [{ [v]: "UseDualStack" }, true] }, m = {}, n = { [t]: "getAttr", [u]: [{ [v]: g }, "supportsFIPS"] }, o = { [t]: c, [u]: [true, { [t]: "getAttr", [u]: [{ [v]: g }, "supportsDualStack"] }] }, p = [k], q = [l], r = [{ [v]: "Region" }];
 const _data = { version: "1.0", parameters: { Region: h, UseDualStack: i, UseFIPS: i, Endpoint: h }, rules: [{ conditions: [{ [t]: b, [u]: [j] }], rules: [{ conditions: p, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d }, { rules: [{ conditions: q, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d }, { endpoint: { url: j, properties: m, headers: m }, type: e }], type: f }], type: f }, { rules: [{ conditions: [{ [t]: b, [u]: r }], rules: [{ conditions: [{ [t]: "aws.partition", [u]: r, assign: g }], rules: [{ conditions: [k, l], rules: [{ conditions: [{ [t]: c, [u]: [a, n] }, o], rules: [{ rules: [{ endpoint: { url: "https://timestream-influxdb-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d }], type: f }, { conditions: p, rules: [{ conditions: [{ [t]: c, [u]: [n, a] }], rules: [{ rules: [{ endpoint: { url: "https://timestream-influxdb-fips.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }, { error: "FIPS is enabled but this partition does not support FIPS", type: d }], type: f }, { conditions: q, rules: [{ conditions: [o], rules: [{ rules: [{ endpoint: { url: "https://timestream-influxdb.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }, { error: "DualStack is enabled but this partition does not support DualStack", type: d }], type: f }, { rules: [{ endpoint: { url: "https://timestream-influxdb.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }], type: f }, { error: "Invalid Configuration: Missing Region", type: d }], type: f }] };
 exports.ruleSet = _data;

package/dist-cjs/index.js

@@ -255,12 +255,21 @@ class ValidationException extends TimestreamInfluxDBServiceException {
         this.reason = opts.reason;
     }
 }
+const EngineType = {
+    INFLUXDB_V2: "INFLUXDB_V2",
+    INFLUXDB_V3_CORE: "INFLUXDB_V3_CORE",
+    INFLUXDB_V3_ENTERPRISE: "INFLUXDB_V3_ENTERPRISE",
+};
 const DeploymentType = {
     SINGLE_AZ: "SINGLE_AZ",
     WITH_MULTIAZ_STANDBY: "WITH_MULTIAZ_STANDBY",
 };
 const InstanceMode = {
+    COMPACT: "COMPACT",
+    INGEST: "INGEST",
     PRIMARY: "PRIMARY",
+    PROCESS: "PROCESS",
+    QUERY: "QUERY",
     REPLICA: "REPLICA",
     STANDBY: "STANDBY",
 };
@@ -277,6 +286,7 @@ const Status = {
     UPDATING_INSTANCE_TYPE: "UPDATING_INSTANCE_TYPE",
 };
 const DurationType = {
+    DAYS: "days",
     HOURS: "hours",
     MILLISECONDS: "milliseconds",
     MINUTES: "minutes",
@@ -288,14 +298,36 @@ const LogLevel = {
     INFO: "info",
 };
 const TracingType = {
+    DISABLED: "disabled",
     JAEGER: "jaeger",
     LOG: "log",
 };
+const DataFusionRuntimeType = {
+    MULTI_THREAD: "multi-thread",
+    MULTI_THREAD_ALT: "multi-thread-alt",
+};
+exports.PercentOrAbsoluteLong = void 0;
+(function (PercentOrAbsoluteLong) {
+    PercentOrAbsoluteLong.visit = (value, visitor) => {
+        if (value.percent !== undefined)
+            return visitor.percent(value.percent);
+        if (value.absolute !== undefined)
+            return visitor.absolute(value.absolute);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(exports.PercentOrAbsoluteLong || (exports.PercentOrAbsoluteLong = {}));
+const LogFormats = {
+    FULL: "full",
+};
 exports._Parameters = void 0;
 (function (_Parameters) {
     _Parameters.visit = (value, visitor) => {
         if (value.InfluxDBv2 !== undefined)
             return visitor.InfluxDBv2(value.InfluxDBv2);
+        if (value.InfluxDBv3Core !== undefined)
+            return visitor.InfluxDBv3Core(value.InfluxDBv3Core);
+        if (value.InfluxDBv3Enterprise !== undefined)
+            return visitor.InfluxDBv3Enterprise(value.InfluxDBv3Enterprise);
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(exports._Parameters || (exports._Parameters = {}));
@@ -325,7 +357,7 @@ const se_CreateDbInstanceCommand = async (input, context) => {
 const se_CreateDbParameterGroupCommand = async (input, context) => {
     const headers = sharedHeaders("CreateDbParameterGroup");
     let body;
-    body = JSON.stringify(smithyClient._json(input));
+    body = JSON.stringify(se_CreateDbParameterGroupInput(input));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
 const se_DeleteDbClusterCommand = async (input, context) => {
@@ -444,7 +476,7 @@ const de_CreateDbParameterGroupCommand = async (output, context) => {
     }
     const data = await core$1.parseJsonBody(output.body, context);
     let contents = {};
-    contents = smithyClient._json(data);
+    contents = de_CreateDbParameterGroupOutput(data);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
@@ -509,7 +541,7 @@ const de_GetDbParameterGroupCommand = async (output, context) => {
     }
     const data = await core$1.parseJsonBody(output.body, context);
     let contents = {};
-    contents = smithyClient._json(data);
+    contents = de_GetDbParameterGroupOutput(data);
     const response = {
         $metadata: deserializeMetadata(output),
         ...contents,
@@ -727,6 +759,256 @@ const de_ValidationExceptionRes = async (parsedOutput, context) => {
     });
     return smithyClient.decorateServiceException(exception, body);
 };
+const se_CreateDbParameterGroupInput = (input, context) => {
+    return smithyClient.take(input, {
+        description: [],
+        name: [],
+        parameters: (_) => se__Parameters(_),
+        tags: smithyClient._json,
+    });
+};
+const se_InfluxDBv3CoreParameters = (input, context) => {
+    return smithyClient.take(input, {
+        dataFusionConfig: [],
+        dataFusionMaxParquetFanout: [],
+        dataFusionNumThreads: [],
+        dataFusionRuntimeDisableLifoSlot: [],
+        dataFusionRuntimeEventInterval: [],
+        dataFusionRuntimeGlobalQueueInterval: [],
+        dataFusionRuntimeMaxBlockingThreads: [],
+        dataFusionRuntimeMaxIoEventsPerTick: [],
+        dataFusionRuntimeThreadKeepAlive: smithyClient._json,
+        dataFusionRuntimeThreadPriority: [],
+        dataFusionRuntimeType: [],
+        dataFusionUseCachedParquetLoader: [],
+        deleteGracePeriod: smithyClient._json,
+        disableParquetMemCache: [],
+        distinctCacheEvictionInterval: smithyClient._json,
+        execMemPoolBytes: smithyClient._json,
+        forceSnapshotMemThreshold: smithyClient._json,
+        gen1Duration: smithyClient._json,
+        gen1LookbackDuration: smithyClient._json,
+        hardDeleteDefaultDuration: smithyClient._json,
+        lastCacheEvictionInterval: smithyClient._json,
+        logFilter: [],
+        logFormat: [],
+        maxHttpRequestSize: [],
+        parquetMemCachePruneInterval: smithyClient._json,
+        parquetMemCachePrunePercentage: smithyClient.serializeFloat,
+        parquetMemCacheQueryPathDuration: smithyClient._json,
+        parquetMemCacheSize: smithyClient._json,
+        preemptiveCacheAge: smithyClient._json,
+        queryFileLimit: [],
+        queryLogSize: [],
+        retentionCheckInterval: smithyClient._json,
+        snapshottedWalFilesToKeep: [],
+        tableIndexCacheConcurrencyLimit: [],
+        tableIndexCacheMaxEntries: [],
+        walMaxWriteBufferSize: [],
+        walReplayConcurrencyLimit: [],
+        walReplayFailOnError: [],
+        walSnapshotSize: [],
+    });
+};
+const se_InfluxDBv3EnterpriseParameters = (input, context) => {
+    return smithyClient.take(input, {
+        catalogSyncInterval: smithyClient._json,
+        compactionCheckInterval: smithyClient._json,
+        compactionCleanupWait: smithyClient._json,
+        compactionGen2Duration: smithyClient._json,
+        compactionMaxNumFilesPerPlan: [],
+        compactionMultipliers: [],
+        compactionRowLimit: [],
+        dataFusionConfig: [],
+        dataFusionMaxParquetFanout: [],
+        dataFusionNumThreads: [],
+        dataFusionRuntimeDisableLifoSlot: [],
+        dataFusionRuntimeEventInterval: [],
+        dataFusionRuntimeGlobalQueueInterval: [],
+        dataFusionRuntimeMaxBlockingThreads: [],
+        dataFusionRuntimeMaxIoEventsPerTick: [],
+        dataFusionRuntimeThreadKeepAlive: smithyClient._json,
+        dataFusionRuntimeThreadPriority: [],
+        dataFusionRuntimeType: [],
+        dataFusionUseCachedParquetLoader: [],
+        dedicatedCompactor: [],
+        deleteGracePeriod: smithyClient._json,
+        disableParquetMemCache: [],
+        distinctCacheEvictionInterval: smithyClient._json,
+        distinctValueCacheDisableFromHistory: [],
+        execMemPoolBytes: smithyClient._json,
+        forceSnapshotMemThreshold: smithyClient._json,
+        gen1Duration: smithyClient._json,
+        gen1LookbackDuration: smithyClient._json,
+        hardDeleteDefaultDuration: smithyClient._json,
+        ingestQueryInstances: [],
+        lastCacheEvictionInterval: smithyClient._json,
+        lastValueCacheDisableFromHistory: [],
+        logFilter: [],
+        logFormat: [],
+        maxHttpRequestSize: [],
+        parquetMemCachePruneInterval: smithyClient._json,
+        parquetMemCachePrunePercentage: smithyClient.serializeFloat,
+        parquetMemCacheQueryPathDuration: smithyClient._json,
+        parquetMemCacheSize: smithyClient._json,
+        preemptiveCacheAge: smithyClient._json,
+        queryFileLimit: [],
+        queryLogSize: [],
+        queryOnlyInstances: [],
+        replicationInterval: smithyClient._json,
+        retentionCheckInterval: smithyClient._json,
+        snapshottedWalFilesToKeep: [],
+        tableIndexCacheConcurrencyLimit: [],
+        tableIndexCacheMaxEntries: [],
+        walMaxWriteBufferSize: [],
+        walReplayConcurrencyLimit: [],
+        walReplayFailOnError: [],
+        walSnapshotSize: [],
+    });
+};
+const se__Parameters = (input, context) => {
+    return exports._Parameters.visit(input, {
+        InfluxDBv2: (value) => ({ InfluxDBv2: smithyClient._json(value) }),
+        InfluxDBv3Core: (value) => ({ InfluxDBv3Core: se_InfluxDBv3CoreParameters(value) }),
+        InfluxDBv3Enterprise: (value) => ({ InfluxDBv3Enterprise: se_InfluxDBv3EnterpriseParameters(value) }),
+        _: (name, value) => ({ [name]: value }),
+    });
+};
+const de_CreateDbParameterGroupOutput = (output, context) => {
+    return smithyClient.take(output, {
+        arn: smithyClient.expectString,
+        description: smithyClient.expectString,
+        id: smithyClient.expectString,
+        name: smithyClient.expectString,
+        parameters: (_) => de__Parameters(core$1.awsExpectUnion(_)),
+    });
+};
+const de_GetDbParameterGroupOutput = (output, context) => {
+    return smithyClient.take(output, {
+        arn: smithyClient.expectString,
+        description: smithyClient.expectString,
+        id: smithyClient.expectString,
+        name: smithyClient.expectString,
+        parameters: (_) => de__Parameters(core$1.awsExpectUnion(_)),
+    });
+};
+const de_InfluxDBv3CoreParameters = (output, context) => {
+    return smithyClient.take(output, {
+        dataFusionConfig: smithyClient.expectString,
+        dataFusionMaxParquetFanout: smithyClient.expectInt32,
+        dataFusionNumThreads: smithyClient.expectInt32,
+        dataFusionRuntimeDisableLifoSlot: smithyClient.expectBoolean,
+        dataFusionRuntimeEventInterval: smithyClient.expectInt32,
+        dataFusionRuntimeGlobalQueueInterval: smithyClient.expectInt32,
+        dataFusionRuntimeMaxBlockingThreads: smithyClient.expectInt32,
+        dataFusionRuntimeMaxIoEventsPerTick: smithyClient.expectInt32,
+        dataFusionRuntimeThreadKeepAlive: smithyClient._json,
+        dataFusionRuntimeThreadPriority: smithyClient.expectInt32,
+        dataFusionRuntimeType: smithyClient.expectString,
+        dataFusionUseCachedParquetLoader: smithyClient.expectBoolean,
+        deleteGracePeriod: smithyClient._json,
+        disableParquetMemCache: smithyClient.expectBoolean,
+        distinctCacheEvictionInterval: smithyClient._json,
+        execMemPoolBytes: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
+        forceSnapshotMemThreshold: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
+        gen1Duration: smithyClient._json,
+        gen1LookbackDuration: smithyClient._json,
+        hardDeleteDefaultDuration: smithyClient._json,
+        lastCacheEvictionInterval: smithyClient._json,
+        logFilter: smithyClient.expectString,
+        logFormat: smithyClient.expectString,
+        maxHttpRequestSize: smithyClient.expectLong,
+        parquetMemCachePruneInterval: smithyClient._json,
+        parquetMemCachePrunePercentage: smithyClient.limitedParseFloat32,
+        parquetMemCacheQueryPathDuration: smithyClient._json,
+        parquetMemCacheSize: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
+        preemptiveCacheAge: smithyClient._json,
+        queryFileLimit: smithyClient.expectInt32,
+        queryLogSize: smithyClient.expectInt32,
+        retentionCheckInterval: smithyClient._json,
+        snapshottedWalFilesToKeep: smithyClient.expectInt32,
+        tableIndexCacheConcurrencyLimit: smithyClient.expectInt32,
+        tableIndexCacheMaxEntries: smithyClient.expectInt32,
+        walMaxWriteBufferSize: smithyClient.expectInt32,
+        walReplayConcurrencyLimit: smithyClient.expectInt32,
+        walReplayFailOnError: smithyClient.expectBoolean,
+        walSnapshotSize: smithyClient.expectInt32,
+    });
+};
+const de_InfluxDBv3EnterpriseParameters = (output, context) => {
+    return smithyClient.take(output, {
+        catalogSyncInterval: smithyClient._json,
+        compactionCheckInterval: smithyClient._json,
+        compactionCleanupWait: smithyClient._json,
+        compactionGen2Duration: smithyClient._json,
+        compactionMaxNumFilesPerPlan: smithyClient.expectInt32,
+        compactionMultipliers: smithyClient.expectString,
+        compactionRowLimit: smithyClient.expectInt32,
+        dataFusionConfig: smithyClient.expectString,
+        dataFusionMaxParquetFanout: smithyClient.expectInt32,
+        dataFusionNumThreads: smithyClient.expectInt32,
+        dataFusionRuntimeDisableLifoSlot: smithyClient.expectBoolean,
+        dataFusionRuntimeEventInterval: smithyClient.expectInt32,
+        dataFusionRuntimeGlobalQueueInterval: smithyClient.expectInt32,
+        dataFusionRuntimeMaxBlockingThreads: smithyClient.expectInt32,
+        dataFusionRuntimeMaxIoEventsPerTick: smithyClient.expectInt32,
+        dataFusionRuntimeThreadKeepAlive: smithyClient._json,
+        dataFusionRuntimeThreadPriority: smithyClient.expectInt32,
+        dataFusionRuntimeType: smithyClient.expectString,
+        dataFusionUseCachedParquetLoader: smithyClient.expectBoolean,
+        dedicatedCompactor: smithyClient.expectBoolean,
+        deleteGracePeriod: smithyClient._json,
+        disableParquetMemCache: smithyClient.expectBoolean,
+        distinctCacheEvictionInterval: smithyClient._json,
+        distinctValueCacheDisableFromHistory: smithyClient.expectBoolean,
+        execMemPoolBytes: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
+        forceSnapshotMemThreshold: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
+        gen1Duration: smithyClient._json,
+        gen1LookbackDuration: smithyClient._json,
+        hardDeleteDefaultDuration: smithyClient._json,
+        ingestQueryInstances: smithyClient.expectInt32,
+        lastCacheEvictionInterval: smithyClient._json,
+        lastValueCacheDisableFromHistory: smithyClient.expectBoolean,
+        logFilter: smithyClient.expectString,
+        logFormat: smithyClient.expectString,
+        maxHttpRequestSize: smithyClient.expectLong,
+        parquetMemCachePruneInterval: smithyClient._json,
+        parquetMemCachePrunePercentage: smithyClient.limitedParseFloat32,
+        parquetMemCacheQueryPathDuration: smithyClient._json,
+        parquetMemCacheSize: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
+        preemptiveCacheAge: smithyClient._json,
+        queryFileLimit: smithyClient.expectInt32,
+        queryLogSize: smithyClient.expectInt32,
+        queryOnlyInstances: smithyClient.expectInt32,
+        replicationInterval: smithyClient._json,
+        retentionCheckInterval: smithyClient._json,
+        snapshottedWalFilesToKeep: smithyClient.expectInt32,
+        tableIndexCacheConcurrencyLimit: smithyClient.expectInt32,
+        tableIndexCacheMaxEntries: smithyClient.expectInt32,
+        walMaxWriteBufferSize: smithyClient.expectInt32,
+        walReplayConcurrencyLimit: smithyClient.expectInt32,
+        walReplayFailOnError: smithyClient.expectBoolean,
+        walSnapshotSize: smithyClient.expectInt32,
+    });
+};
+const de__Parameters = (output, context) => {
+    if (output.InfluxDBv2 != null) {
+        return {
+            InfluxDBv2: smithyClient._json(output.InfluxDBv2),
+        };
+    }
+    if (output.InfluxDBv3Core != null) {
+        return {
+            InfluxDBv3Core: de_InfluxDBv3CoreParameters(output.InfluxDBv3Core),
+        };
+    }
+    if (output.InfluxDBv3Enterprise != null) {
+        return {
+            InfluxDBv3Enterprise: de_InfluxDBv3EnterpriseParameters(output.InfluxDBv3Enterprise),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
     requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
@@ -1093,12 +1375,14 @@ exports.CreateDbClusterInputFilterSensitiveLog = CreateDbClusterInputFilterSensi
 exports.CreateDbInstanceCommand = CreateDbInstanceCommand;
 exports.CreateDbInstanceInputFilterSensitiveLog = CreateDbInstanceInputFilterSensitiveLog;
 exports.CreateDbParameterGroupCommand = CreateDbParameterGroupCommand;
+exports.DataFusionRuntimeType = DataFusionRuntimeType;
 exports.DbInstanceType = DbInstanceType;
 exports.DbStorageType = DbStorageType;
 exports.DeleteDbClusterCommand = DeleteDbClusterCommand;
 exports.DeleteDbInstanceCommand = DeleteDbInstanceCommand;
 exports.DeploymentType = DeploymentType;
 exports.DurationType = DurationType;
+exports.EngineType = EngineType;
 exports.FailoverMode = FailoverMode;
 exports.GetDbClusterCommand = GetDbClusterCommand;
 exports.GetDbInstanceCommand = GetDbInstanceCommand;
@@ -1110,6 +1394,7 @@ exports.ListDbInstancesCommand = ListDbInstancesCommand;
 exports.ListDbInstancesForClusterCommand = ListDbInstancesForClusterCommand;
 exports.ListDbParameterGroupsCommand = ListDbParameterGroupsCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
+exports.LogFormats = LogFormats;
 exports.LogLevel = LogLevel;
 exports.NetworkType = NetworkType;
 exports.ResourceNotFoundException = ResourceNotFoundException;

package/dist-es/endpoint/ruleset.js

@@ -1,4 +1,4 @@
 const s = "required", t = "fn", u = "argv", v = "ref";
-const a = true, b = "isSet", c = "booleanEquals", d = "error", e = "endpoint", f = "tree", g = "PartitionResult", h = { [s]: false, "type": "String" }, i = { [s]: true, "default": false, "type": "Boolean" }, j = { [v]: "Endpoint" }, k = { [t]: c, [u]: [{ [v]: "UseFIPS" }, true] }, l = { [t]: c, [u]: [{ [v]: "UseDualStack" }, true] }, m = {}, n = { [t]: "getAttr", [u]: [{ [v]: g }, "supportsFIPS"] }, o = { [t]: c, [u]: [true, { [t]: "getAttr", [u]: [{ [v]: g }, "supportsDualStack"] }] }, p = [k], q = [l], r = [{ [v]: "Region" }];
+const a = true, b = "isSet", c = "booleanEquals", d = "error", e = "endpoint", f = "tree", g = "PartitionResult", h = { [s]: false, "type": "string" }, i = { [s]: true, "default": false, "type": "boolean" }, j = { [v]: "Endpoint" }, k = { [t]: c, [u]: [{ [v]: "UseFIPS" }, true] }, l = { [t]: c, [u]: [{ [v]: "UseDualStack" }, true] }, m = {}, n = { [t]: "getAttr", [u]: [{ [v]: g }, "supportsFIPS"] }, o = { [t]: c, [u]: [true, { [t]: "getAttr", [u]: [{ [v]: g }, "supportsDualStack"] }] }, p = [k], q = [l], r = [{ [v]: "Region" }];
 const _data = { version: "1.0", parameters: { Region: h, UseDualStack: i, UseFIPS: i, Endpoint: h }, rules: [{ conditions: [{ [t]: b, [u]: [j] }], rules: [{ conditions: p, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d }, { rules: [{ conditions: q, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d }, { endpoint: { url: j, properties: m, headers: m }, type: e }], type: f }], type: f }, { rules: [{ conditions: [{ [t]: b, [u]: r }], rules: [{ conditions: [{ [t]: "aws.partition", [u]: r, assign: g }], rules: [{ conditions: [k, l], rules: [{ conditions: [{ [t]: c, [u]: [a, n] }, o], rules: [{ rules: [{ endpoint: { url: "https://timestream-influxdb-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d }], type: f }, { conditions: p, rules: [{ conditions: [{ [t]: c, [u]: [n, a] }], rules: [{ rules: [{ endpoint: { url: "https://timestream-influxdb-fips.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }, { error: "FIPS is enabled but this partition does not support FIPS", type: d }], type: f }, { conditions: q, rules: [{ conditions: [o], rules: [{ rules: [{ endpoint: { url: "https://timestream-influxdb.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }, { error: "DualStack is enabled but this partition does not support DualStack", type: d }], type: f }, { rules: [{ endpoint: { url: "https://timestream-influxdb.{Region}.{PartitionResult#dnsSuffix}", properties: m, headers: m }, type: e }], type: f }], type: f }], type: f }, { error: "Invalid Configuration: Missing Region", type: d }], type: f }] };
 export const ruleSet = _data;

package/dist-es/models/models_0.js

@@ -138,12 +138,21 @@ export class ValidationException extends __BaseException {
         this.reason = opts.reason;
     }
 }
+export const EngineType = {
+    INFLUXDB_V2: "INFLUXDB_V2",
+    INFLUXDB_V3_CORE: "INFLUXDB_V3_CORE",
+    INFLUXDB_V3_ENTERPRISE: "INFLUXDB_V3_ENTERPRISE",
+};
 export const DeploymentType = {
     SINGLE_AZ: "SINGLE_AZ",
     WITH_MULTIAZ_STANDBY: "WITH_MULTIAZ_STANDBY",
 };
 export const InstanceMode = {
+    COMPACT: "COMPACT",
+    INGEST: "INGEST",
     PRIMARY: "PRIMARY",
+    PROCESS: "PROCESS",
+    QUERY: "QUERY",
     REPLICA: "REPLICA",
     STANDBY: "STANDBY",
 };
@@ -160,6 +169,7 @@ export const Status = {
     UPDATING_INSTANCE_TYPE: "UPDATING_INSTANCE_TYPE",
 };
 export const DurationType = {
+    DAYS: "days",
     HOURS: "hours",
     MILLISECONDS: "milliseconds",
     MINUTES: "minutes",
@@ -171,14 +181,36 @@ export const LogLevel = {
     INFO: "info",
 };
 export const TracingType = {
+    DISABLED: "disabled",
     JAEGER: "jaeger",
     LOG: "log",
 };
+export const DataFusionRuntimeType = {
+    MULTI_THREAD: "multi-thread",
+    MULTI_THREAD_ALT: "multi-thread-alt",
+};
+export var PercentOrAbsoluteLong;
+(function (PercentOrAbsoluteLong) {
+    PercentOrAbsoluteLong.visit = (value, visitor) => {
+        if (value.percent !== undefined)
+            return visitor.percent(value.percent);
+        if (value.absolute !== undefined)
+            return visitor.absolute(value.absolute);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(PercentOrAbsoluteLong || (PercentOrAbsoluteLong = {}));
+export const LogFormats = {
+    FULL: "full",
+};
 export var _Parameters;
 (function (_Parameters) {
     _Parameters.visit = (value, visitor) => {
         if (value.InfluxDBv2 !== undefined)
             return visitor.InfluxDBv2(value.InfluxDBv2);
+        if (value.InfluxDBv3Core !== undefined)
+            return visitor.InfluxDBv3Core(value.InfluxDBv3Core);
+        if (value.InfluxDBv3Enterprise !== undefined)
+            return visitor.InfluxDBv3Enterprise(value.InfluxDBv3Enterprise);
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(_Parameters || (_Parameters = {}));