@aws-sdk/client-sagemaker-edge 3.128.0 → 3.133.0

package/dist-es/protocols/Aws_restJson1.js

@@ -1,8 +1,32 @@
 import { __assign, __awaiter, __generator } from "tslib";
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, serializeFloat as __serializeFloat, } from "@aws-sdk/smithy-client";
-import { InternalServiceException } from "../models/models_0";
+import { InternalServiceException, } from "../models/models_0";
 import { SagemakerEdgeServiceException as __BaseException } from "../models/SagemakerEdgeServiceException";
+export var serializeAws_restJson1GetDeploymentsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                headers = {
+                    "content-type": "application/json",
+                };
+                resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/GetDeployments";
+                body = JSON.stringify(__assign(__assign({}, (input.DeviceFleetName != null && { DeviceFleetName: input.DeviceFleetName })), (input.DeviceName != null && { DeviceName: input.DeviceName })));
+                return [2, new __HttpRequest({
+                        protocol: protocol,
+                        hostname: hostname,
+                        port: port,
+                        method: "POST",
+                        headers: headers,
+                        path: resolvedPath,
+                        body: body,
+                    })];
+        }
+    });
+}); };
 export var serializeAws_restJson1GetDeviceRegistrationCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var _a, hostname, _b, protocol, port, basePath, headers, resolvedPath, body;
     return __generator(this, function (_c) {
@@ -38,7 +62,9 @@ export var serializeAws_restJson1SendHeartbeatCommand = function (input, context
                     "content-type": "application/json",
                 };
                 resolvedPath = "".concat((basePath === null || basePath === void 0 ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || "") + "/SendHeartbeat";
-                body = JSON.stringify(__assign(__assign(__assign(__assign(__assign({}, (input.AgentMetrics != null && { AgentMetrics: serializeAws_restJson1EdgeMetrics(input.AgentMetrics, context) })), (input.AgentVersion != null && { AgentVersion: input.AgentVersion })), (input.DeviceFleetName != null && { DeviceFleetName: input.DeviceFleetName })), (input.DeviceName != null && { DeviceName: input.DeviceName })), (input.Models != null && { Models: serializeAws_restJson1Models(input.Models, context) })));
+                body = JSON.stringify(__assign(__assign(__assign(__assign(__assign(__assign({}, (input.AgentMetrics != null && { AgentMetrics: serializeAws_restJson1EdgeMetrics(input.AgentMetrics, context) })), (input.AgentVersion != null && { AgentVersion: input.AgentVersion })), (input.DeploymentResult != null && {
+                    DeploymentResult: serializeAws_restJson1DeploymentResult(input.DeploymentResult, context),
+                })), (input.DeviceFleetName != null && { DeviceFleetName: input.DeviceFleetName })), (input.DeviceName != null && { DeviceName: input.DeviceName })), (input.Models != null && { Models: serializeAws_restJson1Models(input.Models, context) })));
                 return [2, new __HttpRequest({
                         protocol: protocol,
                         hostname: hostname,
@@ -51,6 +77,63 @@ export var serializeAws_restJson1SendHeartbeatCommand = function (input, context
         }
     });
 }); };
+export var deserializeAws_restJson1GetDeploymentsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var contents, data, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (output.statusCode !== 200 && output.statusCode >= 300) {
+                    return [2, deserializeAws_restJson1GetDeploymentsCommandError(output, context)];
+                }
+                contents = {
+                    $metadata: deserializeMetadata(output),
+                    Deployments: undefined,
+                };
+                _a = __expectNonNull;
+                _b = __expectObject;
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.apply(void 0, [_b.apply(void 0, [_c.sent()]), "body"]);
+                if (data.Deployments !== undefined && data.Deployments !== null) {
+                    contents.Deployments = deserializeAws_restJson1EdgeDeployments(data.Deployments, context);
+                }
+                return [2, Promise.resolve(contents)];
+        }
+    });
+}); };
+var deserializeAws_restJson1GetDeploymentsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, _b, parsedBody, $metadata, statusCode;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InternalServiceException": return [3, 2];
+                    case "com.amazonaws.sagemakeredge#InternalServiceException": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_restJson1InternalServiceExceptionResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                $metadata = deserializeMetadata(output);
+                statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
+                response = new __BaseException({
+                    name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
+                    $fault: "client",
+                    $metadata: $metadata,
+                });
+                throw __decorateServiceException(response, parsedBody);
+        }
+    });
+}); };
 export var deserializeAws_restJson1GetDeviceRegistrationCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var contents, data, _a, _b;
     return __generator(this, function (_c) {
@@ -175,6 +258,26 @@ var deserializeAws_restJson1InternalServiceExceptionResponse = function (parsedO
         return [2, __decorateServiceException(exception, parsedOutput.body)];
     });
 }); };
+var serializeAws_restJson1DeploymentModel = function (input, context) {
+    return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, (input.DesiredState != null && { DesiredState: input.DesiredState })), (input.ModelHandle != null && { ModelHandle: input.ModelHandle })), (input.ModelName != null && { ModelName: input.ModelName })), (input.ModelVersion != null && { ModelVersion: input.ModelVersion })), (input.RollbackFailureReason != null && { RollbackFailureReason: input.RollbackFailureReason })), (input.State != null && { State: input.State })), (input.Status != null && { Status: input.Status })), (input.StatusReason != null && { StatusReason: input.StatusReason }));
+};
+var serializeAws_restJson1DeploymentModels = function (input, context) {
+    return input
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
+        if (entry === null) {
+            return null;
+        }
+        return serializeAws_restJson1DeploymentModel(entry, context);
+    });
+};
+var serializeAws_restJson1DeploymentResult = function (input, context) {
+    return __assign(__assign(__assign(__assign(__assign(__assign({}, (input.DeploymentEndTime != null && { DeploymentEndTime: Math.round(input.DeploymentEndTime.getTime() / 1000) })), (input.DeploymentModels != null && {
+        DeploymentModels: serializeAws_restJson1DeploymentModels(input.DeploymentModels, context),
+    })), (input.DeploymentName != null && { DeploymentName: input.DeploymentName })), (input.DeploymentStartTime != null && {
+        DeploymentStartTime: Math.round(input.DeploymentStartTime.getTime() / 1000),
+    })), (input.DeploymentStatus != null && { DeploymentStatus: input.DeploymentStatus })), (input.DeploymentStatusMessage != null && { DeploymentStatusMessage: input.DeploymentStatusMessage }));
+};
 var serializeAws_restJson1EdgeMetric = function (input, context) {
     return __assign(__assign(__assign(__assign({}, (input.Dimension != null && { Dimension: input.Dimension })), (input.MetricName != null && { MetricName: input.MetricName })), (input.Timestamp != null && { Timestamp: Math.round(input.Timestamp.getTime() / 1000) })), (input.Value != null && { Value: __serializeFloat(input.Value) }));
 };
@@ -201,6 +304,50 @@ var serializeAws_restJson1Models = function (input, context) {
         return serializeAws_restJson1Model(entry, context);
     });
 };
+var deserializeAws_restJson1Checksum = function (output, context) {
+    return {
+        Sum: __expectString(output.Sum),
+        Type: __expectString(output.Type),
+    };
+};
+var deserializeAws_restJson1Definition = function (output, context) {
+    return {
+        Checksum: output.Checksum != null ? deserializeAws_restJson1Checksum(output.Checksum, context) : undefined,
+        ModelHandle: __expectString(output.ModelHandle),
+        S3Url: __expectString(output.S3Url),
+        State: __expectString(output.State),
+    };
+};
+var deserializeAws_restJson1Definitions = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1Definition(entry, context);
+    });
+    return retVal;
+};
+var deserializeAws_restJson1EdgeDeployment = function (output, context) {
+    return {
+        Definitions: output.Definitions != null ? deserializeAws_restJson1Definitions(output.Definitions, context) : undefined,
+        DeploymentName: __expectString(output.DeploymentName),
+        FailureHandlingPolicy: __expectString(output.FailureHandlingPolicy),
+        Type: __expectString(output.Type),
+    };
+};
+var deserializeAws_restJson1EdgeDeployments = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1EdgeDeployment(entry, context);
+    });
+    return retVal;
+};
 var deserializeMetadata = function (output) {
     var _a;
     return ({
@@ -239,6 +386,9 @@ var loadRestJsonErrorCode = function (output, data) {
     var findKey = function (object, key) { return Object.keys(object).find(function (k) { return k.toLowerCase() === key.toLowerCase(); }); };
     var sanitizeErrorCode = function (rawValue) {
         var cleanValue = rawValue;
+        if (typeof cleanValue === "number") {
+            cleanValue = cleanValue.toString();
+        }
         if (cleanValue.indexOf(":") >= 0) {
             cleanValue = cleanValue.split(":")[0];
         }

package/dist-types/SagemakerEdge.d.ts

@@ -1,4 +1,5 @@
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+import { GetDeploymentsCommandInput, GetDeploymentsCommandOutput } from "./commands/GetDeploymentsCommand";
 import { GetDeviceRegistrationCommandInput, GetDeviceRegistrationCommandOutput } from "./commands/GetDeviceRegistrationCommand";
 import { SendHeartbeatCommandInput, SendHeartbeatCommandOutput } from "./commands/SendHeartbeatCommand";
 import { SagemakerEdgeClient } from "./SagemakerEdgeClient";
@@ -6,6 +7,12 @@ import { SagemakerEdgeClient } from "./SagemakerEdgeClient";
  * <p>SageMaker Edge Manager dataplane service for communicating with active agents.</p>
  */
 export declare class SagemakerEdge extends SagemakerEdgeClient {
+    /**
+     * <p>Use to get the active deployments from a device.</p>
+     */
+    getDeployments(args: GetDeploymentsCommandInput, options?: __HttpHandlerOptions): Promise<GetDeploymentsCommandOutput>;
+    getDeployments(args: GetDeploymentsCommandInput, cb: (err: any, data?: GetDeploymentsCommandOutput) => void): void;
+    getDeployments(args: GetDeploymentsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDeploymentsCommandOutput) => void): void;
     /**
      * <p>Use to check if a device is registered with SageMaker Edge Manager.</p>
      */

package/dist-types/SagemakerEdgeClient.d.ts

@@ -6,10 +6,11 @@ import { UserAgentInputConfig, UserAgentResolvedConfig } from "@aws-sdk/middlewa
 import { HttpHandler as __HttpHandler } from "@aws-sdk/protocol-http";
 import { Client as __Client, DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@aws-sdk/smithy-client";
 import { BodyLengthCalculator as __BodyLengthCalculator, Credentials as __Credentials, Decoder as __Decoder, Encoder as __Encoder, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, RegionInfoProvider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@aws-sdk/types";
+import { GetDeploymentsCommandInput, GetDeploymentsCommandOutput } from "./commands/GetDeploymentsCommand";
 import { GetDeviceRegistrationCommandInput, GetDeviceRegistrationCommandOutput } from "./commands/GetDeviceRegistrationCommand";
 import { SendHeartbeatCommandInput, SendHeartbeatCommandOutput } from "./commands/SendHeartbeatCommand";
-export declare type ServiceInputTypes = GetDeviceRegistrationCommandInput | SendHeartbeatCommandInput;
-export declare type ServiceOutputTypes = GetDeviceRegistrationCommandOutput | SendHeartbeatCommandOutput;
+export declare type ServiceInputTypes = GetDeploymentsCommandInput | GetDeviceRegistrationCommandInput | SendHeartbeatCommandInput;
+export declare type ServiceOutputTypes = GetDeploymentsCommandOutput | GetDeviceRegistrationCommandOutput | SendHeartbeatCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
     /**
      * The HTTP handler to use. Fetch in browser and Https in Nodejs.

package/dist-types/commands/GetDeploymentsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetDeploymentsRequest, GetDeploymentsResult } from "../models/models_0";
+import { SagemakerEdgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SagemakerEdgeClient";
+export interface GetDeploymentsCommandInput extends GetDeploymentsRequest {
+}
+export interface GetDeploymentsCommandOutput extends GetDeploymentsResult, __MetadataBearer {
+}
+/**
+ * <p>Use to get the active deployments from a device.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SagemakerEdgeClient, GetDeploymentsCommand } from "@aws-sdk/client-sagemaker-edge"; // ES Modules import
+ * // const { SagemakerEdgeClient, GetDeploymentsCommand } = require("@aws-sdk/client-sagemaker-edge"); // CommonJS import
+ * const client = new SagemakerEdgeClient(config);
+ * const command = new GetDeploymentsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDeploymentsCommandInput} for command's `input` shape.
+ * @see {@link GetDeploymentsCommandOutput} for command's `response` shape.
+ * @see {@link SagemakerEdgeClientResolvedConfig | config} for SagemakerEdgeClient's `config` shape.
+ *
+ */
+export declare class GetDeploymentsCommand extends $Command<GetDeploymentsCommandInput, GetDeploymentsCommandOutput, SagemakerEdgeClientResolvedConfig> {
+    readonly input: GetDeploymentsCommandInput;
+    constructor(input: GetDeploymentsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SagemakerEdgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeploymentsCommandInput, GetDeploymentsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/index.d.ts

@@ -1,2 +1,3 @@
+export * from "./GetDeploymentsCommand";
 export * from "./GetDeviceRegistrationCommand";
 export * from "./SendHeartbeatCommand";

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

@@ -1,8 +1,8 @@
 import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
 import { SagemakerEdgeServiceException as __BaseException } from "./SagemakerEdgeServiceException";
-export interface GetDeviceRegistrationRequest {
+export interface GetDeploymentsRequest {
     /**
-     * <p>The unique name of the device you want to get the registration status from.</p>
+     * <p>The unique name of the device you want to get the configuration of active deployments from.</p>
      */
     DeviceName: string | undefined;
     /**
@@ -10,31 +10,114 @@ export interface GetDeviceRegistrationRequest {
      */
     DeviceFleetName: string | undefined;
 }
-export declare namespace GetDeviceRegistrationRequest {
+export declare namespace GetDeploymentsRequest {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: GetDeviceRegistrationRequest) => any;
+    const filterSensitiveLog: (obj: GetDeploymentsRequest) => any;
 }
-export interface GetDeviceRegistrationResult {
+export declare enum ChecksumType {
+    Sha1 = "SHA1"
+}
+/**
+ * <p>Information about the checksum of a model deployed on a device.</p>
+ */
+export interface Checksum {
     /**
-     * <p>Describes if the device is currently registered with SageMaker Edge Manager.</p>
+     * <p>The type of the checksum.</p>
      */
-    DeviceRegistration?: string;
+    Type?: ChecksumType | string;
     /**
-     * <p>The amount of time, in seconds, that the registration status is stored on the device’s cache before it is refreshed.</p>
+     * <p>The checksum of the model.</p>
      */
-    CacheTTL?: string;
+    Sum?: string;
 }
-export declare namespace GetDeviceRegistrationResult {
+export declare namespace Checksum {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: GetDeviceRegistrationResult) => any;
+    const filterSensitiveLog: (obj: Checksum) => any;
+}
+export declare enum ModelState {
+    Deploy = "DEPLOY",
+    Undeploy = "UNDEPLOY"
+}
+/**
+ * <p></p>
+ */
+export interface Definition {
+    /**
+     * <p>The unique model handle.</p>
+     */
+    ModelHandle?: string;
+    /**
+     * <p>The absolute S3 location of the model.</p>
+     */
+    S3Url?: string;
+    /**
+     * <p>The checksum information of the model.</p>
+     */
+    Checksum?: Checksum;
+    /**
+     * <p>The desired state of the model.</p>
+     */
+    State?: ModelState | string;
+}
+export declare namespace Definition {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: Definition) => any;
+}
+export declare enum FailureHandlingPolicy {
+    DoNothing = "DO_NOTHING",
+    RollbackOnFailure = "ROLLBACK_ON_FAILURE"
+}
+export declare enum DeploymentType {
+    Model = "Model"
+}
+/**
+ * <p>Information about a deployment on an edge device that is registered with SageMaker Edge Manager.</p>
+ */
+export interface EdgeDeployment {
+    /**
+     * <p>The name and unique ID of the deployment.</p>
+     */
+    DeploymentName?: string;
+    /**
+     * <p>The type of the deployment.</p>
+     */
+    Type?: DeploymentType | string;
+    /**
+     * <p>Determines whether to rollback to previous configuration if deployment fails.</p>
+     */
+    FailureHandlingPolicy?: FailureHandlingPolicy | string;
+    /**
+     * <p>Returns a list of Definition objects.</p>
+     */
+    Definitions?: Definition[];
+}
+export declare namespace EdgeDeployment {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: EdgeDeployment) => any;
+}
+export interface GetDeploymentsResult {
+    /**
+     * <p>Returns a list of the configurations of the active deployments on the device.</p>
+     */
+    Deployments?: EdgeDeployment[];
+}
+export declare namespace GetDeploymentsResult {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetDeploymentsResult) => any;
 }
 /**
  * <p>An internal failure occurred. Try your request again. If the problem
- *       persists, contact AWS customer support.</p>
+ *       persists, contact Amazon Web Services customer support.</p>
  */
 export declare class InternalServiceException extends __BaseException {
     readonly name: "InternalServiceException";
@@ -45,6 +128,38 @@ export declare class InternalServiceException extends __BaseException {
      */
     constructor(opts: __ExceptionOptionType<InternalServiceException, __BaseException>);
 }
+export interface GetDeviceRegistrationRequest {
+    /**
+     * <p>The unique name of the device you want to get the registration status from.</p>
+     */
+    DeviceName: string | undefined;
+    /**
+     * <p>The name of the fleet that the device belongs to.</p>
+     */
+    DeviceFleetName: string | undefined;
+}
+export declare namespace GetDeviceRegistrationRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetDeviceRegistrationRequest) => any;
+}
+export interface GetDeviceRegistrationResult {
+    /**
+     * <p>Describes if the device is currently registered with SageMaker Edge Manager.</p>
+     */
+    DeviceRegistration?: string;
+    /**
+     * <p>The amount of time, in seconds, that the registration status is stored on the device’s cache before it is refreshed.</p>
+     */
+    CacheTTL?: string;
+}
+export declare namespace GetDeviceRegistrationResult {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetDeviceRegistrationResult) => any;
+}
 /**
  * <p>Information required for edge device metrics.</p>
  */
@@ -72,6 +187,88 @@ export declare namespace EdgeMetric {
      */
     const filterSensitiveLog: (obj: EdgeMetric) => any;
 }
+export declare enum DeploymentStatus {
+    Fail = "FAIL",
+    Success = "SUCCESS"
+}
+/**
+ * <p></p>
+ */
+export interface DeploymentModel {
+    /**
+     * <p>The unique handle of the model.</p>
+     */
+    ModelHandle?: string;
+    /**
+     * <p>The name of the model.</p>
+     */
+    ModelName?: string;
+    /**
+     * <p>The version of the model.</p>
+     */
+    ModelVersion?: string;
+    /**
+     * <p>The desired state of the model.</p>
+     */
+    DesiredState?: ModelState | string;
+    /**
+     * <p>Returns the current state of the model.</p>
+     */
+    State?: ModelState | string;
+    /**
+     * <p>Returns the deployment status of the model.</p>
+     */
+    Status?: DeploymentStatus | string;
+    /**
+     * <p>Returns the error message for the deployment status result.</p>
+     */
+    StatusReason?: string;
+    /**
+     * <p>Returns the error message if there is a rollback.</p>
+     */
+    RollbackFailureReason?: string;
+}
+export declare namespace DeploymentModel {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeploymentModel) => any;
+}
+/**
+ * <p>Information about the result of a deployment on an edge device that is registered with SageMaker Edge Manager.</p>
+ */
+export interface DeploymentResult {
+    /**
+     * <p>The name and unique ID of the deployment.</p>
+     */
+    DeploymentName?: string;
+    /**
+     * <p>Returns the bucket error code.</p>
+     */
+    DeploymentStatus?: string;
+    /**
+     * <p>Returns the detailed error message.</p>
+     */
+    DeploymentStatusMessage?: string;
+    /**
+     * <p>The timestamp of when the deployment was started on the agent.</p>
+     */
+    DeploymentStartTime?: Date;
+    /**
+     * <p>The timestamp of when the deployment was ended, and the agent got the deployment results.</p>
+     */
+    DeploymentEndTime?: Date;
+    /**
+     * <p>Returns a list of models deployed on the agent.</p>
+     */
+    DeploymentModels?: DeploymentModel[];
+}
+export declare namespace DeploymentResult {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeploymentResult) => any;
+}
 /**
  * <p>Information about a model deployed on an edge device that is registered with SageMaker Edge Manager.</p>
  */
@@ -124,6 +321,10 @@ export interface SendHeartbeatRequest {
      * <p>The name of the fleet that the device belongs to.</p>
      */
     DeviceFleetName: string | undefined;
+    /**
+     * <p>Returns the result of a deployment on the device.</p>
+     */
+    DeploymentResult?: DeploymentResult;
 }
 export declare namespace SendHeartbeatRequest {
     /**

package/dist-types/protocols/Aws_restJson1.d.ts

@@ -1,8 +1,11 @@
 import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
 import { SerdeContext as __SerdeContext } from "@aws-sdk/types";
+import { GetDeploymentsCommandInput, GetDeploymentsCommandOutput } from "../commands/GetDeploymentsCommand";
 import { GetDeviceRegistrationCommandInput, GetDeviceRegistrationCommandOutput } from "../commands/GetDeviceRegistrationCommand";
 import { SendHeartbeatCommandInput, SendHeartbeatCommandOutput } from "../commands/SendHeartbeatCommand";
+export declare const serializeAws_restJson1GetDeploymentsCommand: (input: GetDeploymentsCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_restJson1GetDeviceRegistrationCommand: (input: GetDeviceRegistrationCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_restJson1SendHeartbeatCommand: (input: SendHeartbeatCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const deserializeAws_restJson1GetDeploymentsCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetDeploymentsCommandOutput>;
 export declare const deserializeAws_restJson1GetDeviceRegistrationCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetDeviceRegistrationCommandOutput>;
 export declare const deserializeAws_restJson1SendHeartbeatCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<SendHeartbeatCommandOutput>;

package/dist-types/ts3.4/SagemakerEdge.d.ts

@@ -1,10 +1,15 @@
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types";
+import { GetDeploymentsCommandInput, GetDeploymentsCommandOutput } from "./commands/GetDeploymentsCommand";
 import { GetDeviceRegistrationCommandInput, GetDeviceRegistrationCommandOutput } from "./commands/GetDeviceRegistrationCommand";
 import { SendHeartbeatCommandInput, SendHeartbeatCommandOutput } from "./commands/SendHeartbeatCommand";
 import { SagemakerEdgeClient } from "./SagemakerEdgeClient";
 
 export declare class SagemakerEdge extends SagemakerEdgeClient {
     
+    getDeployments(args: GetDeploymentsCommandInput, options?: __HttpHandlerOptions): Promise<GetDeploymentsCommandOutput>;
+    getDeployments(args: GetDeploymentsCommandInput, cb: (err: any, data?: GetDeploymentsCommandOutput) => void): void;
+    getDeployments(args: GetDeploymentsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDeploymentsCommandOutput) => void): void;
+    
     getDeviceRegistration(args: GetDeviceRegistrationCommandInput, options?: __HttpHandlerOptions): Promise<GetDeviceRegistrationCommandOutput>;
     getDeviceRegistration(args: GetDeviceRegistrationCommandInput, cb: (err: any, data?: GetDeviceRegistrationCommandOutput) => void): void;
     getDeviceRegistration(args: GetDeviceRegistrationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetDeviceRegistrationCommandOutput) => void): void;

package/dist-types/ts3.4/SagemakerEdgeClient.d.ts

@@ -6,10 +6,11 @@ import { UserAgentInputConfig, UserAgentResolvedConfig } from "@aws-sdk/middlewa
 import { HttpHandler as __HttpHandler } from "@aws-sdk/protocol-http";
 import { Client as __Client, DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@aws-sdk/smithy-client";
 import { BodyLengthCalculator as __BodyLengthCalculator, Credentials as __Credentials, Decoder as __Decoder, Encoder as __Encoder, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, Provider, RegionInfoProvider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@aws-sdk/types";
+import { GetDeploymentsCommandInput, GetDeploymentsCommandOutput } from "./commands/GetDeploymentsCommand";
 import { GetDeviceRegistrationCommandInput, GetDeviceRegistrationCommandOutput } from "./commands/GetDeviceRegistrationCommand";
 import { SendHeartbeatCommandInput, SendHeartbeatCommandOutput } from "./commands/SendHeartbeatCommand";
-export declare type ServiceInputTypes = GetDeviceRegistrationCommandInput | SendHeartbeatCommandInput;
-export declare type ServiceOutputTypes = GetDeviceRegistrationCommandOutput | SendHeartbeatCommandOutput;
+export declare type ServiceInputTypes = GetDeploymentsCommandInput | GetDeviceRegistrationCommandInput | SendHeartbeatCommandInput;
+export declare type ServiceOutputTypes = GetDeploymentsCommandOutput | GetDeviceRegistrationCommandOutput | SendHeartbeatCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
     
     requestHandler?: __HttpHandler;

package/dist-types/ts3.4/commands/GetDeploymentsCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetDeploymentsRequest, GetDeploymentsResult } from "../models/models_0";
+import { SagemakerEdgeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SagemakerEdgeClient";
+export interface GetDeploymentsCommandInput extends GetDeploymentsRequest {
+}
+export interface GetDeploymentsCommandOutput extends GetDeploymentsResult, __MetadataBearer {
+}
+
+export declare class GetDeploymentsCommand extends $Command<GetDeploymentsCommandInput, GetDeploymentsCommandOutput, SagemakerEdgeClientResolvedConfig> {
+    readonly input: GetDeploymentsCommandInput;
+    constructor(input: GetDeploymentsCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SagemakerEdgeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeploymentsCommandInput, GetDeploymentsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/index.d.ts

@@ -1,2 +1,3 @@
+export * from "./GetDeploymentsCommand";
 export * from "./GetDeviceRegistrationCommand";
 export * from "./SendHeartbeatCommand";