@aws-sdk/client-iottwinmaker 3.44.0

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

@@ -0,0 +1,1382 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace AccessDeniedException {
+    
+    const filterSensitiveLog: (obj: AccessDeniedException) => any;
+}
+
+export interface EntityPropertyReference {
+    
+    componentName?: string;
+    
+    externalIdProperty?: {
+        [key: string]: string;
+    };
+    
+    entityId?: string;
+    
+    propertyName: string | undefined;
+}
+export declare namespace EntityPropertyReference {
+    
+    const filterSensitiveLog: (obj: EntityPropertyReference) => any;
+}
+
+export interface RelationshipValue {
+    
+    targetEntityId?: string;
+    
+    targetComponentName?: string;
+}
+export declare namespace RelationshipValue {
+    
+    const filterSensitiveLog: (obj: RelationshipValue) => any;
+}
+
+export interface InternalServerException extends __SmithyException, $MetadataBearer {
+    name: "InternalServerException";
+    $fault: "server";
+    message?: string;
+}
+export declare namespace InternalServerException {
+    
+    const filterSensitiveLog: (obj: InternalServerException) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ResourceNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ThrottlingException {
+    
+    const filterSensitiveLog: (obj: ThrottlingException) => any;
+}
+
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ValidationException {
+    
+    const filterSensitiveLog: (obj: ValidationException) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ConflictException {
+    
+    const filterSensitiveLog: (obj: ConflictException) => any;
+}
+
+export interface LambdaFunction {
+    
+    arn: string | undefined;
+}
+export declare namespace LambdaFunction {
+    
+    const filterSensitiveLog: (obj: LambdaFunction) => any;
+}
+
+export interface DataConnector {
+    
+    lambda?: LambdaFunction;
+    
+    isNative?: boolean;
+}
+export declare namespace DataConnector {
+    
+    const filterSensitiveLog: (obj: DataConnector) => any;
+}
+export declare enum Scope {
+    ENTITY = "ENTITY",
+    WORKSPACE = "WORKSPACE"
+}
+
+export interface FunctionRequest {
+    
+    requiredProperties?: string[];
+    
+    scope?: Scope | string;
+    
+    implementedBy?: DataConnector;
+}
+export declare namespace FunctionRequest {
+    
+    const filterSensitiveLog: (obj: FunctionRequest) => any;
+}
+
+export interface Relationship {
+    
+    targetComponentTypeId?: string;
+    
+    relationshipType?: string;
+}
+export declare namespace Relationship {
+    
+    const filterSensitiveLog: (obj: Relationship) => any;
+}
+export declare enum Type {
+    BOOLEAN = "BOOLEAN",
+    DOUBLE = "DOUBLE",
+    INTEGER = "INTEGER",
+    LIST = "LIST",
+    LONG = "LONG",
+    MAP = "MAP",
+    RELATIONSHIP = "RELATIONSHIP",
+    STRING = "STRING"
+}
+export declare enum State {
+    ACTIVE = "ACTIVE",
+    CREATING = "CREATING",
+    DELETING = "DELETING",
+    ERROR = "ERROR",
+    UPDATING = "UPDATING"
+}
+export interface CreateComponentTypeResponse {
+    
+    arn: string | undefined;
+    
+    creationDateTime: Date | undefined;
+    
+    state: State | string | undefined;
+}
+export declare namespace CreateComponentTypeResponse {
+    
+    const filterSensitiveLog: (obj: CreateComponentTypeResponse) => any;
+}
+
+export interface ServiceQuotaExceededException extends __SmithyException, $MetadataBearer {
+    name: "ServiceQuotaExceededException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ServiceQuotaExceededException {
+    
+    const filterSensitiveLog: (obj: ServiceQuotaExceededException) => any;
+}
+export declare enum PropertyUpdateType {
+    DELETE = "DELETE",
+    UPDATE = "UPDATE"
+}
+export interface CreateEntityResponse {
+    
+    entityId: string | undefined;
+    
+    arn: string | undefined;
+    
+    creationDateTime: Date | undefined;
+    
+    state: State | string | undefined;
+}
+export declare namespace CreateEntityResponse {
+    
+    const filterSensitiveLog: (obj: CreateEntityResponse) => any;
+}
+export interface CreateSceneRequest {
+    
+    workspaceId: string | undefined;
+    
+    sceneId: string | undefined;
+    
+    contentLocation: string | undefined;
+    
+    description?: string;
+    
+    capabilities?: string[];
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateSceneRequest {
+    
+    const filterSensitiveLog: (obj: CreateSceneRequest) => any;
+}
+export interface CreateSceneResponse {
+    
+    arn: string | undefined;
+    
+    creationDateTime: Date | undefined;
+}
+export declare namespace CreateSceneResponse {
+    
+    const filterSensitiveLog: (obj: CreateSceneResponse) => any;
+}
+export interface CreateWorkspaceRequest {
+    
+    workspaceId: string | undefined;
+    
+    description?: string;
+    
+    s3Location: string | undefined;
+    
+    role: string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateWorkspaceRequest {
+    
+    const filterSensitiveLog: (obj: CreateWorkspaceRequest) => any;
+}
+export interface CreateWorkspaceResponse {
+    
+    arn: string | undefined;
+    
+    creationDateTime: Date | undefined;
+}
+export declare namespace CreateWorkspaceResponse {
+    
+    const filterSensitiveLog: (obj: CreateWorkspaceResponse) => any;
+}
+export interface DeleteComponentTypeRequest {
+    
+    workspaceId: string | undefined;
+    
+    componentTypeId: string | undefined;
+}
+export declare namespace DeleteComponentTypeRequest {
+    
+    const filterSensitiveLog: (obj: DeleteComponentTypeRequest) => any;
+}
+export interface DeleteComponentTypeResponse {
+    
+    state: State | string | undefined;
+}
+export declare namespace DeleteComponentTypeResponse {
+    
+    const filterSensitiveLog: (obj: DeleteComponentTypeResponse) => any;
+}
+export interface DeleteEntityRequest {
+    
+    workspaceId: string | undefined;
+    
+    entityId: string | undefined;
+    
+    isRecursive?: boolean;
+}
+export declare namespace DeleteEntityRequest {
+    
+    const filterSensitiveLog: (obj: DeleteEntityRequest) => any;
+}
+export interface DeleteEntityResponse {
+    
+    state: State | string | undefined;
+}
+export declare namespace DeleteEntityResponse {
+    
+    const filterSensitiveLog: (obj: DeleteEntityResponse) => any;
+}
+export interface DeleteSceneRequest {
+    
+    workspaceId: string | undefined;
+    
+    sceneId: string | undefined;
+}
+export declare namespace DeleteSceneRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSceneRequest) => any;
+}
+export interface DeleteSceneResponse {
+}
+export declare namespace DeleteSceneResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSceneResponse) => any;
+}
+export interface DeleteWorkspaceRequest {
+    
+    workspaceId: string | undefined;
+}
+export declare namespace DeleteWorkspaceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteWorkspaceRequest) => any;
+}
+export interface DeleteWorkspaceResponse {
+}
+export declare namespace DeleteWorkspaceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteWorkspaceResponse) => any;
+}
+export interface GetComponentTypeRequest {
+    
+    workspaceId: string | undefined;
+    
+    componentTypeId: string | undefined;
+}
+export declare namespace GetComponentTypeRequest {
+    
+    const filterSensitiveLog: (obj: GetComponentTypeRequest) => any;
+}
+
+export interface FunctionResponse {
+    
+    requiredProperties?: string[];
+    
+    scope?: Scope | string;
+    
+    implementedBy?: DataConnector;
+    
+    isInherited?: boolean;
+}
+export declare namespace FunctionResponse {
+    
+    const filterSensitiveLog: (obj: FunctionResponse) => any;
+}
+export declare enum ErrorCode {
+    INTERNAL_FAILURE = "INTERNAL_FAILURE",
+    VALIDATION_ERROR = "VALIDATION_ERROR"
+}
+
+export interface ErrorDetails {
+    
+    code?: ErrorCode | string;
+    
+    message?: string;
+}
+export declare namespace ErrorDetails {
+    
+    const filterSensitiveLog: (obj: ErrorDetails) => any;
+}
+
+export interface Status {
+    
+    state?: State | string;
+    
+    error?: ErrorDetails;
+}
+export declare namespace Status {
+    
+    const filterSensitiveLog: (obj: Status) => any;
+}
+export interface GetEntityRequest {
+    
+    workspaceId: string | undefined;
+    
+    entityId: string | undefined;
+}
+export declare namespace GetEntityRequest {
+    
+    const filterSensitiveLog: (obj: GetEntityRequest) => any;
+}
+
+export interface ConnectorFailureException extends __SmithyException, $MetadataBearer {
+    name: "ConnectorFailureException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ConnectorFailureException {
+    
+    const filterSensitiveLog: (obj: ConnectorFailureException) => any;
+}
+
+export interface ConnectorTimeoutException extends __SmithyException, $MetadataBearer {
+    name: "ConnectorTimeoutException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ConnectorTimeoutException {
+    
+    const filterSensitiveLog: (obj: ConnectorTimeoutException) => any;
+}
+export interface GetPropertyValueRequest {
+    
+    componentName?: string;
+    
+    componentTypeId?: string;
+    
+    entityId?: string;
+    
+    selectedProperties: string[] | undefined;
+    
+    workspaceId: string | undefined;
+}
+export declare namespace GetPropertyValueRequest {
+    
+    const filterSensitiveLog: (obj: GetPropertyValueRequest) => any;
+}
+export declare enum InterpolationType {
+    LINEAR = "LINEAR"
+}
+
+export interface InterpolationParameters {
+    
+    interpolationType?: InterpolationType | string;
+    
+    intervalInSeconds?: number;
+}
+export declare namespace InterpolationParameters {
+    
+    const filterSensitiveLog: (obj: InterpolationParameters) => any;
+}
+export declare enum OrderByTime {
+    ASCENDING = "ASCENDING",
+    DESCENDING = "DESCENDING"
+}
+export interface GetSceneRequest {
+    
+    workspaceId: string | undefined;
+    
+    sceneId: string | undefined;
+}
+export declare namespace GetSceneRequest {
+    
+    const filterSensitiveLog: (obj: GetSceneRequest) => any;
+}
+export interface GetSceneResponse {
+    
+    workspaceId: string | undefined;
+    
+    sceneId: string | undefined;
+    
+    contentLocation: string | undefined;
+    
+    arn: string | undefined;
+    
+    creationDateTime: Date | undefined;
+    
+    updateDateTime: Date | undefined;
+    
+    description?: string;
+    
+    capabilities?: string[];
+}
+export declare namespace GetSceneResponse {
+    
+    const filterSensitiveLog: (obj: GetSceneResponse) => any;
+}
+export interface GetWorkspaceRequest {
+    
+    workspaceId: string | undefined;
+}
+export declare namespace GetWorkspaceRequest {
+    
+    const filterSensitiveLog: (obj: GetWorkspaceRequest) => any;
+}
+export interface GetWorkspaceResponse {
+    
+    workspaceId: string | undefined;
+    
+    arn: string | undefined;
+    
+    description?: string;
+    
+    s3Location: string | undefined;
+    
+    role: string | undefined;
+    
+    creationDateTime: Date | undefined;
+    
+    updateDateTime: Date | undefined;
+}
+export declare namespace GetWorkspaceResponse {
+    
+    const filterSensitiveLog: (obj: GetWorkspaceResponse) => any;
+}
+
+export declare type ListComponentTypesFilter = ListComponentTypesFilter.ExtendsFromMember | ListComponentTypesFilter.IsAbstractMember | ListComponentTypesFilter.NamespaceMember | ListComponentTypesFilter.$UnknownMember;
+export declare namespace ListComponentTypesFilter {
+    
+    interface ExtendsFromMember {
+        extendsFrom: string;
+        namespace?: never;
+        isAbstract?: never;
+        $unknown?: never;
+    }
+    
+    interface NamespaceMember {
+        extendsFrom?: never;
+        namespace: string;
+        isAbstract?: never;
+        $unknown?: never;
+    }
+    
+    interface IsAbstractMember {
+        extendsFrom?: never;
+        namespace?: never;
+        isAbstract: boolean;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        extendsFrom?: never;
+        namespace?: never;
+        isAbstract?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        extendsFrom: (value: string) => T;
+        namespace: (value: string) => T;
+        isAbstract: (value: boolean) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ListComponentTypesFilter, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: ListComponentTypesFilter) => any;
+}
+export interface ListComponentTypesRequest {
+    
+    workspaceId: string | undefined;
+    
+    filters?: ListComponentTypesFilter[];
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListComponentTypesRequest {
+    
+    const filterSensitiveLog: (obj: ListComponentTypesRequest) => any;
+}
+
+export interface ComponentTypeSummary {
+    
+    arn: string | undefined;
+    
+    componentTypeId: string | undefined;
+    
+    creationDateTime: Date | undefined;
+    
+    updateDateTime: Date | undefined;
+    
+    description?: string;
+    
+    status?: Status;
+}
+export declare namespace ComponentTypeSummary {
+    
+    const filterSensitiveLog: (obj: ComponentTypeSummary) => any;
+}
+export interface ListComponentTypesResponse {
+    
+    workspaceId: string | undefined;
+    
+    componentTypeSummaries: ComponentTypeSummary[] | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListComponentTypesResponse {
+    
+    const filterSensitiveLog: (obj: ListComponentTypesResponse) => any;
+}
+
+export declare type ListEntitiesFilter = ListEntitiesFilter.ComponentTypeIdMember | ListEntitiesFilter.ParentEntityIdMember | ListEntitiesFilter.$UnknownMember;
+export declare namespace ListEntitiesFilter {
+    
+    interface ParentEntityIdMember {
+        parentEntityId: string;
+        componentTypeId?: never;
+        $unknown?: never;
+    }
+    
+    interface ComponentTypeIdMember {
+        parentEntityId?: never;
+        componentTypeId: string;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        parentEntityId?: never;
+        componentTypeId?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        parentEntityId: (value: string) => T;
+        componentTypeId: (value: string) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ListEntitiesFilter, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: ListEntitiesFilter) => any;
+}
+export interface ListEntitiesRequest {
+    
+    workspaceId: string | undefined;
+    
+    filters?: ListEntitiesFilter[];
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListEntitiesRequest {
+    
+    const filterSensitiveLog: (obj: ListEntitiesRequest) => any;
+}
+
+export interface EntitySummary {
+    
+    entityId: string | undefined;
+    
+    entityName: string | undefined;
+    
+    arn: string | undefined;
+    
+    parentEntityId?: string;
+    
+    status: Status | undefined;
+    
+    description?: string;
+    
+    hasChildEntities?: boolean;
+    
+    creationDateTime: Date | undefined;
+    
+    updateDateTime: Date | undefined;
+}
+export declare namespace EntitySummary {
+    
+    const filterSensitiveLog: (obj: EntitySummary) => any;
+}
+export interface ListEntitiesResponse {
+    
+    entitySummaries?: EntitySummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListEntitiesResponse {
+    
+    const filterSensitiveLog: (obj: ListEntitiesResponse) => any;
+}
+export interface ListScenesRequest {
+    
+    workspaceId: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListScenesRequest {
+    
+    const filterSensitiveLog: (obj: ListScenesRequest) => any;
+}
+
+export interface SceneSummary {
+    
+    sceneId: string | undefined;
+    
+    contentLocation: string | undefined;
+    
+    arn: string | undefined;
+    
+    creationDateTime: Date | undefined;
+    
+    updateDateTime: Date | undefined;
+    
+    description?: string;
+}
+export declare namespace SceneSummary {
+    
+    const filterSensitiveLog: (obj: SceneSummary) => any;
+}
+export interface ListScenesResponse {
+    
+    sceneSummaries?: SceneSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListScenesResponse {
+    
+    const filterSensitiveLog: (obj: ListScenesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceARN: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    nextToken?: string;
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ListWorkspacesRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListWorkspacesRequest {
+    
+    const filterSensitiveLog: (obj: ListWorkspacesRequest) => any;
+}
+
+export interface WorkspaceSummary {
+    
+    workspaceId: string | undefined;
+    
+    arn: string | undefined;
+    
+    description?: string;
+    
+    creationDateTime: Date | undefined;
+    
+    updateDateTime: Date | undefined;
+}
+export declare namespace WorkspaceSummary {
+    
+    const filterSensitiveLog: (obj: WorkspaceSummary) => any;
+}
+export interface ListWorkspacesResponse {
+    
+    workspaceSummaries?: WorkspaceSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListWorkspacesResponse {
+    
+    const filterSensitiveLog: (obj: ListWorkspacesResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    resourceARN: string | undefined;
+    
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+
+export interface TooManyTagsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyTagsException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace TooManyTagsException {
+    
+    const filterSensitiveLog: (obj: TooManyTagsException) => any;
+}
+export interface UntagResourceRequest {
+    
+    resourceARN: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateComponentTypeResponse {
+    
+    workspaceId: string | undefined;
+    
+    arn: string | undefined;
+    
+    componentTypeId: string | undefined;
+    
+    state: State | string | undefined;
+}
+export declare namespace UpdateComponentTypeResponse {
+    
+    const filterSensitiveLog: (obj: UpdateComponentTypeResponse) => any;
+}
+export declare enum ComponentUpdateType {
+    CREATE = "CREATE",
+    DELETE = "DELETE",
+    UPDATE = "UPDATE"
+}
+export declare enum ParentEntityUpdateType {
+    DELETE = "DELETE",
+    UPDATE = "UPDATE"
+}
+
+export interface ParentEntityUpdateRequest {
+    
+    updateType: ParentEntityUpdateType | string | undefined;
+    
+    parentEntityId?: string;
+}
+export declare namespace ParentEntityUpdateRequest {
+    
+    const filterSensitiveLog: (obj: ParentEntityUpdateRequest) => any;
+}
+export interface UpdateEntityResponse {
+    
+    updateDateTime: Date | undefined;
+    
+    state: State | string | undefined;
+}
+export declare namespace UpdateEntityResponse {
+    
+    const filterSensitiveLog: (obj: UpdateEntityResponse) => any;
+}
+export interface UpdateSceneRequest {
+    
+    workspaceId: string | undefined;
+    
+    sceneId: string | undefined;
+    
+    contentLocation?: string;
+    
+    description?: string;
+    
+    capabilities?: string[];
+}
+export declare namespace UpdateSceneRequest {
+    
+    const filterSensitiveLog: (obj: UpdateSceneRequest) => any;
+}
+export interface UpdateSceneResponse {
+    
+    updateDateTime: Date | undefined;
+}
+export declare namespace UpdateSceneResponse {
+    
+    const filterSensitiveLog: (obj: UpdateSceneResponse) => any;
+}
+export interface UpdateWorkspaceRequest {
+    
+    workspaceId: string | undefined;
+    
+    description?: string;
+    
+    role?: string;
+}
+export declare namespace UpdateWorkspaceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateWorkspaceRequest) => any;
+}
+export interface UpdateWorkspaceResponse {
+    
+    updateDateTime: Date | undefined;
+}
+export declare namespace UpdateWorkspaceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateWorkspaceResponse) => any;
+}
+
+export interface DataValue {
+    
+    booleanValue?: boolean;
+    
+    doubleValue?: number;
+    
+    integerValue?: number;
+    
+    longValue?: number;
+    
+    stringValue?: string;
+    
+    listValue?: DataValue[];
+    
+    mapValue?: {
+        [key: string]: DataValue;
+    };
+    
+    relationshipValue?: RelationshipValue;
+    
+    expression?: string;
+}
+export declare namespace DataValue {
+    
+    const filterSensitiveLog: (obj: DataValue) => any;
+}
+
+export interface PropertyFilter {
+    
+    propertyName?: string;
+    
+    operator?: string;
+    
+    value?: DataValue;
+}
+export declare namespace PropertyFilter {
+    
+    const filterSensitiveLog: (obj: PropertyFilter) => any;
+}
+
+export interface PropertyLatestValue {
+    
+    propertyReference: EntityPropertyReference | undefined;
+    
+    propertyValue?: DataValue;
+}
+export declare namespace PropertyLatestValue {
+    
+    const filterSensitiveLog: (obj: PropertyLatestValue) => any;
+}
+
+export interface PropertyValue {
+    
+    timestamp: Date | undefined;
+    
+    value: DataValue | undefined;
+}
+export declare namespace PropertyValue {
+    
+    const filterSensitiveLog: (obj: PropertyValue) => any;
+}
+
+export interface DataType {
+    
+    type: Type | string | undefined;
+    
+    nestedType?: DataType;
+    
+    allowedValues?: DataValue[];
+    
+    unitOfMeasure?: string;
+    
+    relationship?: Relationship;
+}
+export declare namespace DataType {
+    
+    const filterSensitiveLog: (obj: DataType) => any;
+}
+export interface GetPropertyValueHistoryRequest {
+    
+    workspaceId: string | undefined;
+    
+    entityId?: string;
+    
+    componentName?: string;
+    
+    componentTypeId?: string;
+    
+    selectedProperties: string[] | undefined;
+    
+    propertyFilters?: PropertyFilter[];
+    
+    startDateTime: Date | undefined;
+    
+    endDateTime: Date | undefined;
+    
+    interpolation?: InterpolationParameters;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    orderByTime?: OrderByTime | string;
+}
+export declare namespace GetPropertyValueHistoryRequest {
+    
+    const filterSensitiveLog: (obj: GetPropertyValueHistoryRequest) => any;
+}
+export interface GetPropertyValueResponse {
+    
+    propertyValues: {
+        [key: string]: PropertyLatestValue;
+    } | undefined;
+}
+export declare namespace GetPropertyValueResponse {
+    
+    const filterSensitiveLog: (obj: GetPropertyValueResponse) => any;
+}
+
+export interface PropertyValueEntry {
+    
+    entityPropertyReference: EntityPropertyReference | undefined;
+    
+    propertyValues?: PropertyValue[];
+}
+export declare namespace PropertyValueEntry {
+    
+    const filterSensitiveLog: (obj: PropertyValueEntry) => any;
+}
+
+export interface PropertyValueHistory {
+    
+    entityPropertyReference: EntityPropertyReference | undefined;
+    
+    values?: PropertyValue[];
+}
+export declare namespace PropertyValueHistory {
+    
+    const filterSensitiveLog: (obj: PropertyValueHistory) => any;
+}
+
+export interface BatchPutPropertyError {
+    
+    errorCode: string | undefined;
+    
+    errorMessage: string | undefined;
+    
+    entry: PropertyValueEntry | undefined;
+}
+export declare namespace BatchPutPropertyError {
+    
+    const filterSensitiveLog: (obj: BatchPutPropertyError) => any;
+}
+export interface BatchPutPropertyValuesRequest {
+    
+    workspaceId: string | undefined;
+    
+    entries: PropertyValueEntry[] | undefined;
+}
+export declare namespace BatchPutPropertyValuesRequest {
+    
+    const filterSensitiveLog: (obj: BatchPutPropertyValuesRequest) => any;
+}
+export interface GetPropertyValueHistoryResponse {
+    
+    propertyValues: PropertyValueHistory[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace GetPropertyValueHistoryResponse {
+    
+    const filterSensitiveLog: (obj: GetPropertyValueHistoryResponse) => any;
+}
+
+export interface BatchPutPropertyErrorEntry {
+    
+    errors: BatchPutPropertyError[] | undefined;
+}
+export declare namespace BatchPutPropertyErrorEntry {
+    
+    const filterSensitiveLog: (obj: BatchPutPropertyErrorEntry) => any;
+}
+
+export interface PropertyDefinitionRequest {
+    
+    dataType?: DataType;
+    
+    isRequiredInEntity?: boolean;
+    
+    isExternalId?: boolean;
+    
+    isStoredExternally?: boolean;
+    
+    isTimeSeries?: boolean;
+    
+    defaultValue?: DataValue;
+    
+    configuration?: {
+        [key: string]: string;
+    };
+}
+export declare namespace PropertyDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: PropertyDefinitionRequest) => any;
+}
+
+export interface PropertyDefinitionResponse {
+    
+    dataType: DataType | undefined;
+    
+    isTimeSeries: boolean | undefined;
+    
+    isRequiredInEntity: boolean | undefined;
+    
+    isExternalId: boolean | undefined;
+    
+    isStoredExternally: boolean | undefined;
+    
+    isImported: boolean | undefined;
+    
+    isFinal: boolean | undefined;
+    
+    isInherited: boolean | undefined;
+    
+    defaultValue?: DataValue;
+    
+    configuration?: {
+        [key: string]: string;
+    };
+}
+export declare namespace PropertyDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: PropertyDefinitionResponse) => any;
+}
+export interface BatchPutPropertyValuesResponse {
+    
+    errorEntries: BatchPutPropertyErrorEntry[] | undefined;
+}
+export declare namespace BatchPutPropertyValuesResponse {
+    
+    const filterSensitiveLog: (obj: BatchPutPropertyValuesResponse) => any;
+}
+export interface CreateComponentTypeRequest {
+    
+    workspaceId: string | undefined;
+    
+    isSingleton?: boolean;
+    
+    componentTypeId: string | undefined;
+    
+    description?: string;
+    
+    propertyDefinitions?: {
+        [key: string]: PropertyDefinitionRequest;
+    };
+    
+    extendsFrom?: string[];
+    
+    functions?: {
+        [key: string]: FunctionRequest;
+    };
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateComponentTypeRequest {
+    
+    const filterSensitiveLog: (obj: CreateComponentTypeRequest) => any;
+}
+export interface GetComponentTypeResponse {
+    
+    workspaceId: string | undefined;
+    
+    isSingleton?: boolean;
+    
+    componentTypeId: string | undefined;
+    
+    description?: string;
+    
+    propertyDefinitions?: {
+        [key: string]: PropertyDefinitionResponse;
+    };
+    
+    extendsFrom?: string[];
+    
+    functions?: {
+        [key: string]: FunctionResponse;
+    };
+    
+    creationDateTime: Date | undefined;
+    
+    updateDateTime: Date | undefined;
+    
+    arn: string | undefined;
+    
+    isAbstract?: boolean;
+    
+    isSchemaInitialized?: boolean;
+    
+    status?: Status;
+}
+export declare namespace GetComponentTypeResponse {
+    
+    const filterSensitiveLog: (obj: GetComponentTypeResponse) => any;
+}
+export interface UpdateComponentTypeRequest {
+    
+    workspaceId: string | undefined;
+    
+    isSingleton?: boolean;
+    
+    componentTypeId: string | undefined;
+    
+    description?: string;
+    
+    propertyDefinitions?: {
+        [key: string]: PropertyDefinitionRequest;
+    };
+    
+    extendsFrom?: string[];
+    
+    functions?: {
+        [key: string]: FunctionRequest;
+    };
+}
+export declare namespace UpdateComponentTypeRequest {
+    
+    const filterSensitiveLog: (obj: UpdateComponentTypeRequest) => any;
+}
+
+export interface PropertyRequest {
+    
+    definition?: PropertyDefinitionRequest;
+    
+    value?: DataValue;
+    
+    updateType?: PropertyUpdateType | string;
+}
+export declare namespace PropertyRequest {
+    
+    const filterSensitiveLog: (obj: PropertyRequest) => any;
+}
+
+export interface PropertyResponse {
+    
+    definition?: PropertyDefinitionResponse;
+    
+    value?: DataValue;
+}
+export declare namespace PropertyResponse {
+    
+    const filterSensitiveLog: (obj: PropertyResponse) => any;
+}
+
+export interface ComponentRequest {
+    
+    description?: string;
+    
+    componentTypeId?: string;
+    
+    properties?: {
+        [key: string]: PropertyRequest;
+    };
+}
+export declare namespace ComponentRequest {
+    
+    const filterSensitiveLog: (obj: ComponentRequest) => any;
+}
+
+export interface ComponentResponse {
+    
+    componentName?: string;
+    
+    description?: string;
+    
+    componentTypeId?: string;
+    
+    status?: Status;
+    
+    definedIn?: string;
+    
+    properties?: {
+        [key: string]: PropertyResponse;
+    };
+}
+export declare namespace ComponentResponse {
+    
+    const filterSensitiveLog: (obj: ComponentResponse) => any;
+}
+
+export interface ComponentUpdateRequest {
+    
+    updateType?: ComponentUpdateType | string;
+    
+    description?: string;
+    
+    componentTypeId?: string;
+    
+    propertyUpdates?: {
+        [key: string]: PropertyRequest;
+    };
+}
+export declare namespace ComponentUpdateRequest {
+    
+    const filterSensitiveLog: (obj: ComponentUpdateRequest) => any;
+}
+export interface CreateEntityRequest {
+    
+    workspaceId: string | undefined;
+    
+    entityId?: string;
+    
+    entityName: string | undefined;
+    
+    description?: string;
+    
+    components?: {
+        [key: string]: ComponentRequest;
+    };
+    
+    parentEntityId?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateEntityRequest {
+    
+    const filterSensitiveLog: (obj: CreateEntityRequest) => any;
+}
+export interface GetEntityResponse {
+    
+    entityId: string | undefined;
+    
+    entityName: string | undefined;
+    
+    arn: string | undefined;
+    
+    status: Status | undefined;
+    
+    workspaceId: string | undefined;
+    
+    description?: string;
+    
+    components?: {
+        [key: string]: ComponentResponse;
+    };
+    
+    parentEntityId: string | undefined;
+    
+    hasChildEntities: boolean | undefined;
+    
+    creationDateTime: Date | undefined;
+    
+    updateDateTime: Date | undefined;
+}
+export declare namespace GetEntityResponse {
+    
+    const filterSensitiveLog: (obj: GetEntityResponse) => any;
+}
+export interface UpdateEntityRequest {
+    
+    workspaceId: string | undefined;
+    
+    entityId: string | undefined;
+    
+    entityName?: string;
+    
+    description?: string;
+    
+    componentUpdates?: {
+        [key: string]: ComponentUpdateRequest;
+    };
+    
+    parentEntityUpdate?: ParentEntityUpdateRequest;
+}
+export declare namespace UpdateEntityRequest {
+    
+    const filterSensitiveLog: (obj: UpdateEntityRequest) => any;
+}