@aws-sdk/client-data-pipeline 3.50.0 → 3.51.0

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

@@ -0,0 +1,635 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface ParameterValue {
+    
+    id: string | undefined;
+    
+    stringValue: string | undefined;
+}
+export declare namespace ParameterValue {
+    
+    const filterSensitiveLog: (obj: ParameterValue) => any;
+}
+
+export interface ActivatePipelineInput {
+    
+    pipelineId: string | undefined;
+    
+    parameterValues?: ParameterValue[];
+    
+    startTimestamp?: Date;
+}
+export declare namespace ActivatePipelineInput {
+    
+    const filterSensitiveLog: (obj: ActivatePipelineInput) => any;
+}
+
+export interface ActivatePipelineOutput {
+}
+export declare namespace ActivatePipelineOutput {
+    
+    const filterSensitiveLog: (obj: ActivatePipelineOutput) => any;
+}
+
+export interface InternalServiceError extends __SmithyException, $MetadataBearer {
+    name: "InternalServiceError";
+    $fault: "server";
+    
+    message?: string;
+}
+
+export interface InvalidRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRequestException";
+    $fault: "client";
+    
+    message?: string;
+}
+
+export interface PipelineDeletedException extends __SmithyException, $MetadataBearer {
+    name: "PipelineDeletedException";
+    $fault: "client";
+    
+    message?: string;
+}
+
+export interface PipelineNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "PipelineNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+
+export interface Tag {
+    
+    key: string | undefined;
+    
+    value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface AddTagsInput {
+    
+    pipelineId: string | undefined;
+    
+    tags: Tag[] | undefined;
+}
+export declare namespace AddTagsInput {
+    
+    const filterSensitiveLog: (obj: AddTagsInput) => any;
+}
+
+export interface AddTagsOutput {
+}
+export declare namespace AddTagsOutput {
+    
+    const filterSensitiveLog: (obj: AddTagsOutput) => any;
+}
+
+export interface CreatePipelineInput {
+    
+    name: string | undefined;
+    
+    uniqueId: string | undefined;
+    
+    description?: string;
+    
+    tags?: Tag[];
+}
+export declare namespace CreatePipelineInput {
+    
+    const filterSensitiveLog: (obj: CreatePipelineInput) => any;
+}
+
+export interface CreatePipelineOutput {
+    
+    pipelineId: string | undefined;
+}
+export declare namespace CreatePipelineOutput {
+    
+    const filterSensitiveLog: (obj: CreatePipelineOutput) => any;
+}
+
+export interface DeactivatePipelineInput {
+    
+    pipelineId: string | undefined;
+    
+    cancelActive?: boolean;
+}
+export declare namespace DeactivatePipelineInput {
+    
+    const filterSensitiveLog: (obj: DeactivatePipelineInput) => any;
+}
+
+export interface DeactivatePipelineOutput {
+}
+export declare namespace DeactivatePipelineOutput {
+    
+    const filterSensitiveLog: (obj: DeactivatePipelineOutput) => any;
+}
+
+export interface DeletePipelineInput {
+    
+    pipelineId: string | undefined;
+}
+export declare namespace DeletePipelineInput {
+    
+    const filterSensitiveLog: (obj: DeletePipelineInput) => any;
+}
+
+export interface DescribeObjectsInput {
+    
+    pipelineId: string | undefined;
+    
+    objectIds: string[] | undefined;
+    
+    evaluateExpressions?: boolean;
+    
+    marker?: string;
+}
+export declare namespace DescribeObjectsInput {
+    
+    const filterSensitiveLog: (obj: DescribeObjectsInput) => any;
+}
+
+export interface Field {
+    
+    key: string | undefined;
+    
+    stringValue?: string;
+    
+    refValue?: string;
+}
+export declare namespace Field {
+    
+    const filterSensitiveLog: (obj: Field) => any;
+}
+
+export interface PipelineObject {
+    
+    id: string | undefined;
+    
+    name: string | undefined;
+    
+    fields: Field[] | undefined;
+}
+export declare namespace PipelineObject {
+    
+    const filterSensitiveLog: (obj: PipelineObject) => any;
+}
+
+export interface DescribeObjectsOutput {
+    
+    pipelineObjects: PipelineObject[] | undefined;
+    
+    marker?: string;
+    
+    hasMoreResults?: boolean;
+}
+export declare namespace DescribeObjectsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeObjectsOutput) => any;
+}
+
+export interface DescribePipelinesInput {
+    
+    pipelineIds: string[] | undefined;
+}
+export declare namespace DescribePipelinesInput {
+    
+    const filterSensitiveLog: (obj: DescribePipelinesInput) => any;
+}
+
+export interface PipelineDescription {
+    
+    pipelineId: string | undefined;
+    
+    name: string | undefined;
+    
+    fields: Field[] | undefined;
+    
+    description?: string;
+    
+    tags?: Tag[];
+}
+export declare namespace PipelineDescription {
+    
+    const filterSensitiveLog: (obj: PipelineDescription) => any;
+}
+
+export interface DescribePipelinesOutput {
+    
+    pipelineDescriptionList: PipelineDescription[] | undefined;
+}
+export declare namespace DescribePipelinesOutput {
+    
+    const filterSensitiveLog: (obj: DescribePipelinesOutput) => any;
+}
+
+export interface EvaluateExpressionInput {
+    
+    pipelineId: string | undefined;
+    
+    objectId: string | undefined;
+    
+    expression: string | undefined;
+}
+export declare namespace EvaluateExpressionInput {
+    
+    const filterSensitiveLog: (obj: EvaluateExpressionInput) => any;
+}
+
+export interface EvaluateExpressionOutput {
+    
+    evaluatedExpression: string | undefined;
+}
+export declare namespace EvaluateExpressionOutput {
+    
+    const filterSensitiveLog: (obj: EvaluateExpressionOutput) => any;
+}
+
+export interface TaskNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "TaskNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+
+export interface GetPipelineDefinitionInput {
+    
+    pipelineId: string | undefined;
+    
+    version?: string;
+}
+export declare namespace GetPipelineDefinitionInput {
+    
+    const filterSensitiveLog: (obj: GetPipelineDefinitionInput) => any;
+}
+
+export interface ParameterAttribute {
+    
+    key: string | undefined;
+    
+    stringValue: string | undefined;
+}
+export declare namespace ParameterAttribute {
+    
+    const filterSensitiveLog: (obj: ParameterAttribute) => any;
+}
+
+export interface ParameterObject {
+    
+    id: string | undefined;
+    
+    attributes: ParameterAttribute[] | undefined;
+}
+export declare namespace ParameterObject {
+    
+    const filterSensitiveLog: (obj: ParameterObject) => any;
+}
+
+export interface GetPipelineDefinitionOutput {
+    
+    pipelineObjects?: PipelineObject[];
+    
+    parameterObjects?: ParameterObject[];
+    
+    parameterValues?: ParameterValue[];
+}
+export declare namespace GetPipelineDefinitionOutput {
+    
+    const filterSensitiveLog: (obj: GetPipelineDefinitionOutput) => any;
+}
+
+export interface ListPipelinesInput {
+    
+    marker?: string;
+}
+export declare namespace ListPipelinesInput {
+    
+    const filterSensitiveLog: (obj: ListPipelinesInput) => any;
+}
+
+export interface PipelineIdName {
+    
+    id?: string;
+    
+    name?: string;
+}
+export declare namespace PipelineIdName {
+    
+    const filterSensitiveLog: (obj: PipelineIdName) => any;
+}
+
+export interface ListPipelinesOutput {
+    
+    pipelineIdList: PipelineIdName[] | undefined;
+    
+    marker?: string;
+    
+    hasMoreResults?: boolean;
+}
+export declare namespace ListPipelinesOutput {
+    
+    const filterSensitiveLog: (obj: ListPipelinesOutput) => any;
+}
+
+export interface InstanceIdentity {
+    
+    document?: string;
+    
+    signature?: string;
+}
+export declare namespace InstanceIdentity {
+    
+    const filterSensitiveLog: (obj: InstanceIdentity) => any;
+}
+
+export interface PollForTaskInput {
+    
+    workerGroup: string | undefined;
+    
+    hostname?: string;
+    
+    instanceIdentity?: InstanceIdentity;
+}
+export declare namespace PollForTaskInput {
+    
+    const filterSensitiveLog: (obj: PollForTaskInput) => any;
+}
+
+export interface TaskObject {
+    
+    taskId?: string;
+    
+    pipelineId?: string;
+    
+    attemptId?: string;
+    
+    objects?: {
+        [key: string]: PipelineObject;
+    };
+}
+export declare namespace TaskObject {
+    
+    const filterSensitiveLog: (obj: TaskObject) => any;
+}
+
+export interface PollForTaskOutput {
+    
+    taskObject?: TaskObject;
+}
+export declare namespace PollForTaskOutput {
+    
+    const filterSensitiveLog: (obj: PollForTaskOutput) => any;
+}
+
+export interface PutPipelineDefinitionInput {
+    
+    pipelineId: string | undefined;
+    
+    pipelineObjects: PipelineObject[] | undefined;
+    
+    parameterObjects?: ParameterObject[];
+    
+    parameterValues?: ParameterValue[];
+}
+export declare namespace PutPipelineDefinitionInput {
+    
+    const filterSensitiveLog: (obj: PutPipelineDefinitionInput) => any;
+}
+
+export interface ValidationError {
+    
+    id?: string;
+    
+    errors?: string[];
+}
+export declare namespace ValidationError {
+    
+    const filterSensitiveLog: (obj: ValidationError) => any;
+}
+
+export interface ValidationWarning {
+    
+    id?: string;
+    
+    warnings?: string[];
+}
+export declare namespace ValidationWarning {
+    
+    const filterSensitiveLog: (obj: ValidationWarning) => any;
+}
+
+export interface PutPipelineDefinitionOutput {
+    
+    validationErrors?: ValidationError[];
+    
+    validationWarnings?: ValidationWarning[];
+    
+    errored: boolean | undefined;
+}
+export declare namespace PutPipelineDefinitionOutput {
+    
+    const filterSensitiveLog: (obj: PutPipelineDefinitionOutput) => any;
+}
+export declare enum OperatorType {
+    Between = "BETWEEN",
+    Equal = "EQ",
+    GreaterThanOrEqual = "GE",
+    LessThanOrEqual = "LE",
+    ReferenceEqual = "REF_EQ"
+}
+
+export interface Operator {
+    
+    type?: OperatorType | string;
+    
+    values?: string[];
+}
+export declare namespace Operator {
+    
+    const filterSensitiveLog: (obj: Operator) => any;
+}
+
+export interface Selector {
+    
+    fieldName?: string;
+    
+    operator?: Operator;
+}
+export declare namespace Selector {
+    
+    const filterSensitiveLog: (obj: Selector) => any;
+}
+
+export interface Query {
+    
+    selectors?: Selector[];
+}
+export declare namespace Query {
+    
+    const filterSensitiveLog: (obj: Query) => any;
+}
+
+export interface QueryObjectsInput {
+    
+    pipelineId: string | undefined;
+    
+    query?: Query;
+    
+    sphere: string | undefined;
+    
+    marker?: string;
+    
+    limit?: number;
+}
+export declare namespace QueryObjectsInput {
+    
+    const filterSensitiveLog: (obj: QueryObjectsInput) => any;
+}
+
+export interface QueryObjectsOutput {
+    
+    ids?: string[];
+    
+    marker?: string;
+    
+    hasMoreResults?: boolean;
+}
+export declare namespace QueryObjectsOutput {
+    
+    const filterSensitiveLog: (obj: QueryObjectsOutput) => any;
+}
+
+export interface RemoveTagsInput {
+    
+    pipelineId: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace RemoveTagsInput {
+    
+    const filterSensitiveLog: (obj: RemoveTagsInput) => any;
+}
+
+export interface RemoveTagsOutput {
+}
+export declare namespace RemoveTagsOutput {
+    
+    const filterSensitiveLog: (obj: RemoveTagsOutput) => any;
+}
+
+export interface ReportTaskProgressInput {
+    
+    taskId: string | undefined;
+    
+    fields?: Field[];
+}
+export declare namespace ReportTaskProgressInput {
+    
+    const filterSensitiveLog: (obj: ReportTaskProgressInput) => any;
+}
+
+export interface ReportTaskProgressOutput {
+    
+    canceled: boolean | undefined;
+}
+export declare namespace ReportTaskProgressOutput {
+    
+    const filterSensitiveLog: (obj: ReportTaskProgressOutput) => any;
+}
+
+export interface ReportTaskRunnerHeartbeatInput {
+    
+    taskrunnerId: string | undefined;
+    
+    workerGroup?: string;
+    
+    hostname?: string;
+}
+export declare namespace ReportTaskRunnerHeartbeatInput {
+    
+    const filterSensitiveLog: (obj: ReportTaskRunnerHeartbeatInput) => any;
+}
+
+export interface ReportTaskRunnerHeartbeatOutput {
+    
+    terminate: boolean | undefined;
+}
+export declare namespace ReportTaskRunnerHeartbeatOutput {
+    
+    const filterSensitiveLog: (obj: ReportTaskRunnerHeartbeatOutput) => any;
+}
+
+export interface SetStatusInput {
+    
+    pipelineId: string | undefined;
+    
+    objectIds: string[] | undefined;
+    
+    status: string | undefined;
+}
+export declare namespace SetStatusInput {
+    
+    const filterSensitiveLog: (obj: SetStatusInput) => any;
+}
+export declare enum TaskStatus {
+    FAILED = "FAILED",
+    FALSE = "FALSE",
+    FINISHED = "FINISHED"
+}
+
+export interface SetTaskStatusInput {
+    
+    taskId: string | undefined;
+    
+    taskStatus: TaskStatus | string | undefined;
+    
+    errorId?: string;
+    
+    errorMessage?: string;
+    
+    errorStackTrace?: string;
+}
+export declare namespace SetTaskStatusInput {
+    
+    const filterSensitiveLog: (obj: SetTaskStatusInput) => any;
+}
+
+export interface SetTaskStatusOutput {
+}
+export declare namespace SetTaskStatusOutput {
+    
+    const filterSensitiveLog: (obj: SetTaskStatusOutput) => any;
+}
+
+export interface ValidatePipelineDefinitionInput {
+    
+    pipelineId: string | undefined;
+    
+    pipelineObjects: PipelineObject[] | undefined;
+    
+    parameterObjects?: ParameterObject[];
+    
+    parameterValues?: ParameterValue[];
+}
+export declare namespace ValidatePipelineDefinitionInput {
+    
+    const filterSensitiveLog: (obj: ValidatePipelineDefinitionInput) => any;
+}
+
+export interface ValidatePipelineDefinitionOutput {
+    
+    validationErrors?: ValidationError[];
+    
+    validationWarnings?: ValidationWarning[];
+    
+    errored: boolean | undefined;
+}
+export declare namespace ValidatePipelineDefinitionOutput {
+    
+    const filterSensitiveLog: (obj: ValidatePipelineDefinitionOutput) => any;
+}

package/dist-types/ts3.4/pagination/DescribeObjectsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeObjectsCommandInput, DescribeObjectsCommandOutput } from "../commands/DescribeObjectsCommand";
+import { DataPipelinePaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeObjects(config: DataPipelinePaginationConfiguration, input: DescribeObjectsCommandInput, ...additionalArguments: any): Paginator<DescribeObjectsCommandOutput>;

package/dist-types/ts3.4/pagination/Interfaces.d.ts

@@ -0,0 +1,6 @@
+import { PaginationConfiguration } from "@aws-sdk/types";
+import { DataPipeline } from "../DataPipeline";
+import { DataPipelineClient } from "../DataPipelineClient";
+export interface DataPipelinePaginationConfiguration extends PaginationConfiguration {
+    client: DataPipeline | DataPipelineClient;
+}

package/dist-types/ts3.4/pagination/ListPipelinesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListPipelinesCommandInput, ListPipelinesCommandOutput } from "../commands/ListPipelinesCommand";
+import { DataPipelinePaginationConfiguration } from "./Interfaces";
+export declare function paginateListPipelines(config: DataPipelinePaginationConfiguration, input: ListPipelinesCommandInput, ...additionalArguments: any): Paginator<ListPipelinesCommandOutput>;

package/dist-types/ts3.4/pagination/QueryObjectsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { QueryObjectsCommandInput, QueryObjectsCommandOutput } from "../commands/QueryObjectsCommand";
+import { DataPipelinePaginationConfiguration } from "./Interfaces";
+export declare function paginateQueryObjects(config: DataPipelinePaginationConfiguration, input: QueryObjectsCommandInput, ...additionalArguments: any): Paginator<QueryObjectsCommandOutput>;

package/dist-types/ts3.4/pagination/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./DescribeObjectsPaginator";
+export * from "./Interfaces";
+export * from "./ListPipelinesPaginator";
+export * from "./QueryObjectsPaginator";