import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
import * as outputs from "../types/output";
/**
 * This resource provides the Workspace Task resource in Oracle Cloud Infrastructure Data Integration service.
 * Api doc link for the resource: https://docs.oracle.com/iaas/api/#/en/data-integration/latest/WorkspaceTask
 *
 * Example terraform configs related to the resource : https://github.com/oracle/terraform-provider-oci/tree/master/examples/dataintegration
 *
 * Creates a new task ready for performing data integrations. There are specialized types of tasks that include data loader and integration tasks.
 *
 * ## Example Usage
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as oci from "@pulumi/oci";
 *
 * const testWorkspaceTask = new oci.dataintegration.WorkspaceTask("test_workspace_task", {
 *     identifier: workspaceTaskIdentifier,
 *     modelType: workspaceTaskModelType,
 *     name: workspaceTaskName,
 *     registryMetadata: {
 *         aggregatorKey: workspaceTaskRegistryMetadataAggregatorKey,
 *         isFavorite: workspaceTaskRegistryMetadataIsFavorite === "true",
 *         key: workspaceTaskRegistryMetadataKey,
 *         labels: workspaceTaskRegistryMetadataLabels,
 *         registryVersion: Number(workspaceTaskRegistryMetadataRegistryVersion),
 *     },
 *     workspaceId: testWorkspace.id,
 *     apiCallMode: workspaceTaskApiCallMode,
 *     authConfig: {
 *         key: workspaceTaskAuthConfigKey,
 *         modelType: workspaceTaskAuthConfigModelType,
 *         modelVersion: workspaceTaskAuthConfigModelVersion,
 *         parentRef: {
 *             parent: workspaceTaskAuthConfigParentRefParent,
 *             rootDocId: testRootDoc.id,
 *         },
 *         resourcePrincipalSource: workspaceTaskAuthConfigResourcePrincipalSource,
 *     },
 *     authDetails: [{
 *         key: workspaceTaskAuthDetailsKey,
 *         modelType: workspaceTaskAuthDetailsModelType,
 *         modelVersion: workspaceTaskAuthDetailsModelVersion,
 *         parentRef: [{
 *             parent: workspaceTaskAuthDetailsParentRefParent,
 *             rootDocId: testRootDoc.id,
 *         }],
 *     }],
 *     cancelEndpoint: [{
 *         configValues: [{
 *             configParamValues: [{
 *                 intValue: workspaceTaskCancelEndpointConfigValuesConfigParamValuesIntValue,
 *                 objectValue: workspaceTaskCancelEndpointConfigValuesConfigParamValuesObjectValue,
 *                 parameterValue: workspaceTaskCancelEndpointConfigValuesConfigParamValuesParameterValue,
 *                 refValue: workspaceTaskCancelEndpointConfigValuesConfigParamValuesRefValue,
 *                 rootObjectValue: workspaceTaskCancelEndpointConfigValuesConfigParamValuesRootObjectValue,
 *                 stringValue: workspaceTaskCancelEndpointConfigValuesConfigParamValuesStringValue,
 *             }],
 *             parentRef: [{
 *                 parent: workspaceTaskCancelEndpointConfigValuesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             }],
 *         }],
 *         exprString: workspaceTaskCancelEndpointExprString,
 *         key: workspaceTaskCancelEndpointKey,
 *         modelType: workspaceTaskCancelEndpointModelType,
 *         modelVersion: workspaceTaskCancelEndpointModelVersion,
 *         objectStatus: workspaceTaskCancelEndpointObjectStatus,
 *         parentRef: [{
 *             parent: workspaceTaskCancelEndpointParentRefParent,
 *             rootDocId: testRootDoc.id,
 *         }],
 *     }],
 *     cancelMethodType: workspaceTaskCancelMethodType,
 *     cancelRestCallConfig: {
 *         configValues: {
 *             configParamValues: {
 *                 intValue: workspaceTaskCancelRestCallConfigConfigValuesConfigParamValuesIntValue,
 *                 objectValue: workspaceTaskCancelRestCallConfigConfigValuesConfigParamValuesObjectValue,
 *                 parameterValue: workspaceTaskCancelRestCallConfigConfigValuesConfigParamValuesParameterValue,
 *                 refValue: workspaceTaskCancelRestCallConfigConfigValuesConfigParamValuesRefValue,
 *                 rootObjectValue: workspaceTaskCancelRestCallConfigConfigValuesConfigParamValuesRootObjectValue,
 *                 stringValue: workspaceTaskCancelRestCallConfigConfigValuesConfigParamValuesStringValue,
 *             },
 *             parentRef: {
 *                 parent: workspaceTaskCancelRestCallConfigConfigValuesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             },
 *         },
 *         methodType: workspaceTaskCancelRestCallConfigMethodType,
 *         requestHeaders: workspaceTaskCancelRestCallConfigRequestHeaders,
 *     },
 *     conditionalCompositeFieldMap: [{
 *         configValues: [{
 *             configParamValues: [{
 *                 intValue: workspaceTaskConditionalCompositeFieldMapConfigValuesConfigParamValuesIntValue,
 *                 objectValue: workspaceTaskConditionalCompositeFieldMapConfigValuesConfigParamValuesObjectValue,
 *                 parameterValue: workspaceTaskConditionalCompositeFieldMapConfigValuesConfigParamValuesParameterValue,
 *                 refValue: workspaceTaskConditionalCompositeFieldMapConfigValuesConfigParamValuesRefValue,
 *                 rootObjectValue: workspaceTaskConditionalCompositeFieldMapConfigValuesConfigParamValuesRootObjectValue,
 *                 stringValue: workspaceTaskConditionalCompositeFieldMapConfigValuesConfigParamValuesStringValue,
 *             }],
 *             parentRef: [{
 *                 parent: workspaceTaskConditionalCompositeFieldMapConfigValuesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             }],
 *         }],
 *         description: workspaceTaskConditionalCompositeFieldMapDescription,
 *         fieldMapScope: [{
 *             modelType: workspaceTaskConditionalCompositeFieldMapFieldMapScopeModelType,
 *             configValues: [{
 *                 configParamValues: [{
 *                     intValue: workspaceTaskConditionalCompositeFieldMapFieldMapScopeConfigValuesConfigParamValuesIntValue,
 *                     objectValue: workspaceTaskConditionalCompositeFieldMapFieldMapScopeConfigValuesConfigParamValuesObjectValue,
 *                     parameterValue: workspaceTaskConditionalCompositeFieldMapFieldMapScopeConfigValuesConfigParamValuesParameterValue,
 *                     refValue: workspaceTaskConditionalCompositeFieldMapFieldMapScopeConfigValuesConfigParamValuesRefValue,
 *                     rootObjectValue: workspaceTaskConditionalCompositeFieldMapFieldMapScopeConfigValuesConfigParamValuesRootObjectValue,
 *                     stringValue: workspaceTaskConditionalCompositeFieldMapFieldMapScopeConfigValuesConfigParamValuesStringValue,
 *                 }],
 *                 parentRef: [{
 *                     parent: workspaceTaskConditionalCompositeFieldMapFieldMapScopeConfigValuesParentRefParent,
 *                     rootDocId: testRootDoc.id,
 *                 }],
 *             }],
 *             description: workspaceTaskConditionalCompositeFieldMapFieldMapScopeDescription,
 *             fromName: workspaceTaskConditionalCompositeFieldMapFieldMapScopeFromName,
 *             isCascade: workspaceTaskConditionalCompositeFieldMapFieldMapScopeIsCascade,
 *             isCaseSensitive: workspaceTaskConditionalCompositeFieldMapFieldMapScopeIsCaseSensitive,
 *             isJavaRegexSyntax: workspaceTaskConditionalCompositeFieldMapFieldMapScopeIsJavaRegexSyntax,
 *             isSkipRemainingRulesOnMatch: workspaceTaskConditionalCompositeFieldMapFieldMapScopeIsSkipRemainingRulesOnMatch,
 *             key: workspaceTaskConditionalCompositeFieldMapFieldMapScopeKey,
 *             matchingStrategy: workspaceTaskConditionalCompositeFieldMapFieldMapScopeMatchingStrategy,
 *             modelVersion: workspaceTaskConditionalCompositeFieldMapFieldMapScopeModelVersion,
 *             name: workspaceTaskConditionalCompositeFieldMapFieldMapScopeName,
 *             names: workspaceTaskConditionalCompositeFieldMapFieldMapScopeNames,
 *             objectStatus: workspaceTaskConditionalCompositeFieldMapFieldMapScopeObjectStatus,
 *             parentRef: [{
 *                 parent: workspaceTaskConditionalCompositeFieldMapFieldMapScopeParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             }],
 *             pattern: workspaceTaskConditionalCompositeFieldMapFieldMapScopePattern,
 *             ruleType: workspaceTaskConditionalCompositeFieldMapFieldMapScopeRuleType,
 *             scope: workspaceTaskConditionalCompositeFieldMapFieldMapScopeScope,
 *             toName: workspaceTaskConditionalCompositeFieldMapFieldMapScopeToName,
 *             types: workspaceTaskConditionalCompositeFieldMapFieldMapScopeTypes,
 *         }],
 *         fieldMaps: workspaceTaskConditionalCompositeFieldMapFieldMaps,
 *         key: workspaceTaskConditionalCompositeFieldMapKey,
 *         modelType: workspaceTaskConditionalCompositeFieldMapModelType,
 *         modelVersion: workspaceTaskConditionalCompositeFieldMapModelVersion,
 *         objectStatus: workspaceTaskConditionalCompositeFieldMapObjectStatus,
 *         parentRef: [{
 *             parent: workspaceTaskConditionalCompositeFieldMapParentRefParent,
 *             rootDocId: testRootDoc.id,
 *         }],
 *     }],
 *     configProviderDelegate: {
 *         bindings: [{
 *             rootObjectValue: workspaceTaskConfigProviderDelegateBindingsRootObjectValue,
 *             simpleValue: workspaceTaskConfigProviderDelegateBindingsSimpleValue,
 *         }],
 *     },
 *     dataFlow: [{
 *         description: workspaceTaskDataFlowDescription,
 *         flowConfigValues: [{
 *             configParamValues: [{
 *                 intValue: workspaceTaskDataFlowFlowConfigValuesConfigParamValuesIntValue,
 *                 objectValue: workspaceTaskDataFlowFlowConfigValuesConfigParamValuesObjectValue,
 *                 parameterValue: workspaceTaskDataFlowFlowConfigValuesConfigParamValuesParameterValue,
 *                 refValue: workspaceTaskDataFlowFlowConfigValuesConfigParamValuesRefValue,
 *                 rootObjectValue: workspaceTaskDataFlowFlowConfigValuesConfigParamValuesRootObjectValue,
 *                 stringValue: workspaceTaskDataFlowFlowConfigValuesConfigParamValuesStringValue,
 *             }],
 *             parentRef: [{
 *                 parent: workspaceTaskDataFlowFlowConfigValuesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             }],
 *         }],
 *         identifier: workspaceTaskDataFlowIdentifier,
 *         key: workspaceTaskDataFlowKey,
 *         keyMap: workspaceTaskDataFlowKeyMap,
 *         metadata: [{
 *             aggregator: [{
 *                 description: workspaceTaskDataFlowMetadataAggregatorDescription,
 *                 identifier: workspaceTaskDataFlowMetadataAggregatorIdentifier,
 *                 key: workspaceTaskDataFlowMetadataAggregatorKey,
 *                 name: workspaceTaskDataFlowMetadataAggregatorName,
 *                 type: workspaceTaskDataFlowMetadataAggregatorType,
 *             }],
 *             aggregatorKey: workspaceTaskDataFlowMetadataAggregatorKey,
 *             countStatistics: [{
 *                 objectTypeCountList: [{
 *                     objectCount: workspaceTaskDataFlowMetadataCountStatisticsObjectTypeCountListObjectCount,
 *                     objectType: workspaceTaskDataFlowMetadataCountStatisticsObjectTypeCountListObjectType,
 *                 }],
 *             }],
 *             createdBy: workspaceTaskDataFlowMetadataCreatedBy,
 *             createdByName: workspaceTaskDataFlowMetadataCreatedByName,
 *             identifierPath: workspaceTaskDataFlowMetadataIdentifierPath,
 *             infoFields: workspaceTaskDataFlowMetadataInfoFields,
 *             isFavorite: workspaceTaskDataFlowMetadataIsFavorite,
 *             labels: workspaceTaskDataFlowMetadataLabels,
 *             registryVersion: workspaceTaskDataFlowMetadataRegistryVersion,
 *             timeCreated: workspaceTaskDataFlowMetadataTimeCreated,
 *             timeUpdated: workspaceTaskDataFlowMetadataTimeUpdated,
 *             updatedBy: workspaceTaskDataFlowMetadataUpdatedBy,
 *             updatedByName: workspaceTaskDataFlowMetadataUpdatedByName,
 *         }],
 *         modelType: workspaceTaskDataFlowModelType,
 *         modelVersion: workspaceTaskDataFlowModelVersion,
 *         name: workspaceTaskDataFlowName,
 *         nodes: [{
 *             configProviderDelegate: workspaceTaskDataFlowNodesConfigProviderDelegate,
 *             description: workspaceTaskDataFlowNodesDescription,
 *             inputLinks: [{
 *                 description: workspaceTaskDataFlowNodesInputLinksDescription,
 *                 fieldMap: workspaceTaskDataFlowNodesInputLinksFieldMap,
 *                 fromLink: workspaceTaskDataFlowNodesInputLinksFromLink,
 *                 key: workspaceTaskDataFlowNodesInputLinksKey,
 *                 modelType: workspaceTaskDataFlowNodesInputLinksModelType,
 *                 modelVersion: workspaceTaskDataFlowNodesInputLinksModelVersion,
 *                 objectStatus: workspaceTaskDataFlowNodesInputLinksObjectStatus,
 *                 parentRef: [{
 *                     parent: workspaceTaskDataFlowNodesInputLinksParentRefParent,
 *                     rootDocId: testRootDoc.id,
 *                 }],
 *                 port: workspaceTaskDataFlowNodesInputLinksPort,
 *             }],
 *             key: workspaceTaskDataFlowNodesKey,
 *             modelType: workspaceTaskDataFlowNodesModelType,
 *             modelVersion: workspaceTaskDataFlowNodesModelVersion,
 *             name: workspaceTaskDataFlowNodesName,
 *             objectStatus: workspaceTaskDataFlowNodesObjectStatus,
 *             operator: workspaceTaskDataFlowNodesOperator,
 *             outputLinks: [{
 *                 description: workspaceTaskDataFlowNodesOutputLinksDescription,
 *                 key: workspaceTaskDataFlowNodesOutputLinksKey,
 *                 modelType: workspaceTaskDataFlowNodesOutputLinksModelType,
 *                 modelVersion: workspaceTaskDataFlowNodesOutputLinksModelVersion,
 *                 objectStatus: workspaceTaskDataFlowNodesOutputLinksObjectStatus,
 *                 parentRef: [{
 *                     parent: workspaceTaskDataFlowNodesOutputLinksParentRefParent,
 *                     rootDocId: testRootDoc.id,
 *                 }],
 *                 port: workspaceTaskDataFlowNodesOutputLinksPort,
 *                 toLinks: workspaceTaskDataFlowNodesOutputLinksToLinks,
 *             }],
 *             parentRef: [{
 *                 parent: workspaceTaskDataFlowNodesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             }],
 *             uiProperties: [{
 *                 coordinateX: workspaceTaskDataFlowNodesUiPropertiesCoordinateX,
 *                 coordinateY: workspaceTaskDataFlowNodesUiPropertiesCoordinateY,
 *             }],
 *         }],
 *         objectStatus: workspaceTaskDataFlowObjectStatus,
 *         objectVersion: workspaceTaskDataFlowObjectVersion,
 *         parameters: [{
 *             configValues: [{
 *                 configParamValues: [{
 *                     intValue: workspaceTaskDataFlowParametersConfigValuesConfigParamValuesIntValue,
 *                     objectValue: workspaceTaskDataFlowParametersConfigValuesConfigParamValuesObjectValue,
 *                     parameterValue: workspaceTaskDataFlowParametersConfigValuesConfigParamValuesParameterValue,
 *                     refValue: workspaceTaskDataFlowParametersConfigValuesConfigParamValuesRefValue,
 *                     rootObjectValue: workspaceTaskDataFlowParametersConfigValuesConfigParamValuesRootObjectValue,
 *                     stringValue: workspaceTaskDataFlowParametersConfigValuesConfigParamValuesStringValue,
 *                 }],
 *                 parentRef: [{
 *                     parent: workspaceTaskDataFlowParametersConfigValuesParentRefParent,
 *                     rootDocId: testRootDoc.id,
 *                 }],
 *             }],
 *             defaultValue: workspaceTaskDataFlowParametersDefaultValue,
 *             description: workspaceTaskDataFlowParametersDescription,
 *             isInput: workspaceTaskDataFlowParametersIsInput,
 *             isOutput: workspaceTaskDataFlowParametersIsOutput,
 *             key: workspaceTaskDataFlowParametersKey,
 *             modelType: workspaceTaskDataFlowParametersModelType,
 *             modelVersion: workspaceTaskDataFlowParametersModelVersion,
 *             name: workspaceTaskDataFlowParametersName,
 *             objectStatus: workspaceTaskDataFlowParametersObjectStatus,
 *             outputAggregationType: workspaceTaskDataFlowParametersOutputAggregationType,
 *             parentRef: [{
 *                 parent: workspaceTaskDataFlowParametersParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             }],
 *             rootObjectDefaultValue: workspaceTaskDataFlowParametersRootObjectDefaultValue,
 *             type: workspaceTaskDataFlowParametersType,
 *             typeName: workspaceTaskDataFlowParametersTypeName,
 *             usedFor: workspaceTaskDataFlowParametersUsedFor,
 *         }],
 *         parentRef: [{
 *             parent: workspaceTaskDataFlowParentRefParent,
 *             rootDocId: testRootDoc.id,
 *         }],
 *         targetFieldMapSummary: [{
 *             fieldMap: workspaceTaskDataFlowTargetFieldMapSummaryFieldMap,
 *         }],
 *         typedObjectMap: [{
 *             typedObject: workspaceTaskDataFlowTypedObjectMapTypedObject,
 *         }],
 *     }],
 *     dataflowApplication: [{
 *         applicationId: testApplication.id,
 *         compartmentId: compartmentId,
 *         configValues: [{
 *             configParamValues: [{
 *                 intValue: workspaceTaskDataflowApplicationConfigValuesConfigParamValuesIntValue,
 *                 objectValue: workspaceTaskDataflowApplicationConfigValuesConfigParamValuesObjectValue,
 *                 parameterValue: workspaceTaskDataflowApplicationConfigValuesConfigParamValuesParameterValue,
 *                 refValue: workspaceTaskDataflowApplicationConfigValuesConfigParamValuesRefValue,
 *                 rootObjectValue: workspaceTaskDataflowApplicationConfigValuesConfigParamValuesRootObjectValue,
 *                 stringValue: workspaceTaskDataflowApplicationConfigValuesConfigParamValuesStringValue,
 *             }],
 *             parentRef: [{
 *                 parent: workspaceTaskDataflowApplicationConfigValuesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             }],
 *         }],
 *     }],
 *     description: workspaceTaskDescription,
 *     endpoint: [{
 *         configValues: [{
 *             configParamValues: [{
 *                 intValue: workspaceTaskEndpointConfigValuesConfigParamValuesIntValue,
 *                 objectValue: workspaceTaskEndpointConfigValuesConfigParamValuesObjectValue,
 *                 parameterValue: workspaceTaskEndpointConfigValuesConfigParamValuesParameterValue,
 *                 refValue: workspaceTaskEndpointConfigValuesConfigParamValuesRefValue,
 *                 rootObjectValue: workspaceTaskEndpointConfigValuesConfigParamValuesRootObjectValue,
 *                 stringValue: workspaceTaskEndpointConfigValuesConfigParamValuesStringValue,
 *             }],
 *             parentRef: [{
 *                 parent: workspaceTaskEndpointConfigValuesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             }],
 *         }],
 *         exprString: workspaceTaskEndpointExprString,
 *         key: workspaceTaskEndpointKey,
 *         modelType: workspaceTaskEndpointModelType,
 *         modelVersion: workspaceTaskEndpointModelVersion,
 *         objectStatus: workspaceTaskEndpointObjectStatus,
 *         parentRef: [{
 *             parent: workspaceTaskEndpointParentRefParent,
 *             rootDocId: testRootDoc.id,
 *         }],
 *     }],
 *     executeRestCallConfig: {
 *         configValues: {
 *             configParamValues: {
 *                 intValue: workspaceTaskExecuteRestCallConfigConfigValuesConfigParamValuesIntValue,
 *                 objectValue: workspaceTaskExecuteRestCallConfigConfigValuesConfigParamValuesObjectValue,
 *                 parameterValue: workspaceTaskExecuteRestCallConfigConfigValuesConfigParamValuesParameterValue,
 *                 refValue: workspaceTaskExecuteRestCallConfigConfigValuesConfigParamValuesRefValue,
 *                 rootObjectValue: workspaceTaskExecuteRestCallConfigConfigValuesConfigParamValuesRootObjectValue,
 *                 stringValue: workspaceTaskExecuteRestCallConfigConfigValuesConfigParamValuesStringValue,
 *             },
 *             parentRef: {
 *                 parent: workspaceTaskExecuteRestCallConfigConfigValuesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             },
 *         },
 *         methodType: workspaceTaskExecuteRestCallConfigMethodType,
 *         requestHeaders: workspaceTaskExecuteRestCallConfigRequestHeaders,
 *     },
 *     headers: workspaceTaskHeaders,
 *     inputPorts: [{
 *         modelType: workspaceTaskInputPortsModelType,
 *         configValues: {
 *             configParamValues: {
 *                 intValue: Number(workspaceTaskInputPortsConfigValuesConfigParamValuesIntValue),
 *                 objectValue: workspaceTaskInputPortsConfigValuesConfigParamValuesObjectValue,
 *                 parameterValue: workspaceTaskInputPortsConfigValuesConfigParamValuesParameterValue,
 *                 refValue: workspaceTaskInputPortsConfigValuesConfigParamValuesRefValue,
 *                 rootObjectValue: workspaceTaskInputPortsConfigValuesConfigParamValuesRootObjectValue,
 *                 stringValue: workspaceTaskInputPortsConfigValuesConfigParamValuesStringValue,
 *             },
 *             parentRef: {
 *                 parent: workspaceTaskInputPortsConfigValuesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             },
 *         },
 *         description: workspaceTaskInputPortsDescription,
 *         fields: workspaceTaskInputPortsFields,
 *         key: workspaceTaskInputPortsKey,
 *         modelVersion: workspaceTaskInputPortsModelVersion,
 *         name: workspaceTaskInputPortsName,
 *         objectStatus: Number(workspaceTaskInputPortsObjectStatus),
 *         parentRef: {
 *             parent: workspaceTaskInputPortsParentRefParent,
 *             rootDocId: testRootDoc.id,
 *         },
 *         portType: workspaceTaskInputPortsPortType,
 *     }],
 *     isSingleLoad: workspaceTaskIsSingleLoad === "true",
 *     jsonData: workspaceTaskJsonData,
 *     key: workspaceTaskKey,
 *     methodType: workspaceTaskMethodType,
 *     modelVersion: workspaceTaskModelVersion,
 *     objectStatus: Number(workspaceTaskObjectStatus),
 *     opConfigValues: {
 *         configParamValues: {
 *             intValue: workspaceTaskOpConfigValuesConfigParamValuesIntValue,
 *             objectValue: workspaceTaskOpConfigValuesConfigParamValuesObjectValue,
 *             parameterValue: workspaceTaskOpConfigValuesConfigParamValuesParameterValue,
 *             refValue: workspaceTaskOpConfigValuesConfigParamValuesRefValue,
 *             rootObjectValue: workspaceTaskOpConfigValuesConfigParamValuesRootObjectValue,
 *             stringValue: workspaceTaskOpConfigValuesConfigParamValuesStringValue,
 *         },
 *         parentRef: {
 *             parent: workspaceTaskOpConfigValuesParentRefParent,
 *             rootDocId: testRootDoc.id,
 *         },
 *     },
 *     operation: workspaceTaskOperation,
 *     outputPorts: [{
 *         modelType: workspaceTaskOutputPortsModelType,
 *         configValues: {
 *             configParamValues: {
 *                 intValue: Number(workspaceTaskOutputPortsConfigValuesConfigParamValuesIntValue),
 *                 objectValue: workspaceTaskOutputPortsConfigValuesConfigParamValuesObjectValue,
 *                 parameterValue: workspaceTaskOutputPortsConfigValuesConfigParamValuesParameterValue,
 *                 refValue: workspaceTaskOutputPortsConfigValuesConfigParamValuesRefValue,
 *                 rootObjectValue: workspaceTaskOutputPortsConfigValuesConfigParamValuesRootObjectValue,
 *                 stringValue: workspaceTaskOutputPortsConfigValuesConfigParamValuesStringValue,
 *             },
 *             parentRef: {
 *                 parent: workspaceTaskOutputPortsConfigValuesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             },
 *         },
 *         description: workspaceTaskOutputPortsDescription,
 *         fields: workspaceTaskOutputPortsFields,
 *         key: workspaceTaskOutputPortsKey,
 *         modelVersion: workspaceTaskOutputPortsModelVersion,
 *         name: workspaceTaskOutputPortsName,
 *         objectStatus: Number(workspaceTaskOutputPortsObjectStatus),
 *         parentRef: {
 *             parent: workspaceTaskOutputPortsParentRefParent,
 *             rootDocId: testRootDoc.id,
 *         },
 *         portType: workspaceTaskOutputPortsPortType,
 *     }],
 *     parallelLoadLimit: Number(workspaceTaskParallelLoadLimit),
 *     parameters: [{
 *         modelType: workspaceTaskParametersModelType,
 *         configValues: {
 *             configParamValues: {
 *                 intValue: workspaceTaskParametersConfigValuesConfigParamValuesIntValue,
 *                 objectValue: workspaceTaskParametersConfigValuesConfigParamValuesObjectValue,
 *                 parameterValue: workspaceTaskParametersConfigValuesConfigParamValuesParameterValue,
 *                 refValue: workspaceTaskParametersConfigValuesConfigParamValuesRefValue,
 *                 rootObjectValue: workspaceTaskParametersConfigValuesConfigParamValuesRootObjectValue,
 *                 stringValue: workspaceTaskParametersConfigValuesConfigParamValuesStringValue,
 *             },
 *             parentRef: {
 *                 parent: workspaceTaskParametersConfigValuesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             },
 *         },
 *         defaultValue: workspaceTaskParametersDefaultValue,
 *         description: workspaceTaskParametersDescription,
 *         isInput: workspaceTaskParametersIsInput === "true",
 *         isOutput: workspaceTaskParametersIsOutput === "true",
 *         key: workspaceTaskParametersKey,
 *         modelVersion: workspaceTaskParametersModelVersion,
 *         name: workspaceTaskParametersName,
 *         objectStatus: Number(workspaceTaskParametersObjectStatus),
 *         outputAggregationType: workspaceTaskParametersOutputAggregationType,
 *         parentRef: {
 *             parent: workspaceTaskParametersParentRefParent,
 *             rootDocId: testRootDoc.id,
 *         },
 *         rootObjectDefaultValue: workspaceTaskParametersRootObjectDefaultValue,
 *         type: workspaceTaskParametersType,
 *         typeName: workspaceTaskParametersTypeName,
 *         usedFor: workspaceTaskParametersUsedFor,
 *     }],
 *     parentRef: {
 *         parent: workspaceTaskParentRefParent,
 *         rootDocId: testRootDoc.id,
 *     },
 *     pipeline: [{
 *         description: workspaceTaskPipelineDescription,
 *         flowConfigValues: [{
 *             configParamValues: [{
 *                 intValue: workspaceTaskPipelineFlowConfigValuesConfigParamValuesIntValue,
 *                 objectValue: workspaceTaskPipelineFlowConfigValuesConfigParamValuesObjectValue,
 *                 parameterValue: workspaceTaskPipelineFlowConfigValuesConfigParamValuesParameterValue,
 *                 refValue: workspaceTaskPipelineFlowConfigValuesConfigParamValuesRefValue,
 *                 rootObjectValue: workspaceTaskPipelineFlowConfigValuesConfigParamValuesRootObjectValue,
 *                 stringValue: workspaceTaskPipelineFlowConfigValuesConfigParamValuesStringValue,
 *             }],
 *             parentRef: [{
 *                 parent: workspaceTaskPipelineFlowConfigValuesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             }],
 *         }],
 *         identifier: workspaceTaskPipelineIdentifier,
 *         key: workspaceTaskPipelineKey,
 *         metadata: [{
 *             aggregator: [{
 *                 description: workspaceTaskPipelineMetadataAggregatorDescription,
 *                 identifier: workspaceTaskPipelineMetadataAggregatorIdentifier,
 *                 key: workspaceTaskPipelineMetadataAggregatorKey,
 *                 name: workspaceTaskPipelineMetadataAggregatorName,
 *                 type: workspaceTaskPipelineMetadataAggregatorType,
 *             }],
 *             aggregatorKey: workspaceTaskPipelineMetadataAggregatorKey,
 *             countStatistics: [{
 *                 objectTypeCountList: [{
 *                     objectCount: workspaceTaskPipelineMetadataCountStatisticsObjectTypeCountListObjectCount,
 *                     objectType: workspaceTaskPipelineMetadataCountStatisticsObjectTypeCountListObjectType,
 *                 }],
 *             }],
 *             createdBy: workspaceTaskPipelineMetadataCreatedBy,
 *             createdByName: workspaceTaskPipelineMetadataCreatedByName,
 *             identifierPath: workspaceTaskPipelineMetadataIdentifierPath,
 *             infoFields: workspaceTaskPipelineMetadataInfoFields,
 *             isFavorite: workspaceTaskPipelineMetadataIsFavorite,
 *             labels: workspaceTaskPipelineMetadataLabels,
 *             registryVersion: workspaceTaskPipelineMetadataRegistryVersion,
 *             timeCreated: workspaceTaskPipelineMetadataTimeCreated,
 *             timeUpdated: workspaceTaskPipelineMetadataTimeUpdated,
 *             updatedBy: workspaceTaskPipelineMetadataUpdatedBy,
 *             updatedByName: workspaceTaskPipelineMetadataUpdatedByName,
 *         }],
 *         modelType: workspaceTaskPipelineModelType,
 *         modelVersion: workspaceTaskPipelineModelVersion,
 *         name: workspaceTaskPipelineName,
 *         nodes: [{
 *             configProviderDelegate: workspaceTaskPipelineNodesConfigProviderDelegate,
 *             description: workspaceTaskPipelineNodesDescription,
 *             inputLinks: [{
 *                 description: workspaceTaskPipelineNodesInputLinksDescription,
 *                 fieldMap: workspaceTaskPipelineNodesInputLinksFieldMap,
 *                 fromLink: workspaceTaskPipelineNodesInputLinksFromLink,
 *                 key: workspaceTaskPipelineNodesInputLinksKey,
 *                 modelType: workspaceTaskPipelineNodesInputLinksModelType,
 *                 modelVersion: workspaceTaskPipelineNodesInputLinksModelVersion,
 *                 objectStatus: workspaceTaskPipelineNodesInputLinksObjectStatus,
 *                 parentRef: [{
 *                     parent: workspaceTaskPipelineNodesInputLinksParentRefParent,
 *                     rootDocId: testRootDoc.id,
 *                 }],
 *                 port: workspaceTaskPipelineNodesInputLinksPort,
 *             }],
 *             key: workspaceTaskPipelineNodesKey,
 *             modelType: workspaceTaskPipelineNodesModelType,
 *             modelVersion: workspaceTaskPipelineNodesModelVersion,
 *             name: workspaceTaskPipelineNodesName,
 *             objectStatus: workspaceTaskPipelineNodesObjectStatus,
 *             operator: workspaceTaskPipelineNodesOperator,
 *             outputLinks: [{
 *                 description: workspaceTaskPipelineNodesOutputLinksDescription,
 *                 key: workspaceTaskPipelineNodesOutputLinksKey,
 *                 modelType: workspaceTaskPipelineNodesOutputLinksModelType,
 *                 modelVersion: workspaceTaskPipelineNodesOutputLinksModelVersion,
 *                 objectStatus: workspaceTaskPipelineNodesOutputLinksObjectStatus,
 *                 parentRef: [{
 *                     parent: workspaceTaskPipelineNodesOutputLinksParentRefParent,
 *                     rootDocId: testRootDoc.id,
 *                 }],
 *                 port: workspaceTaskPipelineNodesOutputLinksPort,
 *                 toLinks: workspaceTaskPipelineNodesOutputLinksToLinks,
 *             }],
 *             parentRef: [{
 *                 parent: workspaceTaskPipelineNodesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             }],
 *             uiProperties: [{
 *                 coordinateX: workspaceTaskPipelineNodesUiPropertiesCoordinateX,
 *                 coordinateY: workspaceTaskPipelineNodesUiPropertiesCoordinateY,
 *             }],
 *         }],
 *         objectStatus: workspaceTaskPipelineObjectStatus,
 *         objectVersion: workspaceTaskPipelineObjectVersion,
 *         parameters: [{
 *             configValues: [{
 *                 configParamValues: [{
 *                     intValue: workspaceTaskPipelineParametersConfigValuesConfigParamValuesIntValue,
 *                     objectValue: workspaceTaskPipelineParametersConfigValuesConfigParamValuesObjectValue,
 *                     parameterValue: workspaceTaskPipelineParametersConfigValuesConfigParamValuesParameterValue,
 *                     refValue: workspaceTaskPipelineParametersConfigValuesConfigParamValuesRefValue,
 *                     rootObjectValue: workspaceTaskPipelineParametersConfigValuesConfigParamValuesRootObjectValue,
 *                     stringValue: workspaceTaskPipelineParametersConfigValuesConfigParamValuesStringValue,
 *                 }],
 *                 parentRef: [{
 *                     parent: workspaceTaskPipelineParametersConfigValuesParentRefParent,
 *                     rootDocId: testRootDoc.id,
 *                 }],
 *             }],
 *             defaultValue: workspaceTaskPipelineParametersDefaultValue,
 *             description: workspaceTaskPipelineParametersDescription,
 *             isInput: workspaceTaskPipelineParametersIsInput,
 *             isOutput: workspaceTaskPipelineParametersIsOutput,
 *             key: workspaceTaskPipelineParametersKey,
 *             modelType: workspaceTaskPipelineParametersModelType,
 *             modelVersion: workspaceTaskPipelineParametersModelVersion,
 *             name: workspaceTaskPipelineParametersName,
 *             objectStatus: workspaceTaskPipelineParametersObjectStatus,
 *             outputAggregationType: workspaceTaskPipelineParametersOutputAggregationType,
 *             parentRef: [{
 *                 parent: workspaceTaskPipelineParametersParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             }],
 *             rootObjectDefaultValue: workspaceTaskPipelineParametersRootObjectDefaultValue,
 *             type: workspaceTaskPipelineParametersType,
 *             typeName: workspaceTaskPipelineParametersTypeName,
 *             usedFor: workspaceTaskPipelineParametersUsedFor,
 *         }],
 *         parentRef: [{
 *             parent: workspaceTaskPipelineParentRefParent,
 *             rootDocId: testRootDoc.id,
 *         }],
 *         variables: [{
 *             configValues: [{
 *                 configParamValues: [{
 *                     intValue: workspaceTaskPipelineVariablesConfigValuesConfigParamValuesIntValue,
 *                     objectValue: workspaceTaskPipelineVariablesConfigValuesConfigParamValuesObjectValue,
 *                     parameterValue: workspaceTaskPipelineVariablesConfigValuesConfigParamValuesParameterValue,
 *                     refValue: workspaceTaskPipelineVariablesConfigValuesConfigParamValuesRefValue,
 *                     rootObjectValue: workspaceTaskPipelineVariablesConfigValuesConfigParamValuesRootObjectValue,
 *                     stringValue: workspaceTaskPipelineVariablesConfigValuesConfigParamValuesStringValue,
 *                 }],
 *                 parentRef: [{
 *                     parent: workspaceTaskPipelineVariablesConfigValuesParentRefParent,
 *                     rootDocId: testRootDoc.id,
 *                 }],
 *             }],
 *             defaultValue: workspaceTaskPipelineVariablesDefaultValue,
 *             description: workspaceTaskPipelineVariablesDescription,
 *             identifier: workspaceTaskPipelineVariablesIdentifier,
 *             key: workspaceTaskPipelineVariablesKey,
 *             modelType: workspaceTaskPipelineVariablesModelType,
 *             modelVersion: workspaceTaskPipelineVariablesModelVersion,
 *             name: workspaceTaskPipelineVariablesName,
 *             objectStatus: workspaceTaskPipelineVariablesObjectStatus,
 *             objectVersion: workspaceTaskPipelineVariablesObjectVersion,
 *             parentRef: [{
 *                 parent: workspaceTaskPipelineVariablesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             }],
 *             rootObjectDefaultValue: [{
 *                 key: workspaceTaskPipelineVariablesRootObjectDefaultValueKey,
 *                 modelType: workspaceTaskPipelineVariablesRootObjectDefaultValueModelType,
 *                 modelVersion: workspaceTaskPipelineVariablesRootObjectDefaultValueModelVersion,
 *                 objectStatus: workspaceTaskPipelineVariablesRootObjectDefaultValueObjectStatus,
 *                 parentRef: [{
 *                     parent: workspaceTaskPipelineVariablesRootObjectDefaultValueParentRefParent,
 *                     rootDocId: testRootDoc.id,
 *                 }],
 *             }],
 *             type: workspaceTaskPipelineVariablesType,
 *         }],
 *     }],
 *     pollRestCallConfig: {
 *         configValues: {
 *             configParamValues: {
 *                 intValue: workspaceTaskPollRestCallConfigConfigValuesConfigParamValuesIntValue,
 *                 objectValue: workspaceTaskPollRestCallConfigConfigValuesConfigParamValuesObjectValue,
 *                 parameterValue: workspaceTaskPollRestCallConfigConfigValuesConfigParamValuesParameterValue,
 *                 refValue: workspaceTaskPollRestCallConfigConfigValuesConfigParamValuesRefValue,
 *                 rootObjectValue: workspaceTaskPollRestCallConfigConfigValuesConfigParamValuesRootObjectValue,
 *                 stringValue: workspaceTaskPollRestCallConfigConfigValuesConfigParamValuesStringValue,
 *             },
 *             parentRef: {
 *                 parent: workspaceTaskPollRestCallConfigConfigValuesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             },
 *         },
 *         methodType: workspaceTaskPollRestCallConfigMethodType,
 *         requestHeaders: workspaceTaskPollRestCallConfigRequestHeaders,
 *     },
 *     script: [{
 *         key: workspaceTaskScriptKey,
 *         modelType: workspaceTaskScriptModelType,
 *         modelVersion: workspaceTaskScriptModelVersion,
 *         objectStatus: workspaceTaskScriptObjectStatus,
 *         parentRef: [{
 *             parent: workspaceTaskScriptParentRefParent,
 *             rootDocId: testRootDoc.id,
 *         }],
 *     }],
 *     sqlScriptType: workspaceTaskSqlScriptType,
 *     typedExpressions: [{
 *         configValues: {
 *             configParamValues: {
 *                 intValue: workspaceTaskTypedExpressionsConfigValuesConfigParamValuesIntValue,
 *                 objectValue: workspaceTaskTypedExpressionsConfigValuesConfigParamValuesObjectValue,
 *                 parameterValue: workspaceTaskTypedExpressionsConfigValuesConfigParamValuesParameterValue,
 *                 refValue: workspaceTaskTypedExpressionsConfigValuesConfigParamValuesRefValue,
 *                 rootObjectValue: workspaceTaskTypedExpressionsConfigValuesConfigParamValuesRootObjectValue,
 *                 stringValue: workspaceTaskTypedExpressionsConfigValuesConfigParamValuesStringValue,
 *             },
 *             parentRef: {
 *                 parent: workspaceTaskTypedExpressionsConfigValuesParentRefParent,
 *                 rootDocId: testRootDoc.id,
 *             },
 *         },
 *         description: workspaceTaskTypedExpressionsDescription,
 *         expression: workspaceTaskTypedExpressionsExpression,
 *         key: workspaceTaskTypedExpressionsKey,
 *         modelType: workspaceTaskTypedExpressionsModelType,
 *         modelVersion: workspaceTaskTypedExpressionsModelVersion,
 *         name: workspaceTaskTypedExpressionsName,
 *         objectStatus: Number(workspaceTaskTypedExpressionsObjectStatus),
 *         parentRef: {
 *             parent: workspaceTaskTypedExpressionsParentRefParent,
 *             rootDocId: testRootDoc.id,
 *         },
 *         type: workspaceTaskTypedExpressionsType,
 *     }],
 * });
 * ```
 *
 * ## Import
 *
 * WorkspaceTasks can be imported using the `id`, e.g.
 *
 * ```sh
 * $ pulumi import oci:DataIntegration/workspaceTask:WorkspaceTask test_workspace_task "workspaces/{workspaceId}/tasks/{taskKey}"
 * ```
 */
export declare class WorkspaceTask extends pulumi.CustomResource {
    /**
     * Get an existing WorkspaceTask resource's state with the given name, ID, and optional extra
     * properties used to qualify the lookup.
     *
     * @param name The _unique_ name of the resulting resource.
     * @param id The _unique_ provider ID of the resource to lookup.
     * @param state Any extra arguments used during the lookup.
     * @param opts Optional settings to control the behavior of the CustomResource.
     */
    static get(name: string, id: pulumi.Input<pulumi.ID>, state?: WorkspaceTaskState, opts?: pulumi.CustomResourceOptions): WorkspaceTask;
    /**
     * Returns true if the given object is an instance of WorkspaceTask.  This is designed to work even
     * when multiple copies of the Pulumi SDK have been loaded into the same process.
     */
    static isInstance(obj: any): obj is WorkspaceTask;
    /**
     * (Updatable) The REST invocation pattern to use. ASYNC_OCI_WORKREQUEST is being deprecated as well as cancelEndpoint/MethodType.
     */
    readonly apiCallMode: pulumi.Output<string>;
    /**
     * (Updatable) Authentication configuration for Generic REST invocation.
     */
    readonly authConfig: pulumi.Output<outputs.DataIntegration.WorkspaceTaskAuthConfig>;
    /**
     * (Updatable) The REST API configuration for cancelling the task.
     */
    readonly cancelRestCallConfig: pulumi.Output<outputs.DataIntegration.WorkspaceTaskCancelRestCallConfig>;
    /**
     * (Updatable) The type to create a config provider.
     */
    readonly configProviderDelegate: pulumi.Output<outputs.DataIntegration.WorkspaceTaskConfigProviderDelegate>;
    /**
     * (Updatable) Detailed description for the object.
     */
    readonly description: pulumi.Output<string>;
    /**
     * (Updatable) The REST API configuration for execution.
     */
    readonly executeRestCallConfig: pulumi.Output<outputs.DataIntegration.WorkspaceTaskExecuteRestCallConfig>;
    /**
     * (Updatable) Value can only contain upper case letters, underscore, and numbers. It should begin with upper case letter or underscore. The value can be modified.
     */
    readonly identifier: pulumi.Output<string>;
    /**
     * (Updatable) An array of input ports.
     */
    readonly inputPorts: pulumi.Output<outputs.DataIntegration.WorkspaceTaskInputPort[]>;
    /**
     * (Updatable) Defines whether Data Loader task is used for single load or multiple
     */
    readonly isSingleLoad: pulumi.Output<boolean>;
    /**
     * (Updatable) Generated key that can be used in API calls to identify task. On scenarios where reference to the task is needed, a value can be passed in create.
     */
    readonly key: pulumi.Output<string>;
    /**
     * A key map. If provided, key is replaced with generated key. This structure provides mapping between user provided key and generated key.
     */
    readonly keyMap: pulumi.Output<{
        [key: string]: string;
    }>;
    /**
     * A summary type containing information about the object including its key, name and when/who created/updated it.
     */
    readonly metadatas: pulumi.Output<outputs.DataIntegration.WorkspaceTaskMetadata[]>;
    /**
     * (Updatable) The type of the task.
     */
    readonly modelType: pulumi.Output<string>;
    /**
     * (Updatable) The object's model version.
     */
    readonly modelVersion: pulumi.Output<string>;
    /**
     * (Updatable) Free form text without any restriction on permitted characters. Name can have letters, numbers, and special characters. The value is editable and is restricted to 1000 characters.
     */
    readonly name: pulumi.Output<string>;
    /**
     * (Updatable) The status of an object that can be set to value 1 for shallow references across objects, other values reserved.
     */
    readonly objectStatus: pulumi.Output<number>;
    /**
     * This is used by the service for optimistic locking of the object, to prevent multiple users from simultaneously updating the object.
     */
    readonly objectVersion: pulumi.Output<number>;
    /**
     * (Updatable) Configuration values can be string, objects, or parameters.
     */
    readonly opConfigValues: pulumi.Output<outputs.DataIntegration.WorkspaceTaskOpConfigValues>;
    /**
     * (Updatable) Describes the shape of the execution result
     */
    readonly operation: pulumi.Output<string>;
    /**
     * (Updatable) An array of output ports.
     */
    readonly outputPorts: pulumi.Output<outputs.DataIntegration.WorkspaceTaskOutputPort[]>;
    /**
     * (Updatable) Defines the number of entities being loaded in parallel at a time for a Data Loader task
     */
    readonly parallelLoadLimit: pulumi.Output<number>;
    /**
     * (Updatable) An array of parameters.
     */
    readonly parameters: pulumi.Output<outputs.DataIntegration.WorkspaceTaskParameter[]>;
    /**
     * (Updatable) A reference to the object's parent.
     */
    readonly parentRef: pulumi.Output<outputs.DataIntegration.WorkspaceTaskParentRef>;
    /**
     * (Updatable) The REST API configuration for polling.
     */
    readonly pollRestCallConfig: pulumi.Output<outputs.DataIntegration.WorkspaceTaskPollRestCallConfig>;
    /**
     * (Updatable) Information about the object and its parent.
     */
    readonly registryMetadata: pulumi.Output<outputs.DataIntegration.WorkspaceTaskRegistryMetadata>;
    /**
     * (Updatable) List of typed expressions.
     */
    readonly typedExpressions: pulumi.Output<outputs.DataIntegration.WorkspaceTaskTypedExpression[]>;
    /**
     * The workspace ID.
     *
     *
     * ** IMPORTANT **
     * Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
     */
    readonly workspaceId: pulumi.Output<string>;
    /**
     * Create a WorkspaceTask resource with the given unique name, arguments, and options.
     *
     * @param name The _unique_ name of the resource.
     * @param args The arguments to use to populate this resource's properties.
     * @param opts A bag of options that control this resource's behavior.
     */
    constructor(name: string, args: WorkspaceTaskArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering WorkspaceTask resources.
 */
export interface WorkspaceTaskState {
    /**
     * (Updatable) The REST invocation pattern to use. ASYNC_OCI_WORKREQUEST is being deprecated as well as cancelEndpoint/MethodType.
     */
    apiCallMode?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) Authentication configuration for Generic REST invocation.
     */
    authConfig?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskAuthConfig | undefined>;
    /**
     * (Updatable) The REST API configuration for cancelling the task.
     */
    cancelRestCallConfig?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskCancelRestCallConfig | undefined>;
    /**
     * (Updatable) The type to create a config provider.
     */
    configProviderDelegate?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskConfigProviderDelegate | undefined>;
    /**
     * (Updatable) Detailed description for the object.
     */
    description?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) The REST API configuration for execution.
     */
    executeRestCallConfig?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskExecuteRestCallConfig | undefined>;
    /**
     * (Updatable) Value can only contain upper case letters, underscore, and numbers. It should begin with upper case letter or underscore. The value can be modified.
     */
    identifier?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) An array of input ports.
     */
    inputPorts?: pulumi.Input<pulumi.Input<inputs.DataIntegration.WorkspaceTaskInputPort>[] | undefined>;
    /**
     * (Updatable) Defines whether Data Loader task is used for single load or multiple
     */
    isSingleLoad?: pulumi.Input<boolean | undefined>;
    /**
     * (Updatable) Generated key that can be used in API calls to identify task. On scenarios where reference to the task is needed, a value can be passed in create.
     */
    key?: pulumi.Input<string | undefined>;
    /**
     * A key map. If provided, key is replaced with generated key. This structure provides mapping between user provided key and generated key.
     */
    keyMap?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    } | undefined>;
    /**
     * A summary type containing information about the object including its key, name and when/who created/updated it.
     */
    metadatas?: pulumi.Input<pulumi.Input<inputs.DataIntegration.WorkspaceTaskMetadata>[] | undefined>;
    /**
     * (Updatable) The type of the task.
     */
    modelType?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) The object's model version.
     */
    modelVersion?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) Free form text without any restriction on permitted characters. Name can have letters, numbers, and special characters. The value is editable and is restricted to 1000 characters.
     */
    name?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) The status of an object that can be set to value 1 for shallow references across objects, other values reserved.
     */
    objectStatus?: pulumi.Input<number | undefined>;
    /**
     * This is used by the service for optimistic locking of the object, to prevent multiple users from simultaneously updating the object.
     */
    objectVersion?: pulumi.Input<number | undefined>;
    /**
     * (Updatable) Configuration values can be string, objects, or parameters.
     */
    opConfigValues?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskOpConfigValues | undefined>;
    /**
     * (Updatable) Describes the shape of the execution result
     */
    operation?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) An array of output ports.
     */
    outputPorts?: pulumi.Input<pulumi.Input<inputs.DataIntegration.WorkspaceTaskOutputPort>[] | undefined>;
    /**
     * (Updatable) Defines the number of entities being loaded in parallel at a time for a Data Loader task
     */
    parallelLoadLimit?: pulumi.Input<number | undefined>;
    /**
     * (Updatable) An array of parameters.
     */
    parameters?: pulumi.Input<pulumi.Input<inputs.DataIntegration.WorkspaceTaskParameter>[] | undefined>;
    /**
     * (Updatable) A reference to the object's parent.
     */
    parentRef?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskParentRef | undefined>;
    /**
     * (Updatable) The REST API configuration for polling.
     */
    pollRestCallConfig?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskPollRestCallConfig | undefined>;
    /**
     * (Updatable) Information about the object and its parent.
     */
    registryMetadata?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskRegistryMetadata | undefined>;
    /**
     * (Updatable) List of typed expressions.
     */
    typedExpressions?: pulumi.Input<pulumi.Input<inputs.DataIntegration.WorkspaceTaskTypedExpression>[] | undefined>;
    /**
     * The workspace ID.
     *
     *
     * ** IMPORTANT **
     * Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
     */
    workspaceId?: pulumi.Input<string | undefined>;
}
/**
 * The set of arguments for constructing a WorkspaceTask resource.
 */
export interface WorkspaceTaskArgs {
    /**
     * (Updatable) The REST invocation pattern to use. ASYNC_OCI_WORKREQUEST is being deprecated as well as cancelEndpoint/MethodType.
     */
    apiCallMode?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) Authentication configuration for Generic REST invocation.
     */
    authConfig?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskAuthConfig | undefined>;
    /**
     * (Updatable) The REST API configuration for cancelling the task.
     */
    cancelRestCallConfig?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskCancelRestCallConfig | undefined>;
    /**
     * (Updatable) The type to create a config provider.
     */
    configProviderDelegate?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskConfigProviderDelegate | undefined>;
    /**
     * (Updatable) Detailed description for the object.
     */
    description?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) The REST API configuration for execution.
     */
    executeRestCallConfig?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskExecuteRestCallConfig | undefined>;
    /**
     * (Updatable) Value can only contain upper case letters, underscore, and numbers. It should begin with upper case letter or underscore. The value can be modified.
     */
    identifier: pulumi.Input<string>;
    /**
     * (Updatable) An array of input ports.
     */
    inputPorts?: pulumi.Input<pulumi.Input<inputs.DataIntegration.WorkspaceTaskInputPort>[] | undefined>;
    /**
     * (Updatable) Defines whether Data Loader task is used for single load or multiple
     */
    isSingleLoad?: pulumi.Input<boolean | undefined>;
    /**
     * (Updatable) Generated key that can be used in API calls to identify task. On scenarios where reference to the task is needed, a value can be passed in create.
     */
    key?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) The type of the task.
     */
    modelType: pulumi.Input<string>;
    /**
     * (Updatable) The object's model version.
     */
    modelVersion?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) Free form text without any restriction on permitted characters. Name can have letters, numbers, and special characters. The value is editable and is restricted to 1000 characters.
     */
    name?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) The status of an object that can be set to value 1 for shallow references across objects, other values reserved.
     */
    objectStatus?: pulumi.Input<number | undefined>;
    /**
     * (Updatable) Configuration values can be string, objects, or parameters.
     */
    opConfigValues?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskOpConfigValues | undefined>;
    /**
     * (Updatable) Describes the shape of the execution result
     */
    operation?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) An array of output ports.
     */
    outputPorts?: pulumi.Input<pulumi.Input<inputs.DataIntegration.WorkspaceTaskOutputPort>[] | undefined>;
    /**
     * (Updatable) Defines the number of entities being loaded in parallel at a time for a Data Loader task
     */
    parallelLoadLimit?: pulumi.Input<number | undefined>;
    /**
     * (Updatable) An array of parameters.
     */
    parameters?: pulumi.Input<pulumi.Input<inputs.DataIntegration.WorkspaceTaskParameter>[] | undefined>;
    /**
     * (Updatable) A reference to the object's parent.
     */
    parentRef?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskParentRef | undefined>;
    /**
     * (Updatable) The REST API configuration for polling.
     */
    pollRestCallConfig?: pulumi.Input<inputs.DataIntegration.WorkspaceTaskPollRestCallConfig | undefined>;
    /**
     * (Updatable) Information about the object and its parent.
     */
    registryMetadata: pulumi.Input<inputs.DataIntegration.WorkspaceTaskRegistryMetadata>;
    /**
     * (Updatable) List of typed expressions.
     */
    typedExpressions?: pulumi.Input<pulumi.Input<inputs.DataIntegration.WorkspaceTaskTypedExpression>[] | undefined>;
    /**
     * The workspace ID.
     *
     *
     * ** IMPORTANT **
     * Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
     */
    workspaceId: pulumi.Input<string>;
}
//# sourceMappingURL=workspaceTask.d.ts.map