@aws-sdk/client-iottwinmaker 3.44.0

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

@@ -0,0 +1,2269 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+/**
+ * <p>Access is denied.</p>
+ */
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace AccessDeniedException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: AccessDeniedException) => any;
+}
+/**
+ * <p>An object that uniquely identifies an entity property.</p>
+ */
+export interface EntityPropertyReference {
+    /**
+     * <p>The name of the component.</p>
+     */
+    componentName?: string;
+    /**
+     * <p>A mapping of external IDs to property names. External IDs uniquely identify properties from external data stores.</p>
+     */
+    externalIdProperty?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>The ID of the entity.</p>
+     */
+    entityId?: string;
+    /**
+     * <p>The name of the property.</p>
+     */
+    propertyName: string | undefined;
+}
+export declare namespace EntityPropertyReference {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: EntityPropertyReference) => any;
+}
+/**
+ * <p>A value that associates a component and an entity.</p>
+ */
+export interface RelationshipValue {
+    /**
+     * <p>The ID of the target entity associated with this relationship value.</p>
+     */
+    targetEntityId?: string;
+    /**
+     * <p>The name of the target component associated with the relationship value.</p>
+     */
+    targetComponentName?: string;
+}
+export declare namespace RelationshipValue {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: RelationshipValue) => any;
+}
+/**
+ * <p>An unexpected error has occurred.</p>
+ */
+export interface InternalServerException extends __SmithyException, $MetadataBearer {
+    name: "InternalServerException";
+    $fault: "server";
+    message?: string;
+}
+export declare namespace InternalServerException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: InternalServerException) => any;
+}
+/**
+ * <p>The resource wasn't found.</p>
+ */
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ResourceNotFoundException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+/**
+ * <p>The rate exceeds the limit.</p>
+ */
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ThrottlingException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ThrottlingException) => any;
+}
+/**
+ * <p>Failed</p>
+ */
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ValidationException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ValidationException) => any;
+}
+/**
+ * <p>A conflict occurred.</p>
+ */
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ConflictException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ConflictException) => any;
+}
+/**
+ * <p>The Lambda function.</p>
+ */
+export interface LambdaFunction {
+    /**
+     * <p>The ARN of the Lambda function.</p>
+     */
+    arn: string | undefined;
+}
+export declare namespace LambdaFunction {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: LambdaFunction) => any;
+}
+/**
+ * <p>The data connector.</p>
+ */
+export interface DataConnector {
+    /**
+     * <p>The Lambda function associated with this data connector.</p>
+     */
+    lambda?: LambdaFunction;
+    /**
+     * <p>A Boolean value that specifies whether the data connector is native to TwinMaker.</p>
+     */
+    isNative?: boolean;
+}
+export declare namespace DataConnector {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DataConnector) => any;
+}
+export declare enum Scope {
+    ENTITY = "ENTITY",
+    WORKSPACE = "WORKSPACE"
+}
+/**
+ * <p>The function request body.</p>
+ */
+export interface FunctionRequest {
+    /**
+     * <p>The required properties of the function.</p>
+     */
+    requiredProperties?: string[];
+    /**
+     * <p>The scope of the function.</p>
+     */
+    scope?: Scope | string;
+    /**
+     * <p>The data connector.</p>
+     */
+    implementedBy?: DataConnector;
+}
+export declare namespace FunctionRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: FunctionRequest) => any;
+}
+/**
+ * <p>An object that specifies a relationship with another component type.</p>
+ */
+export interface Relationship {
+    /**
+     * <p>The ID of the target component type associated with this relationship.</p>
+     */
+    targetComponentTypeId?: string;
+    /**
+     * <p>The type of the relationship.</p>
+     */
+    relationshipType?: string;
+}
+export declare namespace Relationship {
+    /**
+     * @internal
+     */
+    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 {
+    /**
+     * <p>The ARN of the component type.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The date and time when the entity was created.</p>
+     */
+    creationDateTime: Date | undefined;
+    /**
+     * <p>The current state of the component type.</p>
+     */
+    state: State | string | undefined;
+}
+export declare namespace CreateComponentTypeResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CreateComponentTypeResponse) => any;
+}
+/**
+ * <p>The service quota was exceeded.</p>
+ */
+export interface ServiceQuotaExceededException extends __SmithyException, $MetadataBearer {
+    name: "ServiceQuotaExceededException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ServiceQuotaExceededException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ServiceQuotaExceededException) => any;
+}
+export declare enum PropertyUpdateType {
+    DELETE = "DELETE",
+    UPDATE = "UPDATE"
+}
+export interface CreateEntityResponse {
+    /**
+     * <p>The ID of the entity.</p>
+     */
+    entityId: string | undefined;
+    /**
+     * <p>The ARN of the entity.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The date and time when the entity was created.</p>
+     */
+    creationDateTime: Date | undefined;
+    /**
+     * <p>The current state of the entity.</p>
+     */
+    state: State | string | undefined;
+}
+export declare namespace CreateEntityResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CreateEntityResponse) => any;
+}
+export interface CreateSceneRequest {
+    /**
+     * <p>The ID of the workspace that contains the scene.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ID of the scene.</p>
+     */
+    sceneId: string | undefined;
+    /**
+     * <p>The relative path that specifies the location of the content definition file.</p>
+     */
+    contentLocation: string | undefined;
+    /**
+     * <p>The description for this scene.</p>
+     */
+    description?: string;
+    /**
+     * <p>A list of capabilities that the scene uses to render itself.</p>
+     */
+    capabilities?: string[];
+    /**
+     * <p>Metadata that you can use to manage the scene.</p>
+     */
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateSceneRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CreateSceneRequest) => any;
+}
+export interface CreateSceneResponse {
+    /**
+     * <p>The ARN of the scene.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The date and time when the scene was created.</p>
+     */
+    creationDateTime: Date | undefined;
+}
+export declare namespace CreateSceneResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CreateSceneResponse) => any;
+}
+export interface CreateWorkspaceRequest {
+    /**
+     * <p>The ID of the workspace.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The description of the workspace.</p>
+     */
+    description?: string;
+    /**
+     * <p>The ARN of the S3 bucket where resources associated with the workspace are stored.</p>
+     */
+    s3Location: string | undefined;
+    /**
+     * <p>The ARN of the execution role associated with the workspace.</p>
+     */
+    role: string | undefined;
+    /**
+     * <p>Metadata that you can use to manage the workspace</p>
+     */
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateWorkspaceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CreateWorkspaceRequest) => any;
+}
+export interface CreateWorkspaceResponse {
+    /**
+     * <p>The ARN of the workspace.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The date and time when the workspace was created.</p>
+     */
+    creationDateTime: Date | undefined;
+}
+export declare namespace CreateWorkspaceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CreateWorkspaceResponse) => any;
+}
+export interface DeleteComponentTypeRequest {
+    /**
+     * <p>The ID of the workspace that contains the component type.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ID of the component type to delete.</p>
+     */
+    componentTypeId: string | undefined;
+}
+export declare namespace DeleteComponentTypeRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeleteComponentTypeRequest) => any;
+}
+export interface DeleteComponentTypeResponse {
+    /**
+     * <p>The current state of the component type to be deleted.</p>
+     */
+    state: State | string | undefined;
+}
+export declare namespace DeleteComponentTypeResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeleteComponentTypeResponse) => any;
+}
+export interface DeleteEntityRequest {
+    /**
+     * <p>The ID of the workspace that contains the entity to delete.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ID of the entity to delete.</p>
+     */
+    entityId: string | undefined;
+    /**
+     * <p>A Boolean value that specifies whether the operation deletes child entities.</p>
+     */
+    isRecursive?: boolean;
+}
+export declare namespace DeleteEntityRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeleteEntityRequest) => any;
+}
+export interface DeleteEntityResponse {
+    /**
+     * <p>The current state of the deleted entity.</p>
+     */
+    state: State | string | undefined;
+}
+export declare namespace DeleteEntityResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeleteEntityResponse) => any;
+}
+export interface DeleteSceneRequest {
+    /**
+     * <p>The ID of the workspace.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ID of the scene to delete.</p>
+     */
+    sceneId: string | undefined;
+}
+export declare namespace DeleteSceneRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeleteSceneRequest) => any;
+}
+export interface DeleteSceneResponse {
+}
+export declare namespace DeleteSceneResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeleteSceneResponse) => any;
+}
+export interface DeleteWorkspaceRequest {
+    /**
+     * <p>The ID of the workspace to delete.</p>
+     */
+    workspaceId: string | undefined;
+}
+export declare namespace DeleteWorkspaceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeleteWorkspaceRequest) => any;
+}
+export interface DeleteWorkspaceResponse {
+}
+export declare namespace DeleteWorkspaceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeleteWorkspaceResponse) => any;
+}
+export interface GetComponentTypeRequest {
+    /**
+     * <p>The ID of the workspace that contains the component type.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ID of the component type.</p>
+     */
+    componentTypeId: string | undefined;
+}
+export declare namespace GetComponentTypeRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetComponentTypeRequest) => any;
+}
+/**
+ * <p>The function response.</p>
+ */
+export interface FunctionResponse {
+    /**
+     * <p>The required properties of the function.</p>
+     */
+    requiredProperties?: string[];
+    /**
+     * <p>The scope of the function.</p>
+     */
+    scope?: Scope | string;
+    /**
+     * <p>The data connector.</p>
+     */
+    implementedBy?: DataConnector;
+    /**
+     * <p>Indicates whether this function is inherited.</p>
+     */
+    isInherited?: boolean;
+}
+export declare namespace FunctionResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: FunctionResponse) => any;
+}
+export declare enum ErrorCode {
+    INTERNAL_FAILURE = "INTERNAL_FAILURE",
+    VALIDATION_ERROR = "VALIDATION_ERROR"
+}
+/**
+ * <p>The error details.</p>
+ */
+export interface ErrorDetails {
+    /**
+     * <p>The error code.</p>
+     */
+    code?: ErrorCode | string;
+    /**
+     * <p>The error message.</p>
+     */
+    message?: string;
+}
+export declare namespace ErrorDetails {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ErrorDetails) => any;
+}
+/**
+ * <p>An object that represents the status of an entity, component, component type, or workspace.</p>
+ */
+export interface Status {
+    /**
+     * <p>The current state of the entity, component, component type, or workspace.</p>
+     */
+    state?: State | string;
+    /**
+     * <p>The error message.</p>
+     */
+    error?: ErrorDetails;
+}
+export declare namespace Status {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: Status) => any;
+}
+export interface GetEntityRequest {
+    /**
+     * <p>The ID of the workspace.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ID of the entity.</p>
+     */
+    entityId: string | undefined;
+}
+export declare namespace GetEntityRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetEntityRequest) => any;
+}
+/**
+ * <p>The connector failed.</p>
+ */
+export interface ConnectorFailureException extends __SmithyException, $MetadataBearer {
+    name: "ConnectorFailureException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ConnectorFailureException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ConnectorFailureException) => any;
+}
+/**
+ * <p>The connector timed out.</p>
+ */
+export interface ConnectorTimeoutException extends __SmithyException, $MetadataBearer {
+    name: "ConnectorTimeoutException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ConnectorTimeoutException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ConnectorTimeoutException) => any;
+}
+export interface GetPropertyValueRequest {
+    /**
+     * <p>The name of the component whose property values the operation returns.</p>
+     */
+    componentName?: string;
+    /**
+     * <p>The ID of the component type whose property values the operation returns.</p>
+     */
+    componentTypeId?: string;
+    /**
+     * <p>The ID of the entity whose property values the operation returns.</p>
+     */
+    entityId?: string;
+    /**
+     * <p>The properties whose values the operation returns.</p>
+     */
+    selectedProperties: string[] | undefined;
+    /**
+     * <p>The ID of the workspace whose values the operation returns.</p>
+     */
+    workspaceId: string | undefined;
+}
+export declare namespace GetPropertyValueRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetPropertyValueRequest) => any;
+}
+export declare enum InterpolationType {
+    LINEAR = "LINEAR"
+}
+/**
+ * <p>An object that specifies how to interpolate data in a list.</p>
+ */
+export interface InterpolationParameters {
+    /**
+     * <p>The interpolation type.</p>
+     */
+    interpolationType?: InterpolationType | string;
+    /**
+     * <p>The interpolation time interval in seconds.</p>
+     */
+    intervalInSeconds?: number;
+}
+export declare namespace InterpolationParameters {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: InterpolationParameters) => any;
+}
+export declare enum OrderByTime {
+    ASCENDING = "ASCENDING",
+    DESCENDING = "DESCENDING"
+}
+export interface GetSceneRequest {
+    /**
+     * <p>The ID of the workspace that contains the scene.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ID of the scene.</p>
+     */
+    sceneId: string | undefined;
+}
+export declare namespace GetSceneRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetSceneRequest) => any;
+}
+export interface GetSceneResponse {
+    /**
+     * <p>The ID of the workspace that contains the scene.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ID of the scene.</p>
+     */
+    sceneId: string | undefined;
+    /**
+     * <p>The relative path that specifies the location of the content definition file.</p>
+     */
+    contentLocation: string | undefined;
+    /**
+     * <p>The ARN of the scene.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The date and time when the scene was created.</p>
+     */
+    creationDateTime: Date | undefined;
+    /**
+     * <p>The date and time when the scene was last updated.</p>
+     */
+    updateDateTime: Date | undefined;
+    /**
+     * <p>The description of the scene.</p>
+     */
+    description?: string;
+    /**
+     * <p>A list of capabilities that the scene uses to render.</p>
+     */
+    capabilities?: string[];
+}
+export declare namespace GetSceneResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetSceneResponse) => any;
+}
+export interface GetWorkspaceRequest {
+    /**
+     * <p>The ID of the workspace.</p>
+     */
+    workspaceId: string | undefined;
+}
+export declare namespace GetWorkspaceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetWorkspaceRequest) => any;
+}
+export interface GetWorkspaceResponse {
+    /**
+     * <p>The ID of the workspace.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ARN of the workspace.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The description of the workspace.</p>
+     */
+    description?: string;
+    /**
+     * <p>The ARN of the S3 bucket where resources associated with the workspace are stored.</p>
+     */
+    s3Location: string | undefined;
+    /**
+     * <p>The ARN of the execution role associated with the workspace.</p>
+     */
+    role: string | undefined;
+    /**
+     * <p>The date and time when the workspace was created.</p>
+     */
+    creationDateTime: Date | undefined;
+    /**
+     * <p>The date and time when the workspace was last updated.</p>
+     */
+    updateDateTime: Date | undefined;
+}
+export declare namespace GetWorkspaceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetWorkspaceResponse) => any;
+}
+/**
+ * <p>An object that filters items in a list of component types.</p>
+ */
+export declare type ListComponentTypesFilter = ListComponentTypesFilter.ExtendsFromMember | ListComponentTypesFilter.IsAbstractMember | ListComponentTypesFilter.NamespaceMember | ListComponentTypesFilter.$UnknownMember;
+export declare namespace ListComponentTypesFilter {
+    /**
+     * <p>The component type that the component types in the list extend.</p>
+     */
+    interface ExtendsFromMember {
+        extendsFrom: string;
+        namespace?: never;
+        isAbstract?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>The namespace to which the component types in the list belong.</p>
+     */
+    interface NamespaceMember {
+        extendsFrom?: never;
+        namespace: string;
+        isAbstract?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>A Boolean value that specifies whether the component types in the list are abstract.</p>
+     */
+    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;
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListComponentTypesFilter) => any;
+}
+export interface ListComponentTypesRequest {
+    /**
+     * <p>The ID of the workspace.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>A list of objects that filter the request.</p>
+     */
+    filters?: ListComponentTypesFilter[];
+    /**
+     * <p>The string that specifies the next page of results.</p>
+     */
+    nextToken?: string;
+    /**
+     * <p>The maximum number of results to display.</p>
+     */
+    maxResults?: number;
+}
+export declare namespace ListComponentTypesRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListComponentTypesRequest) => any;
+}
+/**
+ * <p>An object that contains information about a component type.</p>
+ */
+export interface ComponentTypeSummary {
+    /**
+     * <p>The ARN of the component type.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The ID of the component type.</p>
+     */
+    componentTypeId: string | undefined;
+    /**
+     * <p>The date and time when the component type was created.</p>
+     */
+    creationDateTime: Date | undefined;
+    /**
+     * <p>The date and time when the component type was last updated.</p>
+     */
+    updateDateTime: Date | undefined;
+    /**
+     * <p>The description of the component type.</p>
+     */
+    description?: string;
+    /**
+     * <p>The current status of the component type.</p>
+     */
+    status?: Status;
+}
+export declare namespace ComponentTypeSummary {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ComponentTypeSummary) => any;
+}
+export interface ListComponentTypesResponse {
+    /**
+     * <p>The ID of the workspace.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>A list of objects that contain information about the component types.</p>
+     */
+    componentTypeSummaries: ComponentTypeSummary[] | undefined;
+    /**
+     * <p>The string that specifies the next page of results.</p>
+     */
+    nextToken?: string;
+    /**
+     * <p>Specifies the maximum number of results to display.</p>
+     */
+    maxResults?: number;
+}
+export declare namespace ListComponentTypesResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListComponentTypesResponse) => any;
+}
+/**
+ * <p>An object that filters items in a list of entities.</p>
+ */
+export declare type ListEntitiesFilter = ListEntitiesFilter.ComponentTypeIdMember | ListEntitiesFilter.ParentEntityIdMember | ListEntitiesFilter.$UnknownMember;
+export declare namespace ListEntitiesFilter {
+    /**
+     * <p>The parent of the entities in the list.</p>
+     */
+    interface ParentEntityIdMember {
+        parentEntityId: string;
+        componentTypeId?: never;
+        $unknown?: never;
+    }
+    /**
+     * <p>The ID of the component type in the entities in the list.</p>
+     */
+    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;
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListEntitiesFilter) => any;
+}
+export interface ListEntitiesRequest {
+    /**
+     * <p>The ID of the workspace.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>A list of objects that filter the request.</p>
+     */
+    filters?: ListEntitiesFilter[];
+    /**
+     * <p>The maximum number of results to display.</p>
+     */
+    maxResults?: number;
+    /**
+     * <p>The string that specifies the next page of results.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace ListEntitiesRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListEntitiesRequest) => any;
+}
+/**
+ * <p>An object that contains information about an entity.</p>
+ */
+export interface EntitySummary {
+    /**
+     * <p>The ID of the entity.</p>
+     */
+    entityId: string | undefined;
+    /**
+     * <p>The name of the entity.</p>
+     */
+    entityName: string | undefined;
+    /**
+     * <p>The ARN of the entity.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The ID of the parent entity.</p>
+     */
+    parentEntityId?: string;
+    /**
+     * <p>The current status of the entity.</p>
+     */
+    status: Status | undefined;
+    /**
+     * <p>The description of the entity.</p>
+     */
+    description?: string;
+    /**
+     * <p>A Boolean value that specifies whether the entity has child entities or not.</p>
+     */
+    hasChildEntities?: boolean;
+    /**
+     * <p>The date and time when the entity was created.</p>
+     */
+    creationDateTime: Date | undefined;
+    /**
+     * <p>The last date and time when the entity was updated.</p>
+     */
+    updateDateTime: Date | undefined;
+}
+export declare namespace EntitySummary {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: EntitySummary) => any;
+}
+export interface ListEntitiesResponse {
+    /**
+     * <p>A list of objects that contain information about the entities.</p>
+     */
+    entitySummaries?: EntitySummary[];
+    /**
+     * <p>The string that specifies the next page of results.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace ListEntitiesResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListEntitiesResponse) => any;
+}
+export interface ListScenesRequest {
+    /**
+     * <p>The ID of the workspace that contains the scenes.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>Specifies the maximum number of results to display.</p>
+     */
+    maxResults?: number;
+    /**
+     * <p>The string that specifies the next page of results.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace ListScenesRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListScenesRequest) => any;
+}
+/**
+ * <p>An object that contains information about a scene.</p>
+ */
+export interface SceneSummary {
+    /**
+     * <p>The ID of the scene.</p>
+     */
+    sceneId: string | undefined;
+    /**
+     * <p>The relative path that specifies the location of the content definition file.</p>
+     */
+    contentLocation: string | undefined;
+    /**
+     * <p>The ARN of the scene.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The date and time when the scene was created.</p>
+     */
+    creationDateTime: Date | undefined;
+    /**
+     * <p>The date and time when the scene was last updated.</p>
+     */
+    updateDateTime: Date | undefined;
+    /**
+     * <p>The scene description.</p>
+     */
+    description?: string;
+}
+export declare namespace SceneSummary {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: SceneSummary) => any;
+}
+export interface ListScenesResponse {
+    /**
+     * <p>A list of objects that contain information about the scenes.</p>
+     */
+    sceneSummaries?: SceneSummary[];
+    /**
+     * <p>The string that specifies the next page of results.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace ListScenesResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListScenesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    /**
+     * <p>The ARN of the resource.</p>
+     */
+    resourceARN: string | undefined;
+    /**
+     * <p>The maximum number of results to display.</p>
+     */
+    maxResults?: number;
+    /**
+     * <p>The string that specifies the next page of results.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace ListTagsForResourceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    /**
+     * <p>Metadata that you can use to manage a resource.</p>
+     */
+    tags?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>The string that specifies the next page of results.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace ListTagsForResourceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ListWorkspacesRequest {
+    /**
+     * <p>The maximum number of results to display.</p>
+     */
+    maxResults?: number;
+    /**
+     * <p>The string that specifies the next page of results.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace ListWorkspacesRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListWorkspacesRequest) => any;
+}
+/**
+ * <p>An object that contains information about a workspace.</p>
+ */
+export interface WorkspaceSummary {
+    /**
+     * <p>The ID of the workspace.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ARN of the workspace.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The description of the workspace.</p>
+     */
+    description?: string;
+    /**
+     * <p>The date and time when the workspace was created.</p>
+     */
+    creationDateTime: Date | undefined;
+    /**
+     * <p>The date and time when the workspace was last updated.</p>
+     */
+    updateDateTime: Date | undefined;
+}
+export declare namespace WorkspaceSummary {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: WorkspaceSummary) => any;
+}
+export interface ListWorkspacesResponse {
+    /**
+     * <p>A list of objects that contain information about the workspaces.</p>
+     */
+    workspaceSummaries?: WorkspaceSummary[];
+    /**
+     * <p>The string that specifies the next page of results.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace ListWorkspacesResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListWorkspacesResponse) => any;
+}
+export interface TagResourceRequest {
+    /**
+     * <p>The ARN of the resource.</p>
+     */
+    resourceARN: string | undefined;
+    /**
+     * <p>Metadata to add to this resource.</p>
+     */
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+/**
+ * <p>The number of tags exceeds the limit.</p>
+ */
+export interface TooManyTagsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyTagsException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace TooManyTagsException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TooManyTagsException) => any;
+}
+export interface UntagResourceRequest {
+    /**
+     * <p>The ARN of the resource.</p>
+     */
+    resourceARN: string | undefined;
+    /**
+     * <p>A list of tag key names to remove from the resource. You don't specify the value. Both the key and its associated value are removed.</p>
+     */
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateComponentTypeResponse {
+    /**
+     * <p>The ID of the workspace that contains the component type.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ARN of the component type.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The ID of the component type.</p>
+     */
+    componentTypeId: string | undefined;
+    /**
+     * <p>The current state of the component type.</p>
+     */
+    state: State | string | undefined;
+}
+export declare namespace UpdateComponentTypeResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateComponentTypeResponse) => any;
+}
+export declare enum ComponentUpdateType {
+    CREATE = "CREATE",
+    DELETE = "DELETE",
+    UPDATE = "UPDATE"
+}
+export declare enum ParentEntityUpdateType {
+    DELETE = "DELETE",
+    UPDATE = "UPDATE"
+}
+/**
+ * <p>The parent entity update request.</p>
+ */
+export interface ParentEntityUpdateRequest {
+    /**
+     * <p>The type of the update.</p>
+     */
+    updateType: ParentEntityUpdateType | string | undefined;
+    /**
+     * <p>The ID of the parent entity.</p>
+     */
+    parentEntityId?: string;
+}
+export declare namespace ParentEntityUpdateRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ParentEntityUpdateRequest) => any;
+}
+export interface UpdateEntityResponse {
+    /**
+     * <p>The date and time when the entity was last updated.</p>
+     */
+    updateDateTime: Date | undefined;
+    /**
+     * <p>The current state of the entity update.</p>
+     */
+    state: State | string | undefined;
+}
+export declare namespace UpdateEntityResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateEntityResponse) => any;
+}
+export interface UpdateSceneRequest {
+    /**
+     * <p>The ID of the workspace that contains the scene.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ID of the scene.</p>
+     */
+    sceneId: string | undefined;
+    /**
+     * <p>The relative path that specifies the location of the content definition file.</p>
+     */
+    contentLocation?: string;
+    /**
+     * <p>The description of this scene.</p>
+     */
+    description?: string;
+    /**
+     * <p>A list of capabilities that the scene uses to render.</p>
+     */
+    capabilities?: string[];
+}
+export declare namespace UpdateSceneRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateSceneRequest) => any;
+}
+export interface UpdateSceneResponse {
+    /**
+     * <p>The date and time when the scene was last updated.</p>
+     */
+    updateDateTime: Date | undefined;
+}
+export declare namespace UpdateSceneResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateSceneResponse) => any;
+}
+export interface UpdateWorkspaceRequest {
+    /**
+     * <p>The ID of the workspace.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The description of the workspace.</p>
+     */
+    description?: string;
+    /**
+     * <p>The ARN of the execution role associated with the workspace.</p>
+     */
+    role?: string;
+}
+export declare namespace UpdateWorkspaceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateWorkspaceRequest) => any;
+}
+export interface UpdateWorkspaceResponse {
+    /**
+     * <p>The date and time of the current update.</p>
+     */
+    updateDateTime: Date | undefined;
+}
+export declare namespace UpdateWorkspaceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateWorkspaceResponse) => any;
+}
+/**
+ * <p>An object that specifies a value for a property.</p>
+ */
+export interface DataValue {
+    /**
+     * <p>A Boolean value.</p>
+     */
+    booleanValue?: boolean;
+    /**
+     * <p>A double value.</p>
+     */
+    doubleValue?: number;
+    /**
+     * <p>An integer value.</p>
+     */
+    integerValue?: number;
+    /**
+     * <p>A long value.</p>
+     */
+    longValue?: number;
+    /**
+     * <p>A string value.</p>
+     */
+    stringValue?: string;
+    /**
+     * <p>A list of multiple values.</p>
+     */
+    listValue?: DataValue[];
+    /**
+     * <p>An object that maps strings to multiple <code>DataValue</code> objects.</p>
+     */
+    mapValue?: {
+        [key: string]: DataValue;
+    };
+    /**
+     * <p>A value that relates a component to another component.</p>
+     */
+    relationshipValue?: RelationshipValue;
+    /**
+     * <p>An expression that produces the value.</p>
+     */
+    expression?: string;
+}
+export declare namespace DataValue {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DataValue) => any;
+}
+/**
+ * <p>An object that filters items returned by a property request.</p>
+ */
+export interface PropertyFilter {
+    /**
+     * <p>The property name associated with this property filter.</p>
+     */
+    propertyName?: string;
+    /**
+     * <p>The operator associated with this property filter.</p>
+     */
+    operator?: string;
+    /**
+     * <p>The value associated with this property filter.</p>
+     */
+    value?: DataValue;
+}
+export declare namespace PropertyFilter {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: PropertyFilter) => any;
+}
+/**
+ * <p>The latest value of the property.</p>
+ */
+export interface PropertyLatestValue {
+    /**
+     * <p>An object that specifies information about a property.&gt;</p>
+     */
+    propertyReference: EntityPropertyReference | undefined;
+    /**
+     * <p>The value of the property.</p>
+     */
+    propertyValue?: DataValue;
+}
+export declare namespace PropertyLatestValue {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: PropertyLatestValue) => any;
+}
+/**
+ * <p>An object that contains information about a value for a time series property.</p>
+ */
+export interface PropertyValue {
+    /**
+     * <p>The timestamp of a value for a time series property.</p>
+     */
+    timestamp: Date | undefined;
+    /**
+     * <p>An object that specifies a value for a time series property.</p>
+     */
+    value: DataValue | undefined;
+}
+export declare namespace PropertyValue {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: PropertyValue) => any;
+}
+/**
+ * <p>An object that specifies the data type of a property.</p>
+ */
+export interface DataType {
+    /**
+     * <p>The underlying type of the data type.</p>
+     */
+    type: Type | string | undefined;
+    /**
+     * <p>The nested type in the data type.</p>
+     */
+    nestedType?: DataType;
+    /**
+     * <p>The allowed values for this data type.</p>
+     */
+    allowedValues?: DataValue[];
+    /**
+     * <p>The unit of measure used in this data type.</p>
+     */
+    unitOfMeasure?: string;
+    /**
+     * <p>A relationship that associates a component with another component.</p>
+     */
+    relationship?: Relationship;
+}
+export declare namespace DataType {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DataType) => any;
+}
+export interface GetPropertyValueHistoryRequest {
+    /**
+     * <p>The ID of the workspace.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ID of the entity.</p>
+     */
+    entityId?: string;
+    /**
+     * <p>The name of the component.</p>
+     */
+    componentName?: string;
+    /**
+     * <p>The ID of the component type.</p>
+     */
+    componentTypeId?: string;
+    /**
+     * <p>A list of properties whose value histories the request retrieves.</p>
+     */
+    selectedProperties: string[] | undefined;
+    /**
+     * <p>A list of objects that filter the property value history request.</p>
+     */
+    propertyFilters?: PropertyFilter[];
+    /**
+     * <p>The date and time of the earliest property value to return.</p>
+     */
+    startDateTime: Date | undefined;
+    /**
+     * <p>The date and time of the latest property value to return.</p>
+     */
+    endDateTime: Date | undefined;
+    /**
+     * <p>An object that specifies the interpolation type and the interval over which to interpolate data.</p>
+     */
+    interpolation?: InterpolationParameters;
+    /**
+     * <p>The string that specifies the next page of results.</p>
+     */
+    nextToken?: string;
+    /**
+     * <p>The maximum number of results to return.</p>
+     */
+    maxResults?: number;
+    /**
+     * <p>The time direction to use in the result order.</p>
+     */
+    orderByTime?: OrderByTime | string;
+}
+export declare namespace GetPropertyValueHistoryRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetPropertyValueHistoryRequest) => any;
+}
+export interface GetPropertyValueResponse {
+    /**
+     * <p>An object that maps strings to the properties and latest property values in the response. Each string
+     *        in the mapping must be unique to this object.</p>
+     */
+    propertyValues: {
+        [key: string]: PropertyLatestValue;
+    } | undefined;
+}
+export declare namespace GetPropertyValueResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetPropertyValueResponse) => any;
+}
+/**
+ * <p>An object that specifies information about time series property values.</p>
+ */
+export interface PropertyValueEntry {
+    /**
+     * <p>An object that contains information about the entity that has the property.</p>
+     */
+    entityPropertyReference: EntityPropertyReference | undefined;
+    /**
+     * <p>A list of objects that specify time series property values.</p>
+     */
+    propertyValues?: PropertyValue[];
+}
+export declare namespace PropertyValueEntry {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: PropertyValueEntry) => any;
+}
+/**
+ * <p>The history of values for a time series property.</p>
+ */
+export interface PropertyValueHistory {
+    /**
+     * <p>An object that uniquely identifies an entity property.</p>
+     */
+    entityPropertyReference: EntityPropertyReference | undefined;
+    /**
+     * <p>A list of objects that contain information about the values in the history of a time series property.</p>
+     */
+    values?: PropertyValue[];
+}
+export declare namespace PropertyValueHistory {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: PropertyValueHistory) => any;
+}
+/**
+ * <p>An error returned by the <code>BatchPutProperty</code> action.</p>
+ */
+export interface BatchPutPropertyError {
+    /**
+     * <p>The error code.</p>
+     */
+    errorCode: string | undefined;
+    /**
+     * <p>The error message.</p>
+     */
+    errorMessage: string | undefined;
+    /**
+     * <p>An object that contains information about errors returned by the <code>BatchPutProperty</code> action.</p>
+     */
+    entry: PropertyValueEntry | undefined;
+}
+export declare namespace BatchPutPropertyError {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: BatchPutPropertyError) => any;
+}
+export interface BatchPutPropertyValuesRequest {
+    /**
+     * <p>The ID of the workspace that contains the properties to set.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>An object that maps strings to the property value entries to set. Each string
+     *        in the mapping must be unique to this object.</p>
+     */
+    entries: PropertyValueEntry[] | undefined;
+}
+export declare namespace BatchPutPropertyValuesRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: BatchPutPropertyValuesRequest) => any;
+}
+export interface GetPropertyValueHistoryResponse {
+    /**
+     * <p>An object that maps strings to the property definitions in the component type. Each string
+     *        in the mapping must be unique to this object.</p>
+     */
+    propertyValues: PropertyValueHistory[] | undefined;
+    /**
+     * <p>The string that specifies the next page of results.</p>
+     */
+    nextToken?: string;
+}
+export declare namespace GetPropertyValueHistoryResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetPropertyValueHistoryResponse) => any;
+}
+/**
+ * <p>An object that contains information about errors returned by the <code>BatchPutProperty</code> action.</p>
+ */
+export interface BatchPutPropertyErrorEntry {
+    /**
+     * <p>A list of objects that contain information about errors returned by the
+     *             <code>BatchPutProperty</code> action.</p>
+     */
+    errors: BatchPutPropertyError[] | undefined;
+}
+export declare namespace BatchPutPropertyErrorEntry {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: BatchPutPropertyErrorEntry) => any;
+}
+/**
+ * <p>An object that sets information about a property.</p>
+ */
+export interface PropertyDefinitionRequest {
+    /**
+     * <p>An object that contains information about the data type.</p>
+     */
+    dataType?: DataType;
+    /**
+     * <p>A Boolean value that specifies whether the property is required.</p>
+     */
+    isRequiredInEntity?: boolean;
+    /**
+     * <p>A Boolean value that specifies whether the property ID comes from an external data store.</p>
+     */
+    isExternalId?: boolean;
+    /**
+     * <p>A Boolean value that specifies whether the property is stored externally.</p>
+     */
+    isStoredExternally?: boolean;
+    /**
+     * <p>A Boolean value that specifies whether the property consists of time series data.</p>
+     */
+    isTimeSeries?: boolean;
+    /**
+     * <p>An object that contains the default value.</p>
+     */
+    defaultValue?: DataValue;
+    /**
+     * <p>A mapping that specifies configuration information about the property. Use this field to
+     *          specify information that you read from and write to an external source.</p>
+     */
+    configuration?: {
+        [key: string]: string;
+    };
+}
+export declare namespace PropertyDefinitionRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: PropertyDefinitionRequest) => any;
+}
+/**
+ * <p>An object that contains response data from a property definition request.</p>
+ */
+export interface PropertyDefinitionResponse {
+    /**
+     * <p>An object that contains information about the data type.</p>
+     */
+    dataType: DataType | undefined;
+    /**
+     * <p>A Boolean value that specifies whether the property consists of time series data.</p>
+     */
+    isTimeSeries: boolean | undefined;
+    /**
+     * <p>A Boolean value that specifies whether the property is required in an entity.</p>
+     */
+    isRequiredInEntity: boolean | undefined;
+    /**
+     * <p>A Boolean value that specifies whether the property ID comes from an external data store.</p>
+     */
+    isExternalId: boolean | undefined;
+    /**
+     * <p>A Boolean value that specifies whether the property is stored externally.</p>
+     */
+    isStoredExternally: boolean | undefined;
+    /**
+     * <p>A Boolean value that specifies whether the property definition is imported from an external data store.</p>
+     */
+    isImported: boolean | undefined;
+    /**
+     * <p>A Boolean value that specifies whether the property definition can be updated.</p>
+     */
+    isFinal: boolean | undefined;
+    /**
+     * <p>A Boolean value that specifies whether the property definition is inherited from a parent entity.</p>
+     */
+    isInherited: boolean | undefined;
+    /**
+     * <p>An object that contains the default value.</p>
+     */
+    defaultValue?: DataValue;
+    /**
+     * <p>A mapping that specifies configuration information about the property.</p>
+     */
+    configuration?: {
+        [key: string]: string;
+    };
+}
+export declare namespace PropertyDefinitionResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: PropertyDefinitionResponse) => any;
+}
+export interface BatchPutPropertyValuesResponse {
+    /**
+     * <p>Entries that caused errors in the batch put operation.</p>
+     */
+    errorEntries: BatchPutPropertyErrorEntry[] | undefined;
+}
+export declare namespace BatchPutPropertyValuesResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: BatchPutPropertyValuesResponse) => any;
+}
+export interface CreateComponentTypeRequest {
+    /**
+     * <p>The ID of the workspace that contains the component type.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>A Boolean value that specifies whether an entity can have more than one component of
+     *          this type.</p>
+     */
+    isSingleton?: boolean;
+    /**
+     * <p>The ID of the component type.</p>
+     */
+    componentTypeId: string | undefined;
+    /**
+     * <p>The description of the component type.</p>
+     */
+    description?: string;
+    /**
+     * <p>An object that maps strings to the property definitions in the component type. Each string
+     *       in the mapping must be unique to this object.</p>
+     */
+    propertyDefinitions?: {
+        [key: string]: PropertyDefinitionRequest;
+    };
+    /**
+     * <p>Specifies the parent component type to extend.</p>
+     */
+    extendsFrom?: string[];
+    /**
+     * <p>An object that maps strings to the functions in the component type. Each string in the
+     *          mapping must be unique to this object.</p>
+     */
+    functions?: {
+        [key: string]: FunctionRequest;
+    };
+    /**
+     * <p>Metadata that you can use to manage the component type.</p>
+     */
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateComponentTypeRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CreateComponentTypeRequest) => any;
+}
+export interface GetComponentTypeResponse {
+    /**
+     * <p>The ID of the workspace that contains the component type.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>A Boolean value that specifies whether an entity can have more than one component of this
+     *          type.</p>
+     */
+    isSingleton?: boolean;
+    /**
+     * <p>The ID of the component type.</p>
+     */
+    componentTypeId: string | undefined;
+    /**
+     * <p>The description of the component type.</p>
+     */
+    description?: string;
+    /**
+     * <p>An object that maps strings to the property definitions in the component type. Each string
+     *        in the mapping must be unique to this object.</p>
+     */
+    propertyDefinitions?: {
+        [key: string]: PropertyDefinitionResponse;
+    };
+    /**
+     * <p>The name of the parent component type that this component type extends.</p>
+     */
+    extendsFrom?: string[];
+    /**
+     * <p>An object that maps strings to the functions in the component type. Each string
+     *        in the mapping must be unique to this object.</p>
+     */
+    functions?: {
+        [key: string]: FunctionResponse;
+    };
+    /**
+     * <p>The date and time when the component type was created.</p>
+     */
+    creationDateTime: Date | undefined;
+    /**
+     * <p>The date and time when the component was last updated.</p>
+     */
+    updateDateTime: Date | undefined;
+    /**
+     * <p>The ARN of the component type.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>A Boolean value that specifies whether the component type is abstract.</p>
+     */
+    isAbstract?: boolean;
+    /**
+     * <p>A Boolean value that specifies whether the component type has a schema initializer and that the
+     *       schema initializer has run.</p>
+     */
+    isSchemaInitialized?: boolean;
+    /**
+     * <p>The current status of the component type.</p>
+     */
+    status?: Status;
+}
+export declare namespace GetComponentTypeResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetComponentTypeResponse) => any;
+}
+export interface UpdateComponentTypeRequest {
+    /**
+     * <p>The ID of the workspace that contains the component type.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>A Boolean value that specifies whether an entity can have more than one component of this
+     *          type.</p>
+     */
+    isSingleton?: boolean;
+    /**
+     * <p>The ID of the component type.</p>
+     */
+    componentTypeId: string | undefined;
+    /**
+     * <p>The description of the component type.</p>
+     */
+    description?: string;
+    /**
+     * <p>An object that maps strings to the property definitions in the component type. Each string
+     *        in the mapping must be unique to this object.</p>
+     */
+    propertyDefinitions?: {
+        [key: string]: PropertyDefinitionRequest;
+    };
+    /**
+     * <p>Specifies the component type that this component type extends.</p>
+     */
+    extendsFrom?: string[];
+    /**
+     * <p>An object that maps strings to the functions in the component type. Each string
+     *        in the mapping must be unique to this object.</p>
+     */
+    functions?: {
+        [key: string]: FunctionRequest;
+    };
+}
+export declare namespace UpdateComponentTypeRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateComponentTypeRequest) => any;
+}
+/**
+ * <p>An object that sets information about a property.</p>
+ */
+export interface PropertyRequest {
+    /**
+     * <p>An object that specifies information about a property.</p>
+     */
+    definition?: PropertyDefinitionRequest;
+    /**
+     * <p>The value of the property.</p>
+     */
+    value?: DataValue;
+    /**
+     * <p>The update type of the update property request.</p>
+     */
+    updateType?: PropertyUpdateType | string;
+}
+export declare namespace PropertyRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: PropertyRequest) => any;
+}
+/**
+ * <p>An object that contains information about a property response.</p>
+ */
+export interface PropertyResponse {
+    /**
+     * <p>An object that specifies information about a property.</p>
+     */
+    definition?: PropertyDefinitionResponse;
+    /**
+     * <p>The value of the property.</p>
+     */
+    value?: DataValue;
+}
+export declare namespace PropertyResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: PropertyResponse) => any;
+}
+/**
+ * <p>An object that sets information about a component type create or update request.</p>
+ */
+export interface ComponentRequest {
+    /**
+     * <p>The description of the component request.</p>
+     */
+    description?: string;
+    /**
+     * <p>The ID of the component type.</p>
+     */
+    componentTypeId?: string;
+    /**
+     * <p>An object that maps strings to the properties to set in the component type. Each string
+     *        in the mapping must be unique to this object.</p>
+     */
+    properties?: {
+        [key: string]: PropertyRequest;
+    };
+}
+export declare namespace ComponentRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ComponentRequest) => any;
+}
+/**
+ * <p>An object that returns information about a component type create or update request.</p>
+ */
+export interface ComponentResponse {
+    /**
+     * <p>The name of the component.</p>
+     */
+    componentName?: string;
+    /**
+     * <p>The description of the component type.</p>
+     */
+    description?: string;
+    /**
+     * <p>The ID of the component type.</p>
+     */
+    componentTypeId?: string;
+    /**
+     * <p>The status of the component type.</p>
+     */
+    status?: Status;
+    /**
+     * <p>The name of the property definition set in the request.</p>
+     */
+    definedIn?: string;
+    /**
+     * <p>An object that maps strings to the properties to set in the component type. Each string
+     *        in the mapping must be unique to this object.</p>
+     */
+    properties?: {
+        [key: string]: PropertyResponse;
+    };
+}
+export declare namespace ComponentResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ComponentResponse) => any;
+}
+/**
+ * <p>The component update request.</p>
+ */
+export interface ComponentUpdateRequest {
+    /**
+     * <p>The update type of the component update request.</p>
+     */
+    updateType?: ComponentUpdateType | string;
+    /**
+     * <p>The description of the component type.</p>
+     */
+    description?: string;
+    /**
+     * <p>The ID of the component type.</p>
+     */
+    componentTypeId?: string;
+    /**
+     * <p>An object that maps strings to the properties to set in the component type update. Each string
+     *        in the mapping must be unique to this object.</p>
+     */
+    propertyUpdates?: {
+        [key: string]: PropertyRequest;
+    };
+}
+export declare namespace ComponentUpdateRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ComponentUpdateRequest) => any;
+}
+export interface CreateEntityRequest {
+    /**
+     * <p>The ID of the workspace that contains the entity.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ID of the entity.</p>
+     */
+    entityId?: string;
+    /**
+     * <p>The name of the entity.</p>
+     */
+    entityName: string | undefined;
+    /**
+     * <p>The description of the entity.</p>
+     */
+    description?: string;
+    /**
+     * <p>An object that maps strings to the components in the entity. Each string
+     *        in the mapping must be unique to this object.</p>
+     */
+    components?: {
+        [key: string]: ComponentRequest;
+    };
+    /**
+     * <p>The ID of the entity's parent entity.</p>
+     */
+    parentEntityId?: string;
+    /**
+     * <p>Metadata that you can use to manage the entity.</p>
+     */
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateEntityRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CreateEntityRequest) => any;
+}
+export interface GetEntityResponse {
+    /**
+     * <p>The ID of the entity.</p>
+     */
+    entityId: string | undefined;
+    /**
+     * <p>The name of the entity.</p>
+     */
+    entityName: string | undefined;
+    /**
+     * <p>The ARN of the entity.</p>
+     */
+    arn: string | undefined;
+    /**
+     * <p>The current status of the entity.</p>
+     */
+    status: Status | undefined;
+    /**
+     * <p>The ID of the workspace.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The description of the entity.</p>
+     */
+    description?: string;
+    /**
+     * <p>An object that maps strings to the components in the entity. Each string
+     *        in the mapping must be unique to this object.</p>
+     */
+    components?: {
+        [key: string]: ComponentResponse;
+    };
+    /**
+     * <p>The ID of the parent entity for this entity.</p>
+     */
+    parentEntityId: string | undefined;
+    /**
+     * <p>A Boolean value that specifies whether the entity has associated child entities.</p>
+     */
+    hasChildEntities: boolean | undefined;
+    /**
+     * <p>The date and time when the entity was created.</p>
+     */
+    creationDateTime: Date | undefined;
+    /**
+     * <p>The date and time when the entity was last updated.</p>
+     */
+    updateDateTime: Date | undefined;
+}
+export declare namespace GetEntityResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetEntityResponse) => any;
+}
+export interface UpdateEntityRequest {
+    /**
+     * <p>The ID of the workspace that contains the entity.</p>
+     */
+    workspaceId: string | undefined;
+    /**
+     * <p>The ID of the entity.</p>
+     */
+    entityId: string | undefined;
+    /**
+     * <p>The name of the entity.</p>
+     */
+    entityName?: string;
+    /**
+     * <p>The description of the entity.</p>
+     */
+    description?: string;
+    /**
+     * <p>An object that maps strings to the component updates in the request. Each string
+     *        in the mapping must be unique to this object.</p>
+     */
+    componentUpdates?: {
+        [key: string]: ComponentUpdateRequest;
+    };
+    /**
+     * <p>An object that describes the update request for a parent entity.</p>
+     */
+    parentEntityUpdate?: ParentEntityUpdateRequest;
+}
+export declare namespace UpdateEntityRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateEntityRequest) => any;
+}