@aws-sdk/client-iottwinmaker 3.44.0

package/dist-es/models/models_0.js

@@ -0,0 +1,469 @@
+import { __assign } from "tslib";
+export var AccessDeniedException;
+(function (AccessDeniedException) {
+    AccessDeniedException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(AccessDeniedException || (AccessDeniedException = {}));
+export var EntityPropertyReference;
+(function (EntityPropertyReference) {
+    EntityPropertyReference.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(EntityPropertyReference || (EntityPropertyReference = {}));
+export var RelationshipValue;
+(function (RelationshipValue) {
+    RelationshipValue.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RelationshipValue || (RelationshipValue = {}));
+export var InternalServerException;
+(function (InternalServerException) {
+    InternalServerException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(InternalServerException || (InternalServerException = {}));
+export var ResourceNotFoundException;
+(function (ResourceNotFoundException) {
+    ResourceNotFoundException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ResourceNotFoundException || (ResourceNotFoundException = {}));
+export var ThrottlingException;
+(function (ThrottlingException) {
+    ThrottlingException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ThrottlingException || (ThrottlingException = {}));
+export var ValidationException;
+(function (ValidationException) {
+    ValidationException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ValidationException || (ValidationException = {}));
+export var ConflictException;
+(function (ConflictException) {
+    ConflictException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ConflictException || (ConflictException = {}));
+export var LambdaFunction;
+(function (LambdaFunction) {
+    LambdaFunction.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(LambdaFunction || (LambdaFunction = {}));
+export var DataConnector;
+(function (DataConnector) {
+    DataConnector.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DataConnector || (DataConnector = {}));
+export var Scope;
+(function (Scope) {
+    Scope["ENTITY"] = "ENTITY";
+    Scope["WORKSPACE"] = "WORKSPACE";
+})(Scope || (Scope = {}));
+export var FunctionRequest;
+(function (FunctionRequest) {
+    FunctionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(FunctionRequest || (FunctionRequest = {}));
+export var Relationship;
+(function (Relationship) {
+    Relationship.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Relationship || (Relationship = {}));
+export var Type;
+(function (Type) {
+    Type["BOOLEAN"] = "BOOLEAN";
+    Type["DOUBLE"] = "DOUBLE";
+    Type["INTEGER"] = "INTEGER";
+    Type["LIST"] = "LIST";
+    Type["LONG"] = "LONG";
+    Type["MAP"] = "MAP";
+    Type["RELATIONSHIP"] = "RELATIONSHIP";
+    Type["STRING"] = "STRING";
+})(Type || (Type = {}));
+export var State;
+(function (State) {
+    State["ACTIVE"] = "ACTIVE";
+    State["CREATING"] = "CREATING";
+    State["DELETING"] = "DELETING";
+    State["ERROR"] = "ERROR";
+    State["UPDATING"] = "UPDATING";
+})(State || (State = {}));
+export var CreateComponentTypeResponse;
+(function (CreateComponentTypeResponse) {
+    CreateComponentTypeResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateComponentTypeResponse || (CreateComponentTypeResponse = {}));
+export var ServiceQuotaExceededException;
+(function (ServiceQuotaExceededException) {
+    ServiceQuotaExceededException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ServiceQuotaExceededException || (ServiceQuotaExceededException = {}));
+export var PropertyUpdateType;
+(function (PropertyUpdateType) {
+    PropertyUpdateType["DELETE"] = "DELETE";
+    PropertyUpdateType["UPDATE"] = "UPDATE";
+})(PropertyUpdateType || (PropertyUpdateType = {}));
+export var CreateEntityResponse;
+(function (CreateEntityResponse) {
+    CreateEntityResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateEntityResponse || (CreateEntityResponse = {}));
+export var CreateSceneRequest;
+(function (CreateSceneRequest) {
+    CreateSceneRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateSceneRequest || (CreateSceneRequest = {}));
+export var CreateSceneResponse;
+(function (CreateSceneResponse) {
+    CreateSceneResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateSceneResponse || (CreateSceneResponse = {}));
+export var CreateWorkspaceRequest;
+(function (CreateWorkspaceRequest) {
+    CreateWorkspaceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateWorkspaceRequest || (CreateWorkspaceRequest = {}));
+export var CreateWorkspaceResponse;
+(function (CreateWorkspaceResponse) {
+    CreateWorkspaceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateWorkspaceResponse || (CreateWorkspaceResponse = {}));
+export var DeleteComponentTypeRequest;
+(function (DeleteComponentTypeRequest) {
+    DeleteComponentTypeRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteComponentTypeRequest || (DeleteComponentTypeRequest = {}));
+export var DeleteComponentTypeResponse;
+(function (DeleteComponentTypeResponse) {
+    DeleteComponentTypeResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteComponentTypeResponse || (DeleteComponentTypeResponse = {}));
+export var DeleteEntityRequest;
+(function (DeleteEntityRequest) {
+    DeleteEntityRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteEntityRequest || (DeleteEntityRequest = {}));
+export var DeleteEntityResponse;
+(function (DeleteEntityResponse) {
+    DeleteEntityResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteEntityResponse || (DeleteEntityResponse = {}));
+export var DeleteSceneRequest;
+(function (DeleteSceneRequest) {
+    DeleteSceneRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteSceneRequest || (DeleteSceneRequest = {}));
+export var DeleteSceneResponse;
+(function (DeleteSceneResponse) {
+    DeleteSceneResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteSceneResponse || (DeleteSceneResponse = {}));
+export var DeleteWorkspaceRequest;
+(function (DeleteWorkspaceRequest) {
+    DeleteWorkspaceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteWorkspaceRequest || (DeleteWorkspaceRequest = {}));
+export var DeleteWorkspaceResponse;
+(function (DeleteWorkspaceResponse) {
+    DeleteWorkspaceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteWorkspaceResponse || (DeleteWorkspaceResponse = {}));
+export var GetComponentTypeRequest;
+(function (GetComponentTypeRequest) {
+    GetComponentTypeRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetComponentTypeRequest || (GetComponentTypeRequest = {}));
+export var FunctionResponse;
+(function (FunctionResponse) {
+    FunctionResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(FunctionResponse || (FunctionResponse = {}));
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["INTERNAL_FAILURE"] = "INTERNAL_FAILURE";
+    ErrorCode["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+})(ErrorCode || (ErrorCode = {}));
+export var ErrorDetails;
+(function (ErrorDetails) {
+    ErrorDetails.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ErrorDetails || (ErrorDetails = {}));
+export var Status;
+(function (Status) {
+    Status.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(Status || (Status = {}));
+export var GetEntityRequest;
+(function (GetEntityRequest) {
+    GetEntityRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetEntityRequest || (GetEntityRequest = {}));
+export var ConnectorFailureException;
+(function (ConnectorFailureException) {
+    ConnectorFailureException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ConnectorFailureException || (ConnectorFailureException = {}));
+export var ConnectorTimeoutException;
+(function (ConnectorTimeoutException) {
+    ConnectorTimeoutException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ConnectorTimeoutException || (ConnectorTimeoutException = {}));
+export var GetPropertyValueRequest;
+(function (GetPropertyValueRequest) {
+    GetPropertyValueRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetPropertyValueRequest || (GetPropertyValueRequest = {}));
+export var InterpolationType;
+(function (InterpolationType) {
+    InterpolationType["LINEAR"] = "LINEAR";
+})(InterpolationType || (InterpolationType = {}));
+export var InterpolationParameters;
+(function (InterpolationParameters) {
+    InterpolationParameters.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(InterpolationParameters || (InterpolationParameters = {}));
+export var OrderByTime;
+(function (OrderByTime) {
+    OrderByTime["ASCENDING"] = "ASCENDING";
+    OrderByTime["DESCENDING"] = "DESCENDING";
+})(OrderByTime || (OrderByTime = {}));
+export var GetSceneRequest;
+(function (GetSceneRequest) {
+    GetSceneRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetSceneRequest || (GetSceneRequest = {}));
+export var GetSceneResponse;
+(function (GetSceneResponse) {
+    GetSceneResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetSceneResponse || (GetSceneResponse = {}));
+export var GetWorkspaceRequest;
+(function (GetWorkspaceRequest) {
+    GetWorkspaceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetWorkspaceRequest || (GetWorkspaceRequest = {}));
+export var GetWorkspaceResponse;
+(function (GetWorkspaceResponse) {
+    GetWorkspaceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetWorkspaceResponse || (GetWorkspaceResponse = {}));
+export var ListComponentTypesFilter;
+(function (ListComponentTypesFilter) {
+    ListComponentTypesFilter.visit = function (value, visitor) {
+        if (value.extendsFrom !== undefined)
+            return visitor.extendsFrom(value.extendsFrom);
+        if (value.namespace !== undefined)
+            return visitor.namespace(value.namespace);
+        if (value.isAbstract !== undefined)
+            return visitor.isAbstract(value.isAbstract);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+    ListComponentTypesFilter.filterSensitiveLog = function (obj) {
+        var _a;
+        if (obj.extendsFrom !== undefined)
+            return { extendsFrom: obj.extendsFrom };
+        if (obj.namespace !== undefined)
+            return { namespace: obj.namespace };
+        if (obj.isAbstract !== undefined)
+            return { isAbstract: obj.isAbstract };
+        if (obj.$unknown !== undefined)
+            return _a = {}, _a[obj.$unknown[0]] = "UNKNOWN", _a;
+    };
+})(ListComponentTypesFilter || (ListComponentTypesFilter = {}));
+export var ListComponentTypesRequest;
+(function (ListComponentTypesRequest) {
+    ListComponentTypesRequest.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.filters && { filters: obj.filters.map(function (item) { return ListComponentTypesFilter.filterSensitiveLog(item); }) }))); };
+})(ListComponentTypesRequest || (ListComponentTypesRequest = {}));
+export var ComponentTypeSummary;
+(function (ComponentTypeSummary) {
+    ComponentTypeSummary.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ComponentTypeSummary || (ComponentTypeSummary = {}));
+export var ListComponentTypesResponse;
+(function (ListComponentTypesResponse) {
+    ListComponentTypesResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListComponentTypesResponse || (ListComponentTypesResponse = {}));
+export var ListEntitiesFilter;
+(function (ListEntitiesFilter) {
+    ListEntitiesFilter.visit = function (value, visitor) {
+        if (value.parentEntityId !== undefined)
+            return visitor.parentEntityId(value.parentEntityId);
+        if (value.componentTypeId !== undefined)
+            return visitor.componentTypeId(value.componentTypeId);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+    ListEntitiesFilter.filterSensitiveLog = function (obj) {
+        var _a;
+        if (obj.parentEntityId !== undefined)
+            return { parentEntityId: obj.parentEntityId };
+        if (obj.componentTypeId !== undefined)
+            return { componentTypeId: obj.componentTypeId };
+        if (obj.$unknown !== undefined)
+            return _a = {}, _a[obj.$unknown[0]] = "UNKNOWN", _a;
+    };
+})(ListEntitiesFilter || (ListEntitiesFilter = {}));
+export var ListEntitiesRequest;
+(function (ListEntitiesRequest) {
+    ListEntitiesRequest.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.filters && { filters: obj.filters.map(function (item) { return ListEntitiesFilter.filterSensitiveLog(item); }) }))); };
+})(ListEntitiesRequest || (ListEntitiesRequest = {}));
+export var EntitySummary;
+(function (EntitySummary) {
+    EntitySummary.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(EntitySummary || (EntitySummary = {}));
+export var ListEntitiesResponse;
+(function (ListEntitiesResponse) {
+    ListEntitiesResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListEntitiesResponse || (ListEntitiesResponse = {}));
+export var ListScenesRequest;
+(function (ListScenesRequest) {
+    ListScenesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListScenesRequest || (ListScenesRequest = {}));
+export var SceneSummary;
+(function (SceneSummary) {
+    SceneSummary.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(SceneSummary || (SceneSummary = {}));
+export var ListScenesResponse;
+(function (ListScenesResponse) {
+    ListScenesResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListScenesResponse || (ListScenesResponse = {}));
+export var ListTagsForResourceRequest;
+(function (ListTagsForResourceRequest) {
+    ListTagsForResourceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListTagsForResourceRequest || (ListTagsForResourceRequest = {}));
+export var ListTagsForResourceResponse;
+(function (ListTagsForResourceResponse) {
+    ListTagsForResourceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListTagsForResourceResponse || (ListTagsForResourceResponse = {}));
+export var ListWorkspacesRequest;
+(function (ListWorkspacesRequest) {
+    ListWorkspacesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListWorkspacesRequest || (ListWorkspacesRequest = {}));
+export var WorkspaceSummary;
+(function (WorkspaceSummary) {
+    WorkspaceSummary.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(WorkspaceSummary || (WorkspaceSummary = {}));
+export var ListWorkspacesResponse;
+(function (ListWorkspacesResponse) {
+    ListWorkspacesResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListWorkspacesResponse || (ListWorkspacesResponse = {}));
+export var TagResourceRequest;
+(function (TagResourceRequest) {
+    TagResourceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(TagResourceRequest || (TagResourceRequest = {}));
+export var TagResourceResponse;
+(function (TagResourceResponse) {
+    TagResourceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(TagResourceResponse || (TagResourceResponse = {}));
+export var TooManyTagsException;
+(function (TooManyTagsException) {
+    TooManyTagsException.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(TooManyTagsException || (TooManyTagsException = {}));
+export var UntagResourceRequest;
+(function (UntagResourceRequest) {
+    UntagResourceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UntagResourceRequest || (UntagResourceRequest = {}));
+export var UntagResourceResponse;
+(function (UntagResourceResponse) {
+    UntagResourceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UntagResourceResponse || (UntagResourceResponse = {}));
+export var UpdateComponentTypeResponse;
+(function (UpdateComponentTypeResponse) {
+    UpdateComponentTypeResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateComponentTypeResponse || (UpdateComponentTypeResponse = {}));
+export var ComponentUpdateType;
+(function (ComponentUpdateType) {
+    ComponentUpdateType["CREATE"] = "CREATE";
+    ComponentUpdateType["DELETE"] = "DELETE";
+    ComponentUpdateType["UPDATE"] = "UPDATE";
+})(ComponentUpdateType || (ComponentUpdateType = {}));
+export var ParentEntityUpdateType;
+(function (ParentEntityUpdateType) {
+    ParentEntityUpdateType["DELETE"] = "DELETE";
+    ParentEntityUpdateType["UPDATE"] = "UPDATE";
+})(ParentEntityUpdateType || (ParentEntityUpdateType = {}));
+export var ParentEntityUpdateRequest;
+(function (ParentEntityUpdateRequest) {
+    ParentEntityUpdateRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ParentEntityUpdateRequest || (ParentEntityUpdateRequest = {}));
+export var UpdateEntityResponse;
+(function (UpdateEntityResponse) {
+    UpdateEntityResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateEntityResponse || (UpdateEntityResponse = {}));
+export var UpdateSceneRequest;
+(function (UpdateSceneRequest) {
+    UpdateSceneRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateSceneRequest || (UpdateSceneRequest = {}));
+export var UpdateSceneResponse;
+(function (UpdateSceneResponse) {
+    UpdateSceneResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateSceneResponse || (UpdateSceneResponse = {}));
+export var UpdateWorkspaceRequest;
+(function (UpdateWorkspaceRequest) {
+    UpdateWorkspaceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateWorkspaceRequest || (UpdateWorkspaceRequest = {}));
+export var UpdateWorkspaceResponse;
+(function (UpdateWorkspaceResponse) {
+    UpdateWorkspaceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateWorkspaceResponse || (UpdateWorkspaceResponse = {}));
+export var DataValue;
+(function (DataValue) {
+    DataValue.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DataValue || (DataValue = {}));
+export var PropertyFilter;
+(function (PropertyFilter) {
+    PropertyFilter.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PropertyFilter || (PropertyFilter = {}));
+export var PropertyLatestValue;
+(function (PropertyLatestValue) {
+    PropertyLatestValue.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PropertyLatestValue || (PropertyLatestValue = {}));
+export var PropertyValue;
+(function (PropertyValue) {
+    PropertyValue.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PropertyValue || (PropertyValue = {}));
+export var DataType;
+(function (DataType) {
+    DataType.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DataType || (DataType = {}));
+export var GetPropertyValueHistoryRequest;
+(function (GetPropertyValueHistoryRequest) {
+    GetPropertyValueHistoryRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetPropertyValueHistoryRequest || (GetPropertyValueHistoryRequest = {}));
+export var GetPropertyValueResponse;
+(function (GetPropertyValueResponse) {
+    GetPropertyValueResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetPropertyValueResponse || (GetPropertyValueResponse = {}));
+export var PropertyValueEntry;
+(function (PropertyValueEntry) {
+    PropertyValueEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PropertyValueEntry || (PropertyValueEntry = {}));
+export var PropertyValueHistory;
+(function (PropertyValueHistory) {
+    PropertyValueHistory.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PropertyValueHistory || (PropertyValueHistory = {}));
+export var BatchPutPropertyError;
+(function (BatchPutPropertyError) {
+    BatchPutPropertyError.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchPutPropertyError || (BatchPutPropertyError = {}));
+export var BatchPutPropertyValuesRequest;
+(function (BatchPutPropertyValuesRequest) {
+    BatchPutPropertyValuesRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchPutPropertyValuesRequest || (BatchPutPropertyValuesRequest = {}));
+export var GetPropertyValueHistoryResponse;
+(function (GetPropertyValueHistoryResponse) {
+    GetPropertyValueHistoryResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetPropertyValueHistoryResponse || (GetPropertyValueHistoryResponse = {}));
+export var BatchPutPropertyErrorEntry;
+(function (BatchPutPropertyErrorEntry) {
+    BatchPutPropertyErrorEntry.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchPutPropertyErrorEntry || (BatchPutPropertyErrorEntry = {}));
+export var PropertyDefinitionRequest;
+(function (PropertyDefinitionRequest) {
+    PropertyDefinitionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PropertyDefinitionRequest || (PropertyDefinitionRequest = {}));
+export var PropertyDefinitionResponse;
+(function (PropertyDefinitionResponse) {
+    PropertyDefinitionResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PropertyDefinitionResponse || (PropertyDefinitionResponse = {}));
+export var BatchPutPropertyValuesResponse;
+(function (BatchPutPropertyValuesResponse) {
+    BatchPutPropertyValuesResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(BatchPutPropertyValuesResponse || (BatchPutPropertyValuesResponse = {}));
+export var CreateComponentTypeRequest;
+(function (CreateComponentTypeRequest) {
+    CreateComponentTypeRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateComponentTypeRequest || (CreateComponentTypeRequest = {}));
+export var GetComponentTypeResponse;
+(function (GetComponentTypeResponse) {
+    GetComponentTypeResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetComponentTypeResponse || (GetComponentTypeResponse = {}));
+export var UpdateComponentTypeRequest;
+(function (UpdateComponentTypeRequest) {
+    UpdateComponentTypeRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateComponentTypeRequest || (UpdateComponentTypeRequest = {}));
+export var PropertyRequest;
+(function (PropertyRequest) {
+    PropertyRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PropertyRequest || (PropertyRequest = {}));
+export var PropertyResponse;
+(function (PropertyResponse) {
+    PropertyResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(PropertyResponse || (PropertyResponse = {}));
+export var ComponentRequest;
+(function (ComponentRequest) {
+    ComponentRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ComponentRequest || (ComponentRequest = {}));
+export var ComponentResponse;
+(function (ComponentResponse) {
+    ComponentResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ComponentResponse || (ComponentResponse = {}));
+export var ComponentUpdateRequest;
+(function (ComponentUpdateRequest) {
+    ComponentUpdateRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ComponentUpdateRequest || (ComponentUpdateRequest = {}));
+export var CreateEntityRequest;
+(function (CreateEntityRequest) {
+    CreateEntityRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateEntityRequest || (CreateEntityRequest = {}));
+export var GetEntityResponse;
+(function (GetEntityResponse) {
+    GetEntityResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(GetEntityResponse || (GetEntityResponse = {}));
+export var UpdateEntityRequest;
+(function (UpdateEntityRequest) {
+    UpdateEntityRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(UpdateEntityRequest || (UpdateEntityRequest = {}));

package/dist-es/pagination/GetPropertyValueHistoryPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { GetPropertyValueHistoryCommand, } from "../commands/GetPropertyValueHistoryCommand";
+import { IoTTwinMaker } from "../IoTTwinMaker";
+import { IoTTwinMakerClient } from "../IoTTwinMakerClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new GetPropertyValueHistoryCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.getPropertyValueHistory.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateGetPropertyValueHistory(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateGetPropertyValueHistory_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.nextToken = token;
+                    input["maxResults"] = config.pageSize;
+                    if (!(config.client instanceof IoTTwinMaker)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof IoTTwinMakerClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected IoTTwinMaker | IoTTwinMakerClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.nextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/Interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist-es/pagination/ListComponentTypesPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListComponentTypesCommand, } from "../commands/ListComponentTypesCommand";
+import { IoTTwinMaker } from "../IoTTwinMaker";
+import { IoTTwinMakerClient } from "../IoTTwinMakerClient";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListComponentTypesCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.listComponentTypes.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListComponentTypes(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListComponentTypes_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.nextToken = token;
+                    input["maxResults"] = config.pageSize;
+                    if (!(config.client instanceof IoTTwinMaker)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof IoTTwinMakerClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected IoTTwinMaker | IoTTwinMakerClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.nextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}