@aws-sdk/client-sagemaker-metrics 3.229.0

package/dist-cjs/endpoint/ruleset.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleSet = void 0;
+exports.ruleSet = {
+    version: "1.0",
+    parameters: {
+        Region: {
+            builtIn: "AWS::Region",
+            required: true,
+            documentation: "The AWS region used to dispatch the request.",
+            type: "String",
+        },
+        UseDualStack: {
+            builtIn: "AWS::UseDualStack",
+            required: true,
+            default: false,
+            documentation: "When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.",
+            type: "Boolean",
+        },
+        UseFIPS: {
+            builtIn: "AWS::UseFIPS",
+            required: true,
+            default: false,
+            documentation: "When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.",
+            type: "Boolean",
+        },
+        Endpoint: {
+            builtIn: "SDK::Endpoint",
+            required: false,
+            documentation: "Override the endpoint used to send this request",
+            type: "String",
+        },
+    },
+    rules: [
+        {
+            conditions: [
+                {
+                    fn: "aws.partition",
+                    argv: [
+                        {
+                            ref: "Region",
+                        },
+                    ],
+                    assign: "PartitionResult",
+                },
+            ],
+            type: "tree",
+            rules: [
+                {
+                    conditions: [
+                        {
+                            fn: "isSet",
+                            argv: [
+                                {
+                                    ref: "Endpoint",
+                                },
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        {
+                                            ref: "UseFIPS",
+                                        },
+                                        true,
+                                    ],
+                                },
+                            ],
+                            error: "Invalid Configuration: FIPS and custom endpoint are not supported",
+                            type: "error",
+                        },
+                        {
+                            conditions: [],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [
+                                        {
+                                            fn: "booleanEquals",
+                                            argv: [
+                                                {
+                                                    ref: "UseDualStack",
+                                                },
+                                                true,
+                                            ],
+                                        },
+                                    ],
+                                    error: "Invalid Configuration: Dualstack and custom endpoint are not supported",
+                                    type: "error",
+                                },
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: {
+                                            ref: "Endpoint",
+                                        },
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseFIPS",
+                                },
+                                true,
+                            ],
+                        },
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseDualStack",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsFIPS",
+                                            ],
+                                        },
+                                    ],
+                                },
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsDualStack",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://metrics.sagemaker-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "FIPS and DualStack are enabled, but this partition does not support one or both",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseFIPS",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsFIPS",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://metrics.sagemaker-fips.{Region}.{PartitionResult#dnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "FIPS is enabled but this partition does not support FIPS",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseDualStack",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsDualStack",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://metrics.sagemaker.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "DualStack is enabled but this partition does not support DualStack",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [],
+                    endpoint: {
+                        url: "https://metrics.sagemaker.{Region}.{PartitionResult#dnsSuffix}",
+                        properties: {},
+                        headers: {},
+                    },
+                    type: "endpoint",
+                },
+            ],
+        },
+    ],
+};

package/dist-cjs/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SageMakerMetricsServiceException = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./SageMakerMetrics"), exports);
+tslib_1.__exportStar(require("./SageMakerMetricsClient"), exports);
+tslib_1.__exportStar(require("./commands"), exports);
+tslib_1.__exportStar(require("./models"), exports);
+var SageMakerMetricsServiceException_1 = require("./models/SageMakerMetricsServiceException");
+Object.defineProperty(exports, "SageMakerMetricsServiceException", { enumerable: true, get: function () { return SageMakerMetricsServiceException_1.SageMakerMetricsServiceException; } });

package/dist-cjs/models/SageMakerMetricsServiceException.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SageMakerMetricsServiceException = void 0;
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+class SageMakerMetricsServiceException extends smithy_client_1.ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, SageMakerMetricsServiceException.prototype);
+    }
+}
+exports.SageMakerMetricsServiceException = SageMakerMetricsServiceException;

package/dist-cjs/models/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./models_0"), exports);

package/dist-cjs/models/models_0.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchPutMetricsResponseFilterSensitiveLog = exports.BatchPutMetricsErrorFilterSensitiveLog = exports.BatchPutMetricsRequestFilterSensitiveLog = exports.RawMetricDataFilterSensitiveLog = exports.PutMetricsErrorCode = void 0;
+var PutMetricsErrorCode;
+(function (PutMetricsErrorCode) {
+    PutMetricsErrorCode["CONFLICT_ERROR"] = "CONFLICT_ERROR";
+    PutMetricsErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+    PutMetricsErrorCode["METRIC_LIMIT_EXCEEDED"] = "METRIC_LIMIT_EXCEEDED";
+    PutMetricsErrorCode["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+})(PutMetricsErrorCode = exports.PutMetricsErrorCode || (exports.PutMetricsErrorCode = {}));
+const RawMetricDataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.RawMetricDataFilterSensitiveLog = RawMetricDataFilterSensitiveLog;
+const BatchPutMetricsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.BatchPutMetricsRequestFilterSensitiveLog = BatchPutMetricsRequestFilterSensitiveLog;
+const BatchPutMetricsErrorFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.BatchPutMetricsErrorFilterSensitiveLog = BatchPutMetricsErrorFilterSensitiveLog;
+const BatchPutMetricsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+exports.BatchPutMetricsResponseFilterSensitiveLog = BatchPutMetricsResponseFilterSensitiveLog;

package/dist-cjs/protocols/Aws_restJson1.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeAws_restJson1BatchPutMetricsCommand = exports.serializeAws_restJson1BatchPutMetricsCommand = void 0;
+const protocol_http_1 = require("@aws-sdk/protocol-http");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const SageMakerMetricsServiceException_1 = require("../models/SageMakerMetricsServiceException");
+const serializeAws_restJson1BatchPutMetricsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/BatchPutMetrics";
+    let body;
+    body = JSON.stringify({
+        ...(input.MetricData != null && { MetricData: serializeAws_restJson1RawMetricDataList(input.MetricData, context) }),
+        ...(input.TrialComponentName != null && { TrialComponentName: input.TrialComponentName }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1BatchPutMetricsCommand = serializeAws_restJson1BatchPutMetricsCommand;
+const deserializeAws_restJson1BatchPutMetricsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1BatchPutMetricsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
+    if (data.Errors != null) {
+        contents.Errors = deserializeAws_restJson1BatchPutMetricsErrorList(data.Errors, context);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1BatchPutMetricsCommand = deserializeAws_restJson1BatchPutMetricsCommand;
+const deserializeAws_restJson1BatchPutMetricsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    (0, smithy_client_1.throwDefaultError)({
+        output,
+        parsedBody,
+        exceptionCtor: SageMakerMetricsServiceException_1.SageMakerMetricsServiceException,
+        errorCode,
+    });
+};
+const map = smithy_client_1.map;
+const serializeAws_restJson1RawMetricData = (input, context) => {
+    return {
+        ...(input.MetricName != null && { MetricName: input.MetricName }),
+        ...(input.Step != null && { Step: input.Step }),
+        ...(input.Timestamp != null && { Timestamp: Math.round(input.Timestamp.getTime() / 1000) }),
+        ...(input.Value != null && { Value: (0, smithy_client_1.serializeFloat)(input.Value) }),
+    };
+};
+const serializeAws_restJson1RawMetricDataList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1RawMetricData(entry, context);
+    });
+};
+const deserializeAws_restJson1BatchPutMetricsError = (output, context) => {
+    return {
+        Code: (0, smithy_client_1.expectString)(output.Code),
+        MetricIndex: (0, smithy_client_1.expectInt32)(output.MetricIndex),
+    };
+};
+const deserializeAws_restJson1BatchPutMetricsErrorList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1BatchPutMetricsError(entry, context);
+    });
+    return retVal;
+};
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
+const collectBody = (streamBody = new Uint8Array(), context) => {
+    if (streamBody instanceof Uint8Array) {
+        return Promise.resolve(streamBody);
+    }
+    return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
+};
+const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
+const isSerializableHeaderValue = (value) => value !== undefined &&
+    value !== null &&
+    value !== "" &&
+    (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
+    (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+    if (encoded.length) {
+        return JSON.parse(encoded);
+    }
+    return {};
+});
+const parseErrorBody = async (errorBody, context) => {
+    const value = await parseBody(errorBody, context);
+    value.message = value.message ?? value.Message;
+    return value;
+};
+const loadRestJsonErrorCode = (output, data) => {
+    const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
+    const sanitizeErrorCode = (rawValue) => {
+        let cleanValue = rawValue;
+        if (typeof cleanValue === "number") {
+            cleanValue = cleanValue.toString();
+        }
+        if (cleanValue.indexOf(",") >= 0) {
+            cleanValue = cleanValue.split(",")[0];
+        }
+        if (cleanValue.indexOf(":") >= 0) {
+            cleanValue = cleanValue.split(":")[0];
+        }
+        if (cleanValue.indexOf("#") >= 0) {
+            cleanValue = cleanValue.split("#")[1];
+        }
+        return cleanValue;
+    };
+    const headerKey = findKey(output.headers, "x-amzn-errortype");
+    if (headerKey !== undefined) {
+        return sanitizeErrorCode(output.headers[headerKey]);
+    }
+    if (data.code !== undefined) {
+        return sanitizeErrorCode(data.code);
+    }
+    if (data["__type"] !== undefined) {
+        return sanitizeErrorCode(data["__type"]);
+    }
+};

package/dist-cjs/runtimeConfig.browser.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuntimeConfig = void 0;
+const tslib_1 = require("tslib");
+const package_json_1 = tslib_1.__importDefault(require("../package.json"));
+const sha256_browser_1 = require("@aws-crypto/sha256-browser");
+const config_resolver_1 = require("@aws-sdk/config-resolver");
+const fetch_http_handler_1 = require("@aws-sdk/fetch-http-handler");
+const invalid_dependency_1 = require("@aws-sdk/invalid-dependency");
+const util_body_length_browser_1 = require("@aws-sdk/util-body-length-browser");
+const util_retry_1 = require("@aws-sdk/util-retry");
+const util_user_agent_browser_1 = require("@aws-sdk/util-user-agent-browser");
+const util_utf8_browser_1 = require("@aws-sdk/util-utf8-browser");
+const runtimeConfig_shared_1 = require("./runtimeConfig.shared");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const util_defaults_mode_browser_1 = require("@aws-sdk/util-defaults-mode-browser");
+const getRuntimeConfig = (config) => {
+    const defaultsMode = (0, util_defaults_mode_browser_1.resolveDefaultsModeConfig)(config);
+    const defaultConfigProvider = () => defaultsMode().then(smithy_client_1.loadConfigsForDefaultMode);
+    const clientSharedValues = (0, runtimeConfig_shared_1.getRuntimeConfig)(config);
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "browser",
+        defaultsMode,
+        bodyLengthChecker: config?.bodyLengthChecker ?? util_body_length_browser_1.calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? ((_) => () => Promise.reject(new Error("Credential is missing"))),
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ??
+            (0, util_user_agent_browser_1.defaultUserAgent)({ serviceId: clientSharedValues.serviceId, clientVersion: package_json_1.default.version }),
+        maxAttempts: config?.maxAttempts ?? util_retry_1.DEFAULT_MAX_ATTEMPTS,
+        region: config?.region ?? (0, invalid_dependency_1.invalidProvider)("Region is missing"),
+        requestHandler: config?.requestHandler ?? new fetch_http_handler_1.FetchHttpHandler(defaultConfigProvider),
+        retryMode: config?.retryMode ?? (async () => (await defaultConfigProvider()).retryMode || util_retry_1.DEFAULT_RETRY_MODE),
+        sha256: config?.sha256 ?? sha256_browser_1.Sha256,
+        streamCollector: config?.streamCollector ?? fetch_http_handler_1.streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? (() => Promise.resolve(config_resolver_1.DEFAULT_USE_DUALSTACK_ENDPOINT)),
+        useFipsEndpoint: config?.useFipsEndpoint ?? (() => Promise.resolve(config_resolver_1.DEFAULT_USE_FIPS_ENDPOINT)),
+        utf8Decoder: config?.utf8Decoder ?? util_utf8_browser_1.fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? util_utf8_browser_1.toUtf8,
+    };
+};
+exports.getRuntimeConfig = getRuntimeConfig;

package/dist-cjs/runtimeConfig.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuntimeConfig = void 0;
+const tslib_1 = require("tslib");
+const package_json_1 = tslib_1.__importDefault(require("../package.json"));
+const client_sts_1 = require("@aws-sdk/client-sts");
+const config_resolver_1 = require("@aws-sdk/config-resolver");
+const credential_provider_node_1 = require("@aws-sdk/credential-provider-node");
+const hash_node_1 = require("@aws-sdk/hash-node");
+const middleware_retry_1 = require("@aws-sdk/middleware-retry");
+const node_config_provider_1 = require("@aws-sdk/node-config-provider");
+const node_http_handler_1 = require("@aws-sdk/node-http-handler");
+const util_body_length_node_1 = require("@aws-sdk/util-body-length-node");
+const util_retry_1 = require("@aws-sdk/util-retry");
+const util_user_agent_node_1 = require("@aws-sdk/util-user-agent-node");
+const util_utf8_node_1 = require("@aws-sdk/util-utf8-node");
+const runtimeConfig_shared_1 = require("./runtimeConfig.shared");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const util_defaults_mode_node_1 = require("@aws-sdk/util-defaults-mode-node");
+const smithy_client_2 = require("@aws-sdk/smithy-client");
+const getRuntimeConfig = (config) => {
+    (0, smithy_client_2.emitWarningIfUnsupportedVersion)(process.version);
+    const defaultsMode = (0, util_defaults_mode_node_1.resolveDefaultsModeConfig)(config);
+    const defaultConfigProvider = () => defaultsMode().then(smithy_client_1.loadConfigsForDefaultMode);
+    const clientSharedValues = (0, runtimeConfig_shared_1.getRuntimeConfig)(config);
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "node",
+        defaultsMode,
+        bodyLengthChecker: config?.bodyLengthChecker ?? util_body_length_node_1.calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? (0, client_sts_1.decorateDefaultCredentialProvider)(credential_provider_node_1.defaultProvider),
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ??
+            (0, util_user_agent_node_1.defaultUserAgent)({ serviceId: clientSharedValues.serviceId, clientVersion: package_json_1.default.version }),
+        maxAttempts: config?.maxAttempts ?? (0, node_config_provider_1.loadConfig)(middleware_retry_1.NODE_MAX_ATTEMPT_CONFIG_OPTIONS),
+        region: config?.region ?? (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_REGION_CONFIG_OPTIONS, config_resolver_1.NODE_REGION_CONFIG_FILE_OPTIONS),
+        requestHandler: config?.requestHandler ?? new node_http_handler_1.NodeHttpHandler(defaultConfigProvider),
+        retryMode: config?.retryMode ??
+            (0, node_config_provider_1.loadConfig)({
+                ...middleware_retry_1.NODE_RETRY_MODE_CONFIG_OPTIONS,
+                default: async () => (await defaultConfigProvider()).retryMode || util_retry_1.DEFAULT_RETRY_MODE,
+            }),
+        sha256: config?.sha256 ?? hash_node_1.Hash.bind(null, "sha256"),
+        streamCollector: config?.streamCollector ?? node_http_handler_1.streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS),
+        useFipsEndpoint: config?.useFipsEndpoint ?? (0, node_config_provider_1.loadConfig)(config_resolver_1.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS),
+        utf8Decoder: config?.utf8Decoder ?? util_utf8_node_1.fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? util_utf8_node_1.toUtf8,
+    };
+};
+exports.getRuntimeConfig = getRuntimeConfig;

package/dist-cjs/runtimeConfig.native.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuntimeConfig = void 0;
+const sha256_js_1 = require("@aws-crypto/sha256-js");
+const runtimeConfig_browser_1 = require("./runtimeConfig.browser");
+const getRuntimeConfig = (config) => {
+    const browserDefaults = (0, runtimeConfig_browser_1.getRuntimeConfig)(config);
+    return {
+        ...browserDefaults,
+        ...config,
+        runtime: "react-native",
+        sha256: config?.sha256 ?? sha256_js_1.Sha256,
+    };
+};
+exports.getRuntimeConfig = getRuntimeConfig;

package/dist-cjs/runtimeConfig.shared.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuntimeConfig = void 0;
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const url_parser_1 = require("@aws-sdk/url-parser");
+const util_base64_1 = require("@aws-sdk/util-base64");
+const endpointResolver_1 = require("./endpoint/endpointResolver");
+const getRuntimeConfig = (config) => ({
+    apiVersion: "2022-09-30",
+    base64Decoder: config?.base64Decoder ?? util_base64_1.fromBase64,
+    base64Encoder: config?.base64Encoder ?? util_base64_1.toBase64,
+    disableHostPrefix: config?.disableHostPrefix ?? false,
+    endpointProvider: config?.endpointProvider ?? endpointResolver_1.defaultEndpointResolver,
+    logger: config?.logger ?? new smithy_client_1.NoOpLogger(),
+    serviceId: config?.serviceId ?? "SageMaker Metrics",
+    urlParser: config?.urlParser ?? url_parser_1.parseUrl,
+});
+exports.getRuntimeConfig = getRuntimeConfig;

package/dist-es/SageMakerMetrics.js

@@ -0,0 +1,18 @@
+import { BatchPutMetricsCommand, } from "./commands/BatchPutMetricsCommand";
+import { SageMakerMetricsClient } from "./SageMakerMetricsClient";
+export class SageMakerMetrics extends SageMakerMetricsClient {
+    batchPutMetrics(args, optionsOrCb, cb) {
+        const command = new BatchPutMetricsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+}