@aws-sdk/client-fis 3.50.0 → 3.51.0

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

@@ -0,0 +1,842 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface ActionParameter {
+    
+    description?: string;
+    
+    required?: boolean;
+}
+export declare namespace ActionParameter {
+    
+    const filterSensitiveLog: (obj: ActionParameter) => any;
+}
+
+export interface ActionTarget {
+    
+    resourceType?: string;
+}
+export declare namespace ActionTarget {
+    
+    const filterSensitiveLog: (obj: ActionTarget) => any;
+}
+
+export interface Action {
+    
+    id?: string;
+    
+    description?: string;
+    
+    parameters?: {
+        [key: string]: ActionParameter;
+    };
+    
+    targets?: {
+        [key: string]: ActionTarget;
+    };
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Action {
+    
+    const filterSensitiveLog: (obj: Action) => any;
+}
+
+export interface ActionSummary {
+    
+    id?: string;
+    
+    description?: string;
+    
+    targets?: {
+        [key: string]: ActionTarget;
+    };
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ActionSummary {
+    
+    const filterSensitiveLog: (obj: ActionSummary) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    message?: string;
+}
+
+export interface CreateExperimentTemplateActionInput {
+    
+    actionId: string | undefined;
+    
+    description?: string;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+    
+    targets?: {
+        [key: string]: string;
+    };
+    
+    startAfter?: string[];
+}
+export declare namespace CreateExperimentTemplateActionInput {
+    
+    const filterSensitiveLog: (obj: CreateExperimentTemplateActionInput) => any;
+}
+
+export interface CreateExperimentTemplateStopConditionInput {
+    
+    source: string | undefined;
+    
+    value?: string;
+}
+export declare namespace CreateExperimentTemplateStopConditionInput {
+    
+    const filterSensitiveLog: (obj: CreateExperimentTemplateStopConditionInput) => any;
+}
+
+export interface ExperimentTemplateTargetInputFilter {
+    
+    path: string | undefined;
+    
+    values: string[] | undefined;
+}
+export declare namespace ExperimentTemplateTargetInputFilter {
+    
+    const filterSensitiveLog: (obj: ExperimentTemplateTargetInputFilter) => any;
+}
+
+export interface CreateExperimentTemplateTargetInput {
+    
+    resourceType: string | undefined;
+    
+    resourceArns?: string[];
+    
+    resourceTags?: {
+        [key: string]: string;
+    };
+    
+    filters?: ExperimentTemplateTargetInputFilter[];
+    
+    selectionMode: string | undefined;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateExperimentTemplateTargetInput {
+    
+    const filterSensitiveLog: (obj: CreateExperimentTemplateTargetInput) => any;
+}
+export interface CreateExperimentTemplateRequest {
+    
+    clientToken?: string;
+    
+    description: string | undefined;
+    
+    stopConditions: CreateExperimentTemplateStopConditionInput[] | undefined;
+    
+    targets?: {
+        [key: string]: CreateExperimentTemplateTargetInput;
+    };
+    
+    actions: {
+        [key: string]: CreateExperimentTemplateActionInput;
+    } | undefined;
+    
+    roleArn: string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateExperimentTemplateRequest {
+    
+    const filterSensitiveLog: (obj: CreateExperimentTemplateRequest) => any;
+}
+
+export interface ExperimentTemplateAction {
+    
+    actionId?: string;
+    
+    description?: string;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+    
+    targets?: {
+        [key: string]: string;
+    };
+    
+    startAfter?: string[];
+}
+export declare namespace ExperimentTemplateAction {
+    
+    const filterSensitiveLog: (obj: ExperimentTemplateAction) => any;
+}
+
+export interface ExperimentTemplateStopCondition {
+    
+    source?: string;
+    
+    value?: string;
+}
+export declare namespace ExperimentTemplateStopCondition {
+    
+    const filterSensitiveLog: (obj: ExperimentTemplateStopCondition) => any;
+}
+
+export interface ExperimentTemplateTargetFilter {
+    
+    path?: string;
+    
+    values?: string[];
+}
+export declare namespace ExperimentTemplateTargetFilter {
+    
+    const filterSensitiveLog: (obj: ExperimentTemplateTargetFilter) => any;
+}
+
+export interface ExperimentTemplateTarget {
+    
+    resourceType?: string;
+    
+    resourceArns?: string[];
+    
+    resourceTags?: {
+        [key: string]: string;
+    };
+    
+    filters?: ExperimentTemplateTargetFilter[];
+    
+    selectionMode?: string;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ExperimentTemplateTarget {
+    
+    const filterSensitiveLog: (obj: ExperimentTemplateTarget) => any;
+}
+
+export interface ExperimentTemplate {
+    
+    id?: string;
+    
+    description?: string;
+    
+    targets?: {
+        [key: string]: ExperimentTemplateTarget;
+    };
+    
+    actions?: {
+        [key: string]: ExperimentTemplateAction;
+    };
+    
+    stopConditions?: ExperimentTemplateStopCondition[];
+    
+    creationTime?: Date;
+    
+    lastUpdateTime?: Date;
+    
+    roleArn?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ExperimentTemplate {
+    
+    const filterSensitiveLog: (obj: ExperimentTemplate) => any;
+}
+export interface CreateExperimentTemplateResponse {
+    
+    experimentTemplate?: ExperimentTemplate;
+}
+export declare namespace CreateExperimentTemplateResponse {
+    
+    const filterSensitiveLog: (obj: CreateExperimentTemplateResponse) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+
+export interface ServiceQuotaExceededException extends __SmithyException, $MetadataBearer {
+    name: "ServiceQuotaExceededException";
+    $fault: "client";
+    message?: string;
+}
+
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    message?: string;
+}
+export interface DeleteExperimentTemplateRequest {
+    
+    id: string | undefined;
+}
+export declare namespace DeleteExperimentTemplateRequest {
+    
+    const filterSensitiveLog: (obj: DeleteExperimentTemplateRequest) => any;
+}
+export interface DeleteExperimentTemplateResponse {
+    
+    experimentTemplate?: ExperimentTemplate;
+}
+export declare namespace DeleteExperimentTemplateResponse {
+    
+    const filterSensitiveLog: (obj: DeleteExperimentTemplateResponse) => any;
+}
+export declare enum ExperimentActionStatus {
+    cancelled = "cancelled",
+    completed = "completed",
+    failed = "failed",
+    initiating = "initiating",
+    pending = "pending",
+    running = "running",
+    stopped = "stopped",
+    stopping = "stopping"
+}
+
+export interface ExperimentActionState {
+    
+    status?: ExperimentActionStatus | string;
+    
+    reason?: string;
+}
+export declare namespace ExperimentActionState {
+    
+    const filterSensitiveLog: (obj: ExperimentActionState) => any;
+}
+
+export interface ExperimentAction {
+    
+    actionId?: string;
+    
+    description?: string;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+    
+    targets?: {
+        [key: string]: string;
+    };
+    
+    startAfter?: string[];
+    
+    state?: ExperimentActionState;
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+}
+export declare namespace ExperimentAction {
+    
+    const filterSensitiveLog: (obj: ExperimentAction) => any;
+}
+export declare enum ExperimentStatus {
+    completed = "completed",
+    failed = "failed",
+    initiating = "initiating",
+    pending = "pending",
+    running = "running",
+    stopped = "stopped",
+    stopping = "stopping"
+}
+
+export interface ExperimentState {
+    
+    status?: ExperimentStatus | string;
+    
+    reason?: string;
+}
+export declare namespace ExperimentState {
+    
+    const filterSensitiveLog: (obj: ExperimentState) => any;
+}
+
+export interface ExperimentStopCondition {
+    
+    source?: string;
+    
+    value?: string;
+}
+export declare namespace ExperimentStopCondition {
+    
+    const filterSensitiveLog: (obj: ExperimentStopCondition) => any;
+}
+
+export interface ExperimentTargetFilter {
+    
+    path?: string;
+    
+    values?: string[];
+}
+export declare namespace ExperimentTargetFilter {
+    
+    const filterSensitiveLog: (obj: ExperimentTargetFilter) => any;
+}
+
+export interface ExperimentTarget {
+    
+    resourceType?: string;
+    
+    resourceArns?: string[];
+    
+    resourceTags?: {
+        [key: string]: string;
+    };
+    
+    filters?: ExperimentTargetFilter[];
+    
+    selectionMode?: string;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ExperimentTarget {
+    
+    const filterSensitiveLog: (obj: ExperimentTarget) => any;
+}
+
+export interface Experiment {
+    
+    id?: string;
+    
+    experimentTemplateId?: string;
+    
+    roleArn?: string;
+    
+    state?: ExperimentState;
+    
+    targets?: {
+        [key: string]: ExperimentTarget;
+    };
+    
+    actions?: {
+        [key: string]: ExperimentAction;
+    };
+    
+    stopConditions?: ExperimentStopCondition[];
+    
+    creationTime?: Date;
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Experiment {
+    
+    const filterSensitiveLog: (obj: Experiment) => any;
+}
+
+export interface ExperimentSummary {
+    
+    id?: string;
+    
+    experimentTemplateId?: string;
+    
+    state?: ExperimentState;
+    
+    creationTime?: Date;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ExperimentSummary {
+    
+    const filterSensitiveLog: (obj: ExperimentSummary) => any;
+}
+
+export interface ExperimentTemplateSummary {
+    
+    id?: string;
+    
+    description?: string;
+    
+    creationTime?: Date;
+    
+    lastUpdateTime?: Date;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ExperimentTemplateSummary {
+    
+    const filterSensitiveLog: (obj: ExperimentTemplateSummary) => any;
+}
+export interface GetActionRequest {
+    
+    id: string | undefined;
+}
+export declare namespace GetActionRequest {
+    
+    const filterSensitiveLog: (obj: GetActionRequest) => any;
+}
+export interface GetActionResponse {
+    
+    action?: Action;
+}
+export declare namespace GetActionResponse {
+    
+    const filterSensitiveLog: (obj: GetActionResponse) => any;
+}
+export interface GetExperimentRequest {
+    
+    id: string | undefined;
+}
+export declare namespace GetExperimentRequest {
+    
+    const filterSensitiveLog: (obj: GetExperimentRequest) => any;
+}
+export interface GetExperimentResponse {
+    
+    experiment?: Experiment;
+}
+export declare namespace GetExperimentResponse {
+    
+    const filterSensitiveLog: (obj: GetExperimentResponse) => any;
+}
+export interface GetExperimentTemplateRequest {
+    
+    id: string | undefined;
+}
+export declare namespace GetExperimentTemplateRequest {
+    
+    const filterSensitiveLog: (obj: GetExperimentTemplateRequest) => any;
+}
+export interface GetExperimentTemplateResponse {
+    
+    experimentTemplate?: ExperimentTemplate;
+}
+export declare namespace GetExperimentTemplateResponse {
+    
+    const filterSensitiveLog: (obj: GetExperimentTemplateResponse) => any;
+}
+export interface GetTargetResourceTypeRequest {
+    
+    resourceType: string | undefined;
+}
+export declare namespace GetTargetResourceTypeRequest {
+    
+    const filterSensitiveLog: (obj: GetTargetResourceTypeRequest) => any;
+}
+
+export interface TargetResourceTypeParameter {
+    
+    description?: string;
+    
+    required?: boolean;
+}
+export declare namespace TargetResourceTypeParameter {
+    
+    const filterSensitiveLog: (obj: TargetResourceTypeParameter) => any;
+}
+
+export interface TargetResourceType {
+    
+    resourceType?: string;
+    
+    description?: string;
+    
+    parameters?: {
+        [key: string]: TargetResourceTypeParameter;
+    };
+}
+export declare namespace TargetResourceType {
+    
+    const filterSensitiveLog: (obj: TargetResourceType) => any;
+}
+export interface GetTargetResourceTypeResponse {
+    
+    targetResourceType?: TargetResourceType;
+}
+export declare namespace GetTargetResourceTypeResponse {
+    
+    const filterSensitiveLog: (obj: GetTargetResourceTypeResponse) => any;
+}
+export interface ListActionsRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListActionsRequest {
+    
+    const filterSensitiveLog: (obj: ListActionsRequest) => any;
+}
+export interface ListActionsResponse {
+    
+    actions?: ActionSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListActionsResponse {
+    
+    const filterSensitiveLog: (obj: ListActionsResponse) => any;
+}
+export interface ListExperimentsRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListExperimentsRequest {
+    
+    const filterSensitiveLog: (obj: ListExperimentsRequest) => any;
+}
+export interface ListExperimentsResponse {
+    
+    experiments?: ExperimentSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListExperimentsResponse {
+    
+    const filterSensitiveLog: (obj: ListExperimentsResponse) => any;
+}
+export interface ListExperimentTemplatesRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListExperimentTemplatesRequest {
+    
+    const filterSensitiveLog: (obj: ListExperimentTemplatesRequest) => any;
+}
+export interface ListExperimentTemplatesResponse {
+    
+    experimentTemplates?: ExperimentTemplateSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListExperimentTemplatesResponse {
+    
+    const filterSensitiveLog: (obj: ListExperimentTemplatesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ListTargetResourceTypesRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListTargetResourceTypesRequest {
+    
+    const filterSensitiveLog: (obj: ListTargetResourceTypesRequest) => any;
+}
+
+export interface TargetResourceTypeSummary {
+    
+    resourceType?: string;
+    
+    description?: string;
+}
+export declare namespace TargetResourceTypeSummary {
+    
+    const filterSensitiveLog: (obj: TargetResourceTypeSummary) => any;
+}
+export interface ListTargetResourceTypesResponse {
+    
+    targetResourceTypes?: TargetResourceTypeSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTargetResourceTypesResponse {
+    
+    const filterSensitiveLog: (obj: ListTargetResourceTypesResponse) => any;
+}
+export interface StartExperimentRequest {
+    
+    clientToken?: string;
+    
+    experimentTemplateId: string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace StartExperimentRequest {
+    
+    const filterSensitiveLog: (obj: StartExperimentRequest) => any;
+}
+export interface StartExperimentResponse {
+    
+    experiment?: Experiment;
+}
+export declare namespace StartExperimentResponse {
+    
+    const filterSensitiveLog: (obj: StartExperimentResponse) => any;
+}
+export interface StopExperimentRequest {
+    
+    id: string | undefined;
+}
+export declare namespace StopExperimentRequest {
+    
+    const filterSensitiveLog: (obj: StopExperimentRequest) => any;
+}
+export interface StopExperimentResponse {
+    
+    experiment?: Experiment;
+}
+export declare namespace StopExperimentResponse {
+    
+    const filterSensitiveLog: (obj: StopExperimentResponse) => 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 UntagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys?: string[];
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+
+export interface UpdateExperimentTemplateActionInputItem {
+    
+    actionId?: string;
+    
+    description?: string;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+    
+    targets?: {
+        [key: string]: string;
+    };
+    
+    startAfter?: string[];
+}
+export declare namespace UpdateExperimentTemplateActionInputItem {
+    
+    const filterSensitiveLog: (obj: UpdateExperimentTemplateActionInputItem) => any;
+}
+
+export interface UpdateExperimentTemplateStopConditionInput {
+    
+    source: string | undefined;
+    
+    value?: string;
+}
+export declare namespace UpdateExperimentTemplateStopConditionInput {
+    
+    const filterSensitiveLog: (obj: UpdateExperimentTemplateStopConditionInput) => any;
+}
+
+export interface UpdateExperimentTemplateTargetInput {
+    
+    resourceType: string | undefined;
+    
+    resourceArns?: string[];
+    
+    resourceTags?: {
+        [key: string]: string;
+    };
+    
+    filters?: ExperimentTemplateTargetInputFilter[];
+    
+    selectionMode: string | undefined;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace UpdateExperimentTemplateTargetInput {
+    
+    const filterSensitiveLog: (obj: UpdateExperimentTemplateTargetInput) => any;
+}
+export interface UpdateExperimentTemplateRequest {
+    
+    id: string | undefined;
+    
+    description?: string;
+    
+    stopConditions?: UpdateExperimentTemplateStopConditionInput[];
+    
+    targets?: {
+        [key: string]: UpdateExperimentTemplateTargetInput;
+    };
+    
+    actions?: {
+        [key: string]: UpdateExperimentTemplateActionInputItem;
+    };
+    
+    roleArn?: string;
+}
+export declare namespace UpdateExperimentTemplateRequest {
+    
+    const filterSensitiveLog: (obj: UpdateExperimentTemplateRequest) => any;
+}
+export interface UpdateExperimentTemplateResponse {
+    
+    experimentTemplate?: ExperimentTemplate;
+}
+export declare namespace UpdateExperimentTemplateResponse {
+    
+    const filterSensitiveLog: (obj: UpdateExperimentTemplateResponse) => any;
+}