@aws-sdk/client-iotthingsgraph 3.50.0 → 3.51.0

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

@@ -0,0 +1,1065 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export interface AssociateEntityToThingRequest {
+    
+    thingName: string | undefined;
+    
+    entityId: string | undefined;
+    
+    namespaceVersion?: number;
+}
+export declare namespace AssociateEntityToThingRequest {
+    
+    const filterSensitiveLog: (obj: AssociateEntityToThingRequest) => any;
+}
+export interface AssociateEntityToThingResponse {
+}
+export declare namespace AssociateEntityToThingResponse {
+    
+    const filterSensitiveLog: (obj: AssociateEntityToThingResponse) => any;
+}
+
+export interface InternalFailureException extends __SmithyException, $MetadataBearer {
+    name: "InternalFailureException";
+    $fault: "server";
+    message?: string;
+}
+
+export interface InvalidRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRequestException";
+    $fault: "client";
+    message?: string;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+    message?: string;
+}
+export declare enum DefinitionLanguage {
+    GRAPHQL = "GRAPHQL"
+}
+
+export interface DefinitionDocument {
+    
+    language: DefinitionLanguage | string | undefined;
+    
+    text: string | undefined;
+}
+export declare namespace DefinitionDocument {
+    
+    const filterSensitiveLog: (obj: DefinitionDocument) => any;
+}
+export interface CreateFlowTemplateRequest {
+    
+    definition: DefinitionDocument | undefined;
+    
+    compatibleNamespaceVersion?: number;
+}
+export declare namespace CreateFlowTemplateRequest {
+    
+    const filterSensitiveLog: (obj: CreateFlowTemplateRequest) => any;
+}
+
+export interface FlowTemplateSummary {
+    
+    id?: string;
+    
+    arn?: string;
+    
+    revisionNumber?: number;
+    
+    createdAt?: Date;
+}
+export declare namespace FlowTemplateSummary {
+    
+    const filterSensitiveLog: (obj: FlowTemplateSummary) => any;
+}
+export interface CreateFlowTemplateResponse {
+    
+    summary?: FlowTemplateSummary;
+}
+export declare namespace CreateFlowTemplateResponse {
+    
+    const filterSensitiveLog: (obj: CreateFlowTemplateResponse) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    message?: string;
+}
+
+export interface ResourceAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "ResourceAlreadyExistsException";
+    $fault: "client";
+    message?: string;
+}
+
+export interface MetricsConfiguration {
+    
+    cloudMetricEnabled?: boolean;
+    
+    metricRuleRoleArn?: string;
+}
+export declare namespace MetricsConfiguration {
+    
+    const filterSensitiveLog: (obj: MetricsConfiguration) => any;
+}
+
+export interface Tag {
+    
+    key: string | undefined;
+    
+    value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export declare enum DeploymentTarget {
+    CLOUD = "CLOUD",
+    GREENGRASS = "GREENGRASS"
+}
+export interface CreateSystemInstanceRequest {
+    
+    tags?: Tag[];
+    
+    definition: DefinitionDocument | undefined;
+    
+    target: DeploymentTarget | string | undefined;
+    
+    greengrassGroupName?: string;
+    
+    s3BucketName?: string;
+    
+    metricsConfiguration?: MetricsConfiguration;
+    
+    flowActionsRoleArn?: string;
+}
+export declare namespace CreateSystemInstanceRequest {
+    
+    const filterSensitiveLog: (obj: CreateSystemInstanceRequest) => any;
+}
+export declare enum SystemInstanceDeploymentStatus {
+    BOOTSTRAP = "BOOTSTRAP",
+    DELETED_IN_TARGET = "DELETED_IN_TARGET",
+    DEPLOYED_IN_TARGET = "DEPLOYED_IN_TARGET",
+    DEPLOY_IN_PROGRESS = "DEPLOY_IN_PROGRESS",
+    FAILED = "FAILED",
+    NOT_DEPLOYED = "NOT_DEPLOYED",
+    PENDING_DELETE = "PENDING_DELETE",
+    UNDEPLOY_IN_PROGRESS = "UNDEPLOY_IN_PROGRESS"
+}
+
+export interface SystemInstanceSummary {
+    
+    id?: string;
+    
+    arn?: string;
+    
+    status?: SystemInstanceDeploymentStatus | string;
+    
+    target?: DeploymentTarget | string;
+    
+    greengrassGroupName?: string;
+    
+    createdAt?: Date;
+    
+    updatedAt?: Date;
+    
+    greengrassGroupId?: string;
+    
+    greengrassGroupVersionId?: string;
+}
+export declare namespace SystemInstanceSummary {
+    
+    const filterSensitiveLog: (obj: SystemInstanceSummary) => any;
+}
+export interface CreateSystemInstanceResponse {
+    
+    summary?: SystemInstanceSummary;
+}
+export declare namespace CreateSystemInstanceResponse {
+    
+    const filterSensitiveLog: (obj: CreateSystemInstanceResponse) => any;
+}
+export interface CreateSystemTemplateRequest {
+    
+    definition: DefinitionDocument | undefined;
+    
+    compatibleNamespaceVersion?: number;
+}
+export declare namespace CreateSystemTemplateRequest {
+    
+    const filterSensitiveLog: (obj: CreateSystemTemplateRequest) => any;
+}
+
+export interface SystemTemplateSummary {
+    
+    id?: string;
+    
+    arn?: string;
+    
+    revisionNumber?: number;
+    
+    createdAt?: Date;
+}
+export declare namespace SystemTemplateSummary {
+    
+    const filterSensitiveLog: (obj: SystemTemplateSummary) => any;
+}
+export interface CreateSystemTemplateResponse {
+    
+    summary?: SystemTemplateSummary;
+}
+export declare namespace CreateSystemTemplateResponse {
+    
+    const filterSensitiveLog: (obj: CreateSystemTemplateResponse) => any;
+}
+export interface DeleteFlowTemplateRequest {
+    
+    id: string | undefined;
+}
+export declare namespace DeleteFlowTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFlowTemplateRequest) => any;
+}
+export interface DeleteFlowTemplateResponse {
+}
+export declare namespace DeleteFlowTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFlowTemplateResponse) => any;
+}
+
+export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
+    name: "ResourceInUseException";
+    $fault: "client";
+    message?: string;
+}
+export interface DeleteNamespaceRequest {
+}
+export declare namespace DeleteNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteNamespaceRequest) => any;
+}
+export interface DeleteNamespaceResponse {
+    
+    namespaceArn?: string;
+    
+    namespaceName?: string;
+}
+export declare namespace DeleteNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteNamespaceResponse) => any;
+}
+export interface DeleteSystemInstanceRequest {
+    
+    id?: string;
+}
+export declare namespace DeleteSystemInstanceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSystemInstanceRequest) => any;
+}
+export interface DeleteSystemInstanceResponse {
+}
+export declare namespace DeleteSystemInstanceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSystemInstanceResponse) => any;
+}
+export interface DeleteSystemTemplateRequest {
+    
+    id: string | undefined;
+}
+export declare namespace DeleteSystemTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSystemTemplateRequest) => any;
+}
+export interface DeleteSystemTemplateResponse {
+}
+export declare namespace DeleteSystemTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSystemTemplateResponse) => any;
+}
+
+export interface DependencyRevision {
+    
+    id?: string;
+    
+    revisionNumber?: number;
+}
+export declare namespace DependencyRevision {
+    
+    const filterSensitiveLog: (obj: DependencyRevision) => any;
+}
+export interface DeploySystemInstanceRequest {
+    
+    id?: string;
+}
+export declare namespace DeploySystemInstanceRequest {
+    
+    const filterSensitiveLog: (obj: DeploySystemInstanceRequest) => any;
+}
+export interface DeploySystemInstanceResponse {
+    
+    summary: SystemInstanceSummary | undefined;
+    
+    greengrassDeploymentId?: string;
+}
+export declare namespace DeploySystemInstanceResponse {
+    
+    const filterSensitiveLog: (obj: DeploySystemInstanceResponse) => any;
+}
+export interface DeprecateFlowTemplateRequest {
+    
+    id: string | undefined;
+}
+export declare namespace DeprecateFlowTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DeprecateFlowTemplateRequest) => any;
+}
+export interface DeprecateFlowTemplateResponse {
+}
+export declare namespace DeprecateFlowTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DeprecateFlowTemplateResponse) => any;
+}
+export interface DeprecateSystemTemplateRequest {
+    
+    id: string | undefined;
+}
+export declare namespace DeprecateSystemTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DeprecateSystemTemplateRequest) => any;
+}
+export interface DeprecateSystemTemplateResponse {
+}
+export declare namespace DeprecateSystemTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DeprecateSystemTemplateResponse) => any;
+}
+export interface DescribeNamespaceRequest {
+    
+    namespaceName?: string;
+}
+export declare namespace DescribeNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: DescribeNamespaceRequest) => any;
+}
+export interface DescribeNamespaceResponse {
+    
+    namespaceArn?: string;
+    
+    namespaceName?: string;
+    
+    trackingNamespaceName?: string;
+    
+    trackingNamespaceVersion?: number;
+    
+    namespaceVersion?: number;
+}
+export declare namespace DescribeNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: DescribeNamespaceResponse) => any;
+}
+export declare enum EntityType {
+    ACTION = "ACTION",
+    CAPABILITY = "CAPABILITY",
+    DEVICE = "DEVICE",
+    DEVICE_MODEL = "DEVICE_MODEL",
+    ENUM = "ENUM",
+    EVENT = "EVENT",
+    MAPPING = "MAPPING",
+    PROPERTY = "PROPERTY",
+    SERVICE = "SERVICE",
+    STATE = "STATE"
+}
+export interface DissociateEntityFromThingRequest {
+    
+    thingName: string | undefined;
+    
+    entityType: EntityType | string | undefined;
+}
+export declare namespace DissociateEntityFromThingRequest {
+    
+    const filterSensitiveLog: (obj: DissociateEntityFromThingRequest) => any;
+}
+export interface DissociateEntityFromThingResponse {
+}
+export declare namespace DissociateEntityFromThingResponse {
+    
+    const filterSensitiveLog: (obj: DissociateEntityFromThingResponse) => any;
+}
+
+export interface EntityDescription {
+    
+    id?: string;
+    
+    arn?: string;
+    
+    type?: EntityType | string;
+    
+    createdAt?: Date;
+    
+    definition?: DefinitionDocument;
+}
+export declare namespace EntityDescription {
+    
+    const filterSensitiveLog: (obj: EntityDescription) => any;
+}
+export declare enum EntityFilterName {
+    NAME = "NAME",
+    NAMESPACE = "NAMESPACE",
+    REFERENCED_ENTITY_ID = "REFERENCED_ENTITY_ID",
+    SEMANTIC_TYPE_PATH = "SEMANTIC_TYPE_PATH"
+}
+
+export interface EntityFilter {
+    
+    name?: EntityFilterName | string;
+    
+    value?: string[];
+}
+export declare namespace EntityFilter {
+    
+    const filterSensitiveLog: (obj: EntityFilter) => any;
+}
+export declare enum FlowExecutionEventType {
+    ACKNOWLEDGE_TASK_MESSAGE = "ACKNOWLEDGE_TASK_MESSAGE",
+    ACTIVITY_FAILED = "ACTIVITY_FAILED",
+    ACTIVITY_SCHEDULED = "ACTIVITY_SCHEDULED",
+    ACTIVITY_STARTED = "ACTIVITY_STARTED",
+    ACTIVITY_SUCCEEDED = "ACTIVITY_SUCCEEDED",
+    EXECUTION_ABORTED = "EXECUTION_ABORTED",
+    EXECUTION_FAILED = "EXECUTION_FAILED",
+    EXECUTION_STARTED = "EXECUTION_STARTED",
+    EXECUTION_SUCCEEDED = "EXECUTION_SUCCEEDED",
+    SCHEDULE_NEXT_READY_STEPS_TASK = "SCHEDULE_NEXT_READY_STEPS_TASK",
+    START_FLOW_EXECUTION_TASK = "START_FLOW_EXECUTION_TASK",
+    STEP_FAILED = "STEP_FAILED",
+    STEP_STARTED = "STEP_STARTED",
+    STEP_SUCCEEDED = "STEP_SUCCEEDED",
+    THING_ACTION_TASK = "THING_ACTION_TASK",
+    THING_ACTION_TASK_FAILED = "THING_ACTION_TASK_FAILED",
+    THING_ACTION_TASK_SUCCEEDED = "THING_ACTION_TASK_SUCCEEDED"
+}
+
+export interface FlowExecutionMessage {
+    
+    messageId?: string;
+    
+    eventType?: FlowExecutionEventType | string;
+    
+    timestamp?: Date;
+    
+    payload?: string;
+}
+export declare namespace FlowExecutionMessage {
+    
+    const filterSensitiveLog: (obj: FlowExecutionMessage) => any;
+}
+export declare enum FlowExecutionStatus {
+    ABORTED = "ABORTED",
+    FAILED = "FAILED",
+    RUNNING = "RUNNING",
+    SUCCEEDED = "SUCCEEDED"
+}
+
+export interface FlowExecutionSummary {
+    
+    flowExecutionId?: string;
+    
+    status?: FlowExecutionStatus | string;
+    
+    systemInstanceId?: string;
+    
+    flowTemplateId?: string;
+    
+    createdAt?: Date;
+    
+    updatedAt?: Date;
+}
+export declare namespace FlowExecutionSummary {
+    
+    const filterSensitiveLog: (obj: FlowExecutionSummary) => any;
+}
+
+export interface FlowTemplateDescription {
+    
+    summary?: FlowTemplateSummary;
+    
+    definition?: DefinitionDocument;
+    
+    validatedNamespaceVersion?: number;
+}
+export declare namespace FlowTemplateDescription {
+    
+    const filterSensitiveLog: (obj: FlowTemplateDescription) => any;
+}
+export declare enum FlowTemplateFilterName {
+    DEVICE_MODEL_ID = "DEVICE_MODEL_ID"
+}
+
+export interface FlowTemplateFilter {
+    
+    name: FlowTemplateFilterName | string | undefined;
+    
+    value: string[] | undefined;
+}
+export declare namespace FlowTemplateFilter {
+    
+    const filterSensitiveLog: (obj: FlowTemplateFilter) => any;
+}
+export interface GetEntitiesRequest {
+    
+    ids: string[] | undefined;
+    
+    namespaceVersion?: number;
+}
+export declare namespace GetEntitiesRequest {
+    
+    const filterSensitiveLog: (obj: GetEntitiesRequest) => any;
+}
+export interface GetEntitiesResponse {
+    
+    descriptions?: EntityDescription[];
+}
+export declare namespace GetEntitiesResponse {
+    
+    const filterSensitiveLog: (obj: GetEntitiesResponse) => any;
+}
+export interface GetFlowTemplateRequest {
+    
+    id: string | undefined;
+    
+    revisionNumber?: number;
+}
+export declare namespace GetFlowTemplateRequest {
+    
+    const filterSensitiveLog: (obj: GetFlowTemplateRequest) => any;
+}
+export interface GetFlowTemplateResponse {
+    
+    description?: FlowTemplateDescription;
+}
+export declare namespace GetFlowTemplateResponse {
+    
+    const filterSensitiveLog: (obj: GetFlowTemplateResponse) => any;
+}
+export interface GetFlowTemplateRevisionsRequest {
+    
+    id: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetFlowTemplateRevisionsRequest {
+    
+    const filterSensitiveLog: (obj: GetFlowTemplateRevisionsRequest) => any;
+}
+export interface GetFlowTemplateRevisionsResponse {
+    
+    summaries?: FlowTemplateSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace GetFlowTemplateRevisionsResponse {
+    
+    const filterSensitiveLog: (obj: GetFlowTemplateRevisionsResponse) => any;
+}
+export interface GetNamespaceDeletionStatusRequest {
+}
+export declare namespace GetNamespaceDeletionStatusRequest {
+    
+    const filterSensitiveLog: (obj: GetNamespaceDeletionStatusRequest) => any;
+}
+export declare enum NamespaceDeletionStatusErrorCodes {
+    VALIDATION_FAILED = "VALIDATION_FAILED"
+}
+export declare enum NamespaceDeletionStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCEEDED = "SUCCEEDED"
+}
+export interface GetNamespaceDeletionStatusResponse {
+    
+    namespaceArn?: string;
+    
+    namespaceName?: string;
+    
+    status?: NamespaceDeletionStatus | string;
+    
+    errorCode?: NamespaceDeletionStatusErrorCodes | string;
+    
+    errorMessage?: string;
+}
+export declare namespace GetNamespaceDeletionStatusResponse {
+    
+    const filterSensitiveLog: (obj: GetNamespaceDeletionStatusResponse) => any;
+}
+export interface GetSystemInstanceRequest {
+    
+    id: string | undefined;
+}
+export declare namespace GetSystemInstanceRequest {
+    
+    const filterSensitiveLog: (obj: GetSystemInstanceRequest) => any;
+}
+
+export interface SystemInstanceDescription {
+    
+    summary?: SystemInstanceSummary;
+    
+    definition?: DefinitionDocument;
+    
+    s3BucketName?: string;
+    
+    metricsConfiguration?: MetricsConfiguration;
+    
+    validatedNamespaceVersion?: number;
+    
+    validatedDependencyRevisions?: DependencyRevision[];
+    
+    flowActionsRoleArn?: string;
+}
+export declare namespace SystemInstanceDescription {
+    
+    const filterSensitiveLog: (obj: SystemInstanceDescription) => any;
+}
+export interface GetSystemInstanceResponse {
+    
+    description?: SystemInstanceDescription;
+}
+export declare namespace GetSystemInstanceResponse {
+    
+    const filterSensitiveLog: (obj: GetSystemInstanceResponse) => any;
+}
+export interface GetSystemTemplateRequest {
+    
+    id: string | undefined;
+    
+    revisionNumber?: number;
+}
+export declare namespace GetSystemTemplateRequest {
+    
+    const filterSensitiveLog: (obj: GetSystemTemplateRequest) => any;
+}
+
+export interface SystemTemplateDescription {
+    
+    summary?: SystemTemplateSummary;
+    
+    definition?: DefinitionDocument;
+    
+    validatedNamespaceVersion?: number;
+}
+export declare namespace SystemTemplateDescription {
+    
+    const filterSensitiveLog: (obj: SystemTemplateDescription) => any;
+}
+export interface GetSystemTemplateResponse {
+    
+    description?: SystemTemplateDescription;
+}
+export declare namespace GetSystemTemplateResponse {
+    
+    const filterSensitiveLog: (obj: GetSystemTemplateResponse) => any;
+}
+export interface GetSystemTemplateRevisionsRequest {
+    
+    id: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetSystemTemplateRevisionsRequest {
+    
+    const filterSensitiveLog: (obj: GetSystemTemplateRevisionsRequest) => any;
+}
+export interface GetSystemTemplateRevisionsResponse {
+    
+    summaries?: SystemTemplateSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace GetSystemTemplateRevisionsResponse {
+    
+    const filterSensitiveLog: (obj: GetSystemTemplateRevisionsResponse) => any;
+}
+export interface GetUploadStatusRequest {
+    
+    uploadId: string | undefined;
+}
+export declare namespace GetUploadStatusRequest {
+    
+    const filterSensitiveLog: (obj: GetUploadStatusRequest) => any;
+}
+export declare enum UploadStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCEEDED = "SUCCEEDED"
+}
+export interface GetUploadStatusResponse {
+    
+    uploadId: string | undefined;
+    
+    uploadStatus: UploadStatus | string | undefined;
+    
+    namespaceArn?: string;
+    
+    namespaceName?: string;
+    
+    namespaceVersion?: number;
+    
+    failureReason?: string[];
+    
+    createdDate: Date | undefined;
+}
+export declare namespace GetUploadStatusResponse {
+    
+    const filterSensitiveLog: (obj: GetUploadStatusResponse) => any;
+}
+export interface ListFlowExecutionMessagesRequest {
+    
+    flowExecutionId: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListFlowExecutionMessagesRequest {
+    
+    const filterSensitiveLog: (obj: ListFlowExecutionMessagesRequest) => any;
+}
+export interface ListFlowExecutionMessagesResponse {
+    
+    messages?: FlowExecutionMessage[];
+    
+    nextToken?: string;
+}
+export declare namespace ListFlowExecutionMessagesResponse {
+    
+    const filterSensitiveLog: (obj: ListFlowExecutionMessagesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    maxResults?: number;
+    
+    resourceArn: string | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags?: Tag[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface SearchEntitiesRequest {
+    
+    entityTypes: (EntityType | string)[] | undefined;
+    
+    filters?: EntityFilter[];
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    namespaceVersion?: number;
+}
+export declare namespace SearchEntitiesRequest {
+    
+    const filterSensitiveLog: (obj: SearchEntitiesRequest) => any;
+}
+export interface SearchEntitiesResponse {
+    
+    descriptions?: EntityDescription[];
+    
+    nextToken?: string;
+}
+export declare namespace SearchEntitiesResponse {
+    
+    const filterSensitiveLog: (obj: SearchEntitiesResponse) => any;
+}
+export interface SearchFlowExecutionsRequest {
+    
+    systemInstanceId: string | undefined;
+    
+    flowExecutionId?: string;
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace SearchFlowExecutionsRequest {
+    
+    const filterSensitiveLog: (obj: SearchFlowExecutionsRequest) => any;
+}
+export interface SearchFlowExecutionsResponse {
+    
+    summaries?: FlowExecutionSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace SearchFlowExecutionsResponse {
+    
+    const filterSensitiveLog: (obj: SearchFlowExecutionsResponse) => any;
+}
+export interface SearchFlowTemplatesRequest {
+    
+    filters?: FlowTemplateFilter[];
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace SearchFlowTemplatesRequest {
+    
+    const filterSensitiveLog: (obj: SearchFlowTemplatesRequest) => any;
+}
+export interface SearchFlowTemplatesResponse {
+    
+    summaries?: FlowTemplateSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace SearchFlowTemplatesResponse {
+    
+    const filterSensitiveLog: (obj: SearchFlowTemplatesResponse) => any;
+}
+export declare enum SystemInstanceFilterName {
+    GREENGRASS_GROUP_NAME = "GREENGRASS_GROUP_NAME",
+    STATUS = "STATUS",
+    SYSTEM_TEMPLATE_ID = "SYSTEM_TEMPLATE_ID"
+}
+
+export interface SystemInstanceFilter {
+    
+    name?: SystemInstanceFilterName | string;
+    
+    value?: string[];
+}
+export declare namespace SystemInstanceFilter {
+    
+    const filterSensitiveLog: (obj: SystemInstanceFilter) => any;
+}
+export interface SearchSystemInstancesRequest {
+    
+    filters?: SystemInstanceFilter[];
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace SearchSystemInstancesRequest {
+    
+    const filterSensitiveLog: (obj: SearchSystemInstancesRequest) => any;
+}
+export interface SearchSystemInstancesResponse {
+    
+    summaries?: SystemInstanceSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace SearchSystemInstancesResponse {
+    
+    const filterSensitiveLog: (obj: SearchSystemInstancesResponse) => any;
+}
+export declare enum SystemTemplateFilterName {
+    FLOW_TEMPLATE_ID = "FLOW_TEMPLATE_ID"
+}
+
+export interface SystemTemplateFilter {
+    
+    name: SystemTemplateFilterName | string | undefined;
+    
+    value: string[] | undefined;
+}
+export declare namespace SystemTemplateFilter {
+    
+    const filterSensitiveLog: (obj: SystemTemplateFilter) => any;
+}
+export interface SearchSystemTemplatesRequest {
+    
+    filters?: SystemTemplateFilter[];
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace SearchSystemTemplatesRequest {
+    
+    const filterSensitiveLog: (obj: SearchSystemTemplatesRequest) => any;
+}
+export interface SearchSystemTemplatesResponse {
+    
+    summaries?: SystemTemplateSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace SearchSystemTemplatesResponse {
+    
+    const filterSensitiveLog: (obj: SearchSystemTemplatesResponse) => any;
+}
+export interface SearchThingsRequest {
+    
+    entityId: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    namespaceVersion?: number;
+}
+export declare namespace SearchThingsRequest {
+    
+    const filterSensitiveLog: (obj: SearchThingsRequest) => any;
+}
+
+export interface Thing {
+    
+    thingArn?: string;
+    
+    thingName?: string;
+}
+export declare namespace Thing {
+    
+    const filterSensitiveLog: (obj: Thing) => any;
+}
+export interface SearchThingsResponse {
+    
+    things?: Thing[];
+    
+    nextToken?: string;
+}
+export declare namespace SearchThingsResponse {
+    
+    const filterSensitiveLog: (obj: SearchThingsResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UndeploySystemInstanceRequest {
+    
+    id?: string;
+}
+export declare namespace UndeploySystemInstanceRequest {
+    
+    const filterSensitiveLog: (obj: UndeploySystemInstanceRequest) => any;
+}
+export interface UndeploySystemInstanceResponse {
+    
+    summary?: SystemInstanceSummary;
+}
+export declare namespace UndeploySystemInstanceResponse {
+    
+    const filterSensitiveLog: (obj: UndeploySystemInstanceResponse) => 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 UpdateFlowTemplateRequest {
+    
+    id: string | undefined;
+    
+    definition: DefinitionDocument | undefined;
+    
+    compatibleNamespaceVersion?: number;
+}
+export declare namespace UpdateFlowTemplateRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFlowTemplateRequest) => any;
+}
+export interface UpdateFlowTemplateResponse {
+    
+    summary?: FlowTemplateSummary;
+}
+export declare namespace UpdateFlowTemplateResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFlowTemplateResponse) => any;
+}
+export interface UpdateSystemTemplateRequest {
+    
+    id: string | undefined;
+    
+    definition: DefinitionDocument | undefined;
+    
+    compatibleNamespaceVersion?: number;
+}
+export declare namespace UpdateSystemTemplateRequest {
+    
+    const filterSensitiveLog: (obj: UpdateSystemTemplateRequest) => any;
+}
+export interface UpdateSystemTemplateResponse {
+    
+    summary?: SystemTemplateSummary;
+}
+export declare namespace UpdateSystemTemplateResponse {
+    
+    const filterSensitiveLog: (obj: UpdateSystemTemplateResponse) => any;
+}
+export interface UploadEntityDefinitionsRequest {
+    
+    document?: DefinitionDocument;
+    
+    syncWithPublicNamespace?: boolean;
+    
+    deprecateExistingEntities?: boolean;
+}
+export declare namespace UploadEntityDefinitionsRequest {
+    
+    const filterSensitiveLog: (obj: UploadEntityDefinitionsRequest) => any;
+}
+export interface UploadEntityDefinitionsResponse {
+    
+    uploadId: string | undefined;
+}
+export declare namespace UploadEntityDefinitionsResponse {
+    
+    const filterSensitiveLog: (obj: UploadEntityDefinitionsResponse) => any;
+}