googleapis
Version:
Google APIs Client Library for Node.js
1,181 lines • 605 kB
TypeScript
/// <reference types="node" />
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { Readable } from 'stream';
export declare namespace integrations_v1alpha {
export interface Options extends GlobalOptions {
version: 'v1alpha';
}
interface StandardParameters {
/**
* Auth client or API Key for the request
*/
auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient | BaseExternalAccountClient | GoogleAuth;
/**
* V1 error format.
*/
'$.xgafv'?: string;
/**
* OAuth access token.
*/
access_token?: string;
/**
* Data format for response.
*/
alt?: string;
/**
* JSONP
*/
callback?: string;
/**
* Selector specifying which fields to include in a partial response.
*/
fields?: string;
/**
* API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token.
*/
key?: string;
/**
* OAuth 2.0 token for the current user.
*/
oauth_token?: string;
/**
* Returns response with indentations and line breaks.
*/
prettyPrint?: boolean;
/**
* Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.
*/
quotaUser?: string;
/**
* Legacy upload protocol for media (e.g. "media", "multipart").
*/
uploadType?: string;
/**
* Upload protocol for media (e.g. "raw", "multipart").
*/
upload_protocol?: string;
}
/**
* Application Integration API
*
*
*
* @example
* ```js
* const {google} = require('googleapis');
* const integrations = google.integrations('v1alpha');
* ```
*/
export class Integrations {
context: APIRequestContext;
callback: Resource$Callback;
connectorPlatformRegions: Resource$Connectorplatformregions;
projects: Resource$Projects;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* Registered ids for errors, as "oneof" enums. Each task or logical grouping of tasks may share the same enum.
*/
export interface Schema$CrmlogErrorCode {
commonErrorCode?: string | null;
}
export interface Schema$EnterpriseCrmEventbusAuthconfigAuthConfigTaskParam {
/**
* Defines the credential types to be supported as Task may restrict specific types to use, e.g. Cloud SQL Task will use username/password type only.
*/
allowedCredentialTypes?: string[] | null;
allowedServiceAccountInContext?: boolean | null;
/**
* UUID of the AuthConfig.
*/
authConfigId?: string | null;
/**
* A space-delimited list of requested scope permissions.
*/
scope?: string | null;
useServiceAccountInContext?: boolean | null;
}
/**
* Email address along with optional name and tokens. These tokens will be substituted for the variables in the form of [{var_name\}], where var_name could be any string of no more than 32 bytes.
*/
export interface Schema$EnterpriseCrmEventbusProtoAddress {
/**
* Required.
*/
email?: string | null;
name?: string | null;
tokens?: Schema$EnterpriseCrmEventbusProtoToken[];
}
/**
* Attributes are additional options that can be associated with each event property. For more information, see
*/
export interface Schema$EnterpriseCrmEventbusProtoAttributes {
/**
* Things like URL, Email, Currency, Timestamp (rather than string, int64...)
*/
dataType?: string | null;
/**
* Used to define defaults.
*/
defaultValue?: Schema$EnterpriseCrmEventbusProtoValueType;
/**
* Required for event execution. The validation will be done by the event bus when the event is triggered.
*/
isRequired?: boolean | null;
/**
* Used to indicate if a ParameterEntry should be converted to ParamIndexes for ST-Spanner full-text search. DEPRECATED: use searchable.
*/
isSearchable?: boolean | null;
/**
* See
*/
logSettings?: Schema$EnterpriseCrmEventbusProtoLogSettings;
searchable?: string | null;
/**
* List of tasks that can view this property, if empty then all.
*/
taskVisibility?: string[] | null;
}
/**
* List of error enums for alerts.
*/
export interface Schema$EnterpriseCrmEventbusProtoBaseAlertConfigErrorEnumList {
enumStrings?: string[] | null;
filterType?: string | null;
}
/**
* The threshold value of the metric, above or below which the alert should be triggered. See EventAlertConfig or TaskAlertConfig for the different alert metric types in each case. For the *RATE metrics, one or both of these fields may be set. Zero is the default value and can be left at that. For *PERCENTILE_DURATION metrics, one or both of these fields may be set, and also, the duration threshold value should be specified in the threshold_duration_ms member below. For *AVERAGE_DURATION metrics, these fields should not be set at all. A different member, threshold_duration_ms, must be set in the EventAlertConfig or the TaskAlertConfig.
*/
export interface Schema$EnterpriseCrmEventbusProtoBaseAlertConfigThresholdValue {
absolute?: string | null;
percentage?: number | null;
}
export interface Schema$EnterpriseCrmEventbusProtoBaseFunction {
functionName?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoBaseValue {
/**
* Start with a function that does not build on existing values. Eg. CurrentTime, Min, Max, Exists, etc.
*/
baseFunction?: Schema$EnterpriseCrmEventbusProtoFunction;
/**
* Start with a literal value.
*/
literalValue?: Schema$EnterpriseCrmEventbusProtoParameterValueType;
/**
* Start with a reference value to dereference.
*/
referenceValue?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoBooleanArrayFunction {
functionName?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoBooleanFunction {
functionName?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoBooleanParameterArray {
booleanValues?: boolean[] | null;
}
export interface Schema$EnterpriseCrmEventbusProtoBuganizerNotification {
/**
* Whom to assign the new bug. Optional.
*/
assigneeEmailAddress?: string | null;
/**
* ID of the buganizer component within which to create a new issue. Required.
*/
componentId?: string | null;
/**
* ID of the buganizer template to use. Optional.
*/
templateId?: string | null;
/**
* Title of the issue to be created. Required.
*/
title?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoCloudKmsConfig {
/**
* Optional. The id of GCP project where the KMS key is stored. If not provided, assume the key is stored in the same GCP project defined in Client (tag 14).
*/
gcpProjectId?: string | null;
/**
* A Cloud KMS key is a named object containing one or more key versions, along with metadata for the key. A key exists on exactly one key ring tied to a specific location.
*/
keyName?: string | null;
/**
* A key ring organizes keys in a specific Google Cloud location and allows you to manage access control on groups of keys. A key ring's name does not need to be unique across a Google Cloud project, but must be unique within a given location.
*/
keyRingName?: string | null;
/**
* Optional. Each version of a key contains key material used for encryption or signing. A key's version is represented by an integer, starting at 1. To decrypt data or verify a signature, you must use the same key version that was used to encrypt or sign the data.
*/
keyVersionName?: string | null;
/**
* Location name of the key ring, e.g. "us-west1".
*/
locationName?: string | null;
}
/**
* Cloud Scheduler Trigger configuration
*/
export interface Schema$EnterpriseCrmEventbusProtoCloudSchedulerConfig {
/**
* Required. The cron tab of cloud scheduler trigger.
*/
cronTab?: string | null;
/**
* Optional. When the job was deleted from Pantheon UI, error_message will be populated when Get/List integrations
*/
errorMessage?: string | null;
/**
* Required. The location where associated cloud scheduler job will be created
*/
location?: string | null;
/**
* Required. Service account used by Cloud Scheduler to trigger the integration at scheduled time
*/
serviceAccountEmail?: string | null;
}
/**
* This message recursively combines constituent conditions using logical AND.
*/
export interface Schema$EnterpriseCrmEventbusProtoCombinedCondition {
/**
* A set of individual constituent conditions.
*/
conditions?: Schema$EnterpriseCrmEventbusProtoCondition[];
}
/**
* Condition that uses `operator` to evaluate the key against the value.
*/
export interface Schema$EnterpriseCrmEventbusProtoCondition {
/**
* Key that's evaluated against the `value`. Please note the data type of the runtime value associated with the key should match the data type of `value`, else an IllegalArgumentException is thrown.
*/
eventPropertyKey?: string | null;
/**
* Operator used to evaluate the condition. Please note that an operator with an inappropriate key/value operand will result in IllegalArgumentException, e.g. CONTAINS with boolean key/value pair.
*/
operator?: string | null;
/**
* Value that's checked for the key.
*/
value?: Schema$EnterpriseCrmEventbusProtoValueType;
}
/**
* Contains the combined condition calculation results.
*/
export interface Schema$EnterpriseCrmEventbusProtoConditionResult {
/**
* the current task number.
*/
currentTaskNumber?: string | null;
/**
* the next task number.
*/
nextTaskNumber?: string | null;
/**
* the result comes out after evaluate the combined condition. True if there's no combined condition specified.
*/
result?: boolean | null;
}
export interface Schema$EnterpriseCrmEventbusProtoConnectorsConnection {
/**
* Connection name Format: projects/{project\}/locations/{location\}/connections/{connection\}
*/
connectionName?: string | null;
/**
* Connector version Format: projects/{project\}/locations/{location\}/providers/{provider\}/connectors/{connector\}/versions/{version\}
*/
connectorVersion?: string | null;
/**
* Service name Format: projects/{project\}/locations/{location\}/namespaces/{namespace\}/services/{service\}
*/
serviceName?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoConnectorsGenericConnectorTaskConfig {
/**
* User-selected connection.
*/
connection?: Schema$EnterpriseCrmEventbusProtoConnectorsConnection;
/**
* Operation to perform using the configured connection.
*/
operation?: string | null;
}
/**
* Represents two-dimensional positions.
*/
export interface Schema$EnterpriseCrmEventbusProtoCoordinate {
x?: number | null;
y?: number | null;
}
export interface Schema$EnterpriseCrmEventbusProtoCustomSuspensionRequest {
/**
* Request to fire an event containing the SuspensionInfo message.
*/
postToQueueWithTriggerIdRequest?: Schema$GoogleInternalCloudCrmEventbusV3PostToQueueWithTriggerIdRequest;
/**
* In the fired event, set the SuspensionInfo message as the value for this key.
*/
suspensionInfoEventParameterKey?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoDoubleArray {
values?: number[] | null;
}
export interface Schema$EnterpriseCrmEventbusProtoDoubleArrayFunction {
functionName?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoDoubleFunction {
functionName?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoDoubleParameterArray {
doubleValues?: number[] | null;
}
/**
* An error, warning, or information message associated with a workflow.
*/
export interface Schema$EnterpriseCrmEventbusProtoErrorDetail {
/**
* The associated error-code, which can be a common or internal code.
*/
errorCode?: Schema$CrmlogErrorCode;
/**
* The full text of the error message, including any parameters that were thrown along with the exception.
*/
errorMessage?: string | null;
/**
* The severity of the error: ERROR|WARN|INFO.
*/
severity?: string | null;
/**
* The task try-number, in which, the error occurred. If zero, the error happened at the event level.
*/
taskNumber?: number | null;
}
/**
* LINT.IfChange This message is used for storing key value pair properties for each Event / Task in the EventBus.
*/
export interface Schema$EnterpriseCrmEventbusProtoEventBusProperties {
/**
* An unordered list of property entries.
*/
properties?: Schema$EnterpriseCrmEventbusProtoPropertyEntry[];
}
/**
* Contains the details of the execution info of this event: this includes the tasks execution details plus the event execution statistics. Next available id: 10
*/
export interface Schema$EnterpriseCrmEventbusProtoEventExecutionDetails {
eventAttemptStats?: Schema$EnterpriseCrmEventbusProtoEventExecutionDetailsEventAttemptStats[];
eventExecutionSnapshot?: Schema$EnterpriseCrmEventbusProtoEventExecutionSnapshot[];
eventExecutionState?: string | null;
/**
* Indicates the number of times the execution has restarted from the beginning.
*/
eventRetriesFromBeginningCount?: number | null;
/**
* The log file path (aka. cns address) for this event.
*/
logFilePath?: string | null;
/**
* The network address (aka. bns address) that indicates where the event executor is running.
*/
networkAddress?: string | null;
/**
* Next scheduled execution time in case the execution status was RETRY_ON_HOLD.
*/
nextExecutionTime?: string | null;
/**
* Used internally and shouldn't be exposed to users. A counter for the cron job to record how many times this event is in in_process state but don't have a lock consecutively/
*/
ryeLockUnheldCount?: number | null;
}
export interface Schema$EnterpriseCrmEventbusProtoEventExecutionDetailsEventAttemptStats {
/**
* The end time of the event execution for current attempt.
*/
endTime?: string | null;
/**
* The start time of the event execution for current attempt. This could be in the future if it's been scheduled.
*/
startTime?: string | null;
}
/**
* Contains the snapshot of the event execution for a given checkpoint. Next available id: 13
*/
export interface Schema$EnterpriseCrmEventbusProtoEventExecutionSnapshot {
/**
* Indicates "right after which checkpoint task's execution" this snapshot is taken.
*/
checkpointTaskNumber?: string | null;
/**
* All of the computed conditions that been calculated.
*/
conditionResults?: Schema$EnterpriseCrmEventbusProtoConditionResult[];
/**
* The parameters in Event object that differs from last snapshot.
*/
diffParams?: Schema$EnterpriseCrmEventbusProtoEventParameters;
/**
* Points to the event execution info this snapshot belongs to.
*/
eventExecutionInfoId?: string | null;
/**
* Auto-generated. Used as primary key for EventExecutionSnapshots table.
*/
eventExecutionSnapshotId?: string | null;
eventExecutionSnapshotMetadata?: Schema$EnterpriseCrmEventbusProtoEventExecutionSnapshotEventExecutionSnapshotMetadata;
/**
* The parameters in Event object.
*/
eventParams?: Schema$EnterpriseCrmEventbusProtoEventParameters;
/**
* indicate whether snapshot exceeded maximum size before clean up
*/
exceedMaxSize?: boolean | null;
/**
* Indicates when this snapshot is taken.
*/
snapshotTime?: string | null;
/**
* All of the task execution details at the given point of time.
*/
taskExecutionDetails?: Schema$EnterpriseCrmEventbusProtoTaskExecutionDetails[];
/**
* The task name associated with this snapshot. Could be empty.
*/
taskName?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoEventExecutionSnapshotEventExecutionSnapshotMetadata {
/**
* the event attempt number this snapshot belongs to.
*/
eventAttemptNum?: number | null;
/**
* the task attempt number this snapshot belongs to. Could be empty.
*/
taskAttemptNum?: number | null;
/**
* the task label associated with this snapshot. Could be empty.
*/
taskLabel?: string | null;
/**
* the task name associated with this snapshot. Could be empty.
*/
taskName?: string | null;
/**
* The task number associated with this snapshot. Could be empty.
*/
taskNumber?: string | null;
}
/**
* LINT.IfChange This message is used for processing and persisting (when applicable) key value pair parameters for each event in the event bus. Please see
*/
export interface Schema$EnterpriseCrmEventbusProtoEventParameters {
/**
* Parameters are a part of Event and can be used to communicate between different tasks that are part of the same integration execution.
*/
parameters?: Schema$EnterpriseCrmEventbusProtoParameterEntry[];
}
/**
* Message that helps aggregate all sub-executions triggered by one execution and keeps track of child-parent relationships.
*/
export interface Schema$EnterpriseCrmEventbusProtoExecutionTraceInfo {
/**
* Parent event execution info id that triggers the current execution through SubWorkflowExecutorTask.
*/
parentEventExecutionInfoId?: string | null;
/**
* Used to aggregate ExecutionTraceInfo.
*/
traceId?: string | null;
}
/**
* Represents external traffic type and id.
*/
export interface Schema$EnterpriseCrmEventbusProtoExternalTraffic {
/**
* User’s GCP project id the traffic is referring to.
*/
gcpProjectId?: string | null;
/**
* User’s GCP project number the traffic is referring to.
*/
gcpProjectNumber?: string | null;
/**
* Location for the user's request.
*/
location?: string | null;
/**
* LINT.ThenChange(//depot/google3/enterprise/crm/eventbus/proto/product.proto:product, //depot/google3/java/com/google/enterprise/crm/integrationplatform/api/utils/ConverterUtils.java:source_to_product)
*/
source?: string | null;
}
/**
* Policy that defines the task retry logic and failure type. If no FailurePolicy is defined for a task, all its dependent tasks will not be executed (i.e, a `retry_strategy` of NONE will be applied).
*/
export interface Schema$EnterpriseCrmEventbusProtoFailurePolicy {
/**
* Required if retry_strategy is FIXED_INTERVAL or LINEAR/EXPONENTIAL_BACKOFF/RESTART_WORKFLOW_WITH_BACKOFF. Defines the initial interval for backoff.
*/
intervalInSeconds?: string | null;
/**
* Required if retry_strategy is FIXED_INTERVAL or LINEAR/EXPONENTIAL_BACKOFF/RESTART_WORKFLOW_WITH_BACKOFF. Defines the number of times the task will be retried if failed.
*/
maxNumRetries?: number | null;
/**
* Defines what happens to the task upon failure.
*/
retryStrategy?: string | null;
}
/**
* Information about the value and type of the field.
*/
export interface Schema$EnterpriseCrmEventbusProtoField {
/**
* By default, if the cardinality is unspecified the field is considered required while mapping.
*/
cardinality?: string | null;
/**
* This holds the default values for the fields. This value is supplied by user so may or may not contain PII or SPII data.
*/
defaultValue?: Schema$EnterpriseCrmEventbusProtoParameterValueType;
/**
* Specifies the data type of the field.
*/
fieldType?: string | null;
/**
* Optional. The fully qualified proto name (e.g. enterprise.crm.storage.Account). Required for output field of type PROTO_VALUE or PROTO_ARRAY. For e.g., if input field_type is BYTES and output field_type is PROTO_VALUE, then fully qualified proto type url should be provided to parse the input bytes. If field_type is *_ARRAY, then all the converted protos are of the same type.
*/
protoDefPath?: string | null;
/**
* This holds the reference key of the workflow or task parameter. 1. Any workflow parameter, for e.g. $workflowParam1$. 2. Any task input or output parameter, for e.g. $task1_param1$. 3. Any workflow or task parameters with subfield references, for e.g., $task1_param1.employee.id$
*/
referenceKey?: string | null;
/**
* This is the transform expression to fetch the input field value. for e.g. $param1$.CONCAT('test'). Keep points - 1. Only input field can have a transform expression. 2. If a transform expression is provided, reference_key will be ignored. 3. If no value is returned after evaluation of transform expression, default_value can be mapped if provided. 4. The field_type should be the type of the final object returned after the transform expression is evaluated. Scrubs the transform expression before logging as value provided by user so may or may not contain PII or SPII data.
*/
transformExpression?: Schema$EnterpriseCrmEventbusProtoTransformExpression;
}
/**
* Field Mapping Config to map multiple output fields values from input fields values.
*/
export interface Schema$EnterpriseCrmEventbusProtoFieldMappingConfig {
mappedFields?: Schema$EnterpriseCrmEventbusProtoMappedField[];
}
export interface Schema$EnterpriseCrmEventbusProtoFunction {
/**
* The name of the function to perform.
*/
functionType?: Schema$EnterpriseCrmEventbusProtoFunctionType;
/**
* List of parameters required for the transformation.
*/
parameters?: Schema$EnterpriseCrmEventbusProtoTransformExpression[];
}
export interface Schema$EnterpriseCrmEventbusProtoFunctionType {
/**
* LINT.IfChange
*/
baseFunction?: Schema$EnterpriseCrmEventbusProtoBaseFunction;
booleanArrayFunction?: Schema$EnterpriseCrmEventbusProtoBooleanArrayFunction;
booleanFunction?: Schema$EnterpriseCrmEventbusProtoBooleanFunction;
doubleArrayFunction?: Schema$EnterpriseCrmEventbusProtoDoubleArrayFunction;
doubleFunction?: Schema$EnterpriseCrmEventbusProtoDoubleFunction;
intArrayFunction?: Schema$EnterpriseCrmEventbusProtoIntArrayFunction;
intFunction?: Schema$EnterpriseCrmEventbusProtoIntFunction;
/**
* LINT.ThenChange(//depot/google3/alkali/apps/integrationplatform/client/workflow_editor/utils/transform_function.ts)
*/
jsonFunction?: Schema$EnterpriseCrmEventbusProtoJsonFunction;
protoArrayFunction?: Schema$EnterpriseCrmEventbusProtoProtoArrayFunction;
protoFunction?: Schema$EnterpriseCrmEventbusProtoProtoFunction;
stringArrayFunction?: Schema$EnterpriseCrmEventbusProtoStringArrayFunction;
stringFunction?: Schema$EnterpriseCrmEventbusProtoStringFunction;
}
export interface Schema$EnterpriseCrmEventbusProtoIntArray {
values?: string[] | null;
}
export interface Schema$EnterpriseCrmEventbusProtoIntArrayFunction {
functionName?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoIntFunction {
functionName?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoIntParameterArray {
intValues?: string[] | null;
}
export interface Schema$EnterpriseCrmEventbusProtoJsonFunction {
functionName?: string | null;
}
/**
* The LogSettings define the logging attributes for an event property. These attributes are used to map the property to the parameter in the log proto. Also used to define scrubbing/truncation behavior and PII information.
*/
export interface Schema$EnterpriseCrmEventbusProtoLogSettings {
/**
* The name of corresponding logging field of the event property. If omitted, assumes the same name as the event property key.
*/
logFieldName?: string | null;
/**
* Contains the scrubbing options, such as whether to scrub, obfuscate, etc.
*/
sanitizeOptions?: Schema$EnterpriseCrmLoggingGwsSanitizeOptions;
seedPeriod?: string | null;
seedScope?: string | null;
/**
* Contains the field limits for shortening, such as max string length and max array length.
*/
shorteningLimits?: Schema$EnterpriseCrmLoggingGwsFieldLimits;
}
export interface Schema$EnterpriseCrmEventbusProtoLoopMetadata {
/**
* Starting from 1, not 0.
*/
currentIterationCount?: string | null;
/**
* Needs to be set by the loop impl class before each iteration. The abstract loop class will append the request and response to it. Eg. The foreach Loop will clean up and set it as the current iteration element at the start of each loop. The post request and response will be appended to the value once they are available.
*/
currentIterationDetail?: string | null;
/**
* Add the error message when loops fail.
*/
errorMsg?: string | null;
/**
* Indicates where in the loop logic did it error out.
*/
failureLocation?: string | null;
}
/**
* Mapped field is a pair of input field and output field.
*/
export interface Schema$EnterpriseCrmEventbusProtoMappedField {
/**
* The input field being mapped from.
*/
inputField?: Schema$EnterpriseCrmEventbusProtoField;
/**
* The output field being mapped to.
*/
outputField?: Schema$EnterpriseCrmEventbusProtoField;
}
/**
* The task that is next in line to be executed, if the condition specified evaluated to true.
*/
export interface Schema$EnterpriseCrmEventbusProtoNextTask {
/**
* Combined condition for this task to become an eligible next task. Each of these combined_conditions are joined with logical OR. DEPRECATED: use `condition`
*/
combinedConditions?: Schema$EnterpriseCrmEventbusProtoCombinedCondition[];
/**
* Standard filter expression for this task to become an eligible next task.
*/
condition?: string | null;
/**
* User-provided description intended to give more business context about the next task edge or condition.
*/
description?: string | null;
/**
* User-provided label that is attached to this edge in the UI.
*/
label?: string | null;
/**
* ID of the next task.
*/
taskConfigId?: string | null;
/**
* Task number of the next task.
*/
taskNumber?: string | null;
}
/**
* The teardown task that is next in line to be executed. We support only sequential execution of teardown tasks (i.e. no branching).
*/
export interface Schema$EnterpriseCrmEventbusProtoNextTeardownTask {
/**
* Required. Name of the next teardown task.
*/
name?: string | null;
}
/**
* Represents a node identifier (type + id). Next highest id: 3
*/
export interface Schema$EnterpriseCrmEventbusProtoNodeIdentifier {
/**
* Configuration of the edge.
*/
elementIdentifier?: string | null;
/**
* Destination node where the edge ends. It can only be a task config.
*/
elementType?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoNotification {
buganizerNotification?: Schema$EnterpriseCrmEventbusProtoBuganizerNotification;
emailAddress?: Schema$EnterpriseCrmEventbusProtoAddress;
escalatorQueue?: string | null;
pubsubTopic?: string | null;
/**
* If the out-of-the-box email/pubsub notifications are not suitable and custom logic is required, fire a workflow containing all info needed to notify users to resume execution.
*/
request?: Schema$EnterpriseCrmEventbusProtoCustomSuspensionRequest;
}
/**
* Key-value pair of EventBus parameters.
*/
export interface Schema$EnterpriseCrmEventbusProtoParameterEntry {
/**
* Key is used to retrieve the corresponding parameter value. This should be unique for a given fired event. These parameters must be predefined in the integration definition.
*/
key?: string | null;
/**
* Values for the defined keys. Each value can either be string, int, double or any proto message.
*/
value?: Schema$EnterpriseCrmEventbusProtoParameterValueType;
}
/**
* A generic multi-map that holds key value pairs. They keys and values can be of any type, unless specified.
*/
export interface Schema$EnterpriseCrmEventbusProtoParameterMap {
entries?: Schema$EnterpriseCrmEventbusProtoParameterMapEntry[];
/**
* Option to specify key value type for all entries of the map. If provided then field types for all entries must conform to this.
*/
keyType?: string | null;
valueType?: string | null;
}
/**
* Entry is a pair of key and value.
*/
export interface Schema$EnterpriseCrmEventbusProtoParameterMapEntry {
key?: Schema$EnterpriseCrmEventbusProtoParameterMapField;
value?: Schema$EnterpriseCrmEventbusProtoParameterMapField;
}
/**
* Field represents either the key or value in an entry.
*/
export interface Schema$EnterpriseCrmEventbusProtoParameterMapField {
/**
* Passing a literal value.
*/
literalValue?: Schema$EnterpriseCrmEventbusProtoParameterValueType;
/**
* Referencing one of the WF variables.
*/
referenceKey?: string | null;
}
/**
* LINT.IfChange To support various types of parameter values. Next available id: 14
*/
export interface Schema$EnterpriseCrmEventbusProtoParameterValueType {
booleanArray?: Schema$EnterpriseCrmEventbusProtoBooleanParameterArray;
booleanValue?: boolean | null;
doubleArray?: Schema$EnterpriseCrmEventbusProtoDoubleParameterArray;
doubleValue?: number | null;
intArray?: Schema$EnterpriseCrmEventbusProtoIntParameterArray;
intValue?: string | null;
protoArray?: Schema$EnterpriseCrmEventbusProtoProtoParameterArray;
protoValue?: {
[key: string]: any;
} | null;
serializedObjectValue?: Schema$EnterpriseCrmEventbusProtoSerializedObjectParameter;
stringArray?: Schema$EnterpriseCrmEventbusProtoStringParameterArray;
stringValue?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoParamSpecEntryConfig {
/**
* A short phrase to describe what this parameter contains.
*/
descriptivePhrase?: string | null;
/**
* Detailed help text for this parameter containing information not provided elsewhere. For example, instructions on how to migrate from a deprecated parameter.
*/
helpText?: string | null;
/**
* Whether the default value is hidden in the UI.
*/
hideDefaultValue?: boolean | null;
inputDisplayOption?: string | null;
/**
* Whether this field is hidden in the UI.
*/
isHidden?: boolean | null;
/**
* A user-friendly label for the parameter.
*/
label?: string | null;
parameterNameOption?: string | null;
/**
* A user-friendly label for subSection under which the parameter will be displayed.
*/
subSectionLabel?: string | null;
/**
* Placeholder text which will appear in the UI input form for this parameter.
*/
uiPlaceholderText?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoParamSpecEntryProtoDefinition {
/**
* The fully-qualified proto name. This message, for example, would be "enterprise.crm.eventbus.proto.ParamSpecEntry.ProtoDefinition".
*/
fullName?: string | null;
/**
* Path to the proto file that contains the message type's definition.
*/
path?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoParamSpecEntryValidationRule {
doubleRange?: Schema$EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleDoubleRange;
intRange?: Schema$EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleIntRange;
stringRegex?: Schema$EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleStringRegex;
}
/**
* Range used to validate doubles and floats.
*/
export interface Schema$EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleDoubleRange {
/**
* The inclusive maximum of the acceptable range.
*/
max?: number | null;
/**
* The inclusive minimum of the acceptable range.
*/
min?: number | null;
}
/**
* Range used to validate longs and ints.
*/
export interface Schema$EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleIntRange {
/**
* The inclusive maximum of the acceptable range.
*/
max?: string | null;
/**
* The inclusive minimum of the acceptable range.
*/
min?: string | null;
}
/**
* Rule used to validate strings.
*/
export interface Schema$EnterpriseCrmEventbusProtoParamSpecEntryValidationRuleStringRegex {
/**
* Whether the regex matcher is applied exclusively (if true, matching values will be rejected).
*/
exclusive?: boolean | null;
/**
* The regex applied to the input value(s).
*/
regex?: string | null;
}
/**
* Key-value pair of EventBus property.
*/
export interface Schema$EnterpriseCrmEventbusProtoPropertyEntry {
/**
* Key is used to retrieve the corresponding property value. This should be unique for a given fired event. The Tasks should be aware of the keys used while firing the events for them to be able to retrieve the values.
*/
key?: string | null;
/**
* Values for the defined keys. Each value can either be string, int, double or any proto message.
*/
value?: Schema$EnterpriseCrmEventbusProtoValueType;
}
export interface Schema$EnterpriseCrmEventbusProtoProtoArrayFunction {
functionName?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoProtoFunction {
functionName?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoProtoParameterArray {
protoValues?: Array<{
[key: string]: any;
}> | null;
}
export interface Schema$EnterpriseCrmEventbusProtoScatterResponse {
/**
* The error message of the failure if applicable.
*/
errorMsg?: string | null;
/**
* The execution ids of each Subworkflow fired by this scatter.
*/
executionIds?: string[] | null;
/**
* If execution is sync, this is true if the execution passed and false if it failed. If the execution is async, this is true if the WF was fired off successfully, and false if it failed to execute. The success or failure of the subworkflows executed are not captured.
*/
isSuccessful?: boolean | null;
/**
* A list of all the response parameters in the aggregtorMap stored with the remapped key.
*/
responseParams?: Schema$EnterpriseCrmEventbusProtoParameterEntry[];
/**
* The element that was scattered for this execution.
*/
scatterElement?: Schema$EnterpriseCrmEventbusProtoParameterValueType;
}
export interface Schema$EnterpriseCrmEventbusProtoSerializedObjectParameter {
objectValue?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoStringArray {
values?: string[] | null;
}
export interface Schema$EnterpriseCrmEventbusProtoStringArrayFunction {
functionName?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoStringFunction {
functionName?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoStringParameterArray {
stringValues?: string[] | null;
}
/**
* Policy that dictates the behavior for the task after it completes successfully.
*/
export interface Schema$EnterpriseCrmEventbusProtoSuccessPolicy {
/**
* State to which the execution snapshot status will be set if the task succeeds.
*/
finalState?: string | null;
}
/**
* LINT.IfChange
*/
export interface Schema$EnterpriseCrmEventbusProtoSuspensionAuthPermissions {
/**
* Represents a Gaia identity for a person or service account.
*/
gaiaIdentity?: Schema$EnterpriseCrmEventbusProtoSuspensionAuthPermissionsGaiaIdentity;
googleGroup?: Schema$EnterpriseCrmEventbusProtoSuspensionAuthPermissionsGaiaIdentity;
loasRole?: string | null;
mdbGroup?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoSuspensionAuthPermissionsGaiaIdentity {
emailAddress?: string | null;
gaiaId?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoSuspensionConfig {
/**
* Optional information to provide recipients of the suspension in addition to the resolution URL, typically containing relevant parameter values from the originating workflow.
*/
customMessage?: string | null;
notifications?: Schema$EnterpriseCrmEventbusProtoNotification[];
/**
* Indicates the next steps when no external actions happen on the suspension.
*/
suspensionExpiration?: Schema$EnterpriseCrmEventbusProtoSuspensionExpiration;
/**
* Identities able to resolve this suspension.
*/
whoMayResolve?: Schema$EnterpriseCrmEventbusProtoSuspensionAuthPermissions[];
}
export interface Schema$EnterpriseCrmEventbusProtoSuspensionExpiration {
/**
* Milliseconds after which the suspension expires, if no action taken.
*/
expireAfterMs?: number | null;
/**
* Whether the suspension will be REJECTED or LIFTED upon expiration. REJECTED is the default behavior.
*/
liftWhenExpired?: boolean | null;
/**
* Milliseconds after which the previous suspension action reminder, if any, is sent using the selected notification option, for a suspension which is still PENDING_UNSPECIFIED.
*/
remindAfterMs?: number | null;
}
export interface Schema$EnterpriseCrmEventbusProtoSuspensionResolutionInfo {
audit?: Schema$EnterpriseCrmEventbusProtoSuspensionResolutionInfoAudit;
/**
* The event data user sends as request.
*/
clientId?: string | null;
/**
* KMS info, used by cmek/gmek integration
*/
cloudKmsConfig?: Schema$EnterpriseCrmEventbusProtoCloudKmsConfig;
/**
* Auto-generated.
*/
createdTimestamp?: string | null;
/**
* Encrypted SuspensionResolutionInfo
*/
encryptedSuspensionResolutionInfo?: string | null;
/**
* Required. ID of the associated execution.
*/
eventExecutionInfoId?: string | null;
/**
* The origin of the suspension for periodic notifications.
*/
externalTraffic?: Schema$EnterpriseCrmEventbusProtoExternalTraffic;
/**
* Auto-generated.
*/
lastModifiedTimestamp?: string | null;
/**
* Which Google product the suspension belongs to. If not set, the suspension belongs to Integration Platform by default.
*/
product?: string | null;
status?: string | null;
suspensionConfig?: Schema$EnterpriseCrmEventbusProtoSuspensionConfig;
/**
* Primary key for the SuspensionResolutionInfoTable.
*/
suspensionId?: string | null;
/**
* Required. Task number of the associated SuspensionTask.
*/
taskNumber?: string | null;
/**
* Required. The name of the originating workflow.
*/
workflowName?: string | null;
/**
* Wrapped dek
*/
wrappedDek?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoSuspensionResolutionInfoAudit {
resolvedBy?: string | null;
resolvedByCpi?: string | null;
timestamp?: string | null;
}
/**
* Message to be used to configure alerting in the {@code TaskConfig\} protos for tasks in an event.
*/
export interface Schema$EnterpriseCrmEventbusProtoTaskAlertConfig {
/**
* The period over which the metric value should be aggregated and evaluated. Format is , where integer should be a positive integer and unit should be one of (s,m,h,d,w) meaning (second, minute, hour, day, week).
*/
aggregationPeriod?: string | null;
/**
* Set to false by default. When set to true, the metrics are not aggregated or pushed to Monarch for this workflow alert.
*/
alertDisabled?: boolean | null;
/**
* A name to identify this alert. This will be displayed in the alert subject. If set, this name should be unique in within the scope of the containing workflow.
*/
alertName?: string | null;
/**
* Client associated with this alert configuration. Must be a client enabled in one of the containing workflow's triggers.
*/
clientId?: string | null;
/**
* Should be specified only for TASK_AVERAGE_DURATION and TASK_PERCENTILE_DURATION metrics. This member should be used to specify what duration value the metrics should exceed for the alert to trigger.
*/
durationThresholdMs?: string | null;
errorEnumList?: Schema$EnterpriseCrmEventbusProtoBaseAlertConfigErrorEnumList;
metricType?: string | null;
/**
* For how many contiguous aggregation periods should the expected min or max be violated for the alert to be fired.
*/
numAggregationPeriods?: number | null;
/**
* Only count final task attempts, not retries.
*/
onlyFinalAttempt?: boolean | null;
/**
* Link to a playbook for resolving the issue that triggered this alert.
*/
playbookUrl?: string | null;
/**
* The threshold type for which this alert is being configured. If value falls below expected_min or exceeds expected_max, an alert will be fired.
*/
thresholdType?: string | null;
/**
* The metric value, above or below which the alert should be triggered.
*/
thresholdValue?: Schema$EnterpriseCrmEventbusProtoBaseAlertConfigThresholdValue;
warningEnumList?: Schema$EnterpriseCrmEventbusProtoBaseAlertConfigErrorEnumList;
}
/**
* Contains the details of the execution of this task. Next available id: 11
*/
export interface Schema$EnterpriseCrmEventbusProtoTaskExecutionDetails {
taskAttemptStats?: Schema$EnterpriseCrmEventbusProtoTaskExecutionDetailsTaskAttemptStats[];
taskExecutionState?: string | null;
/**
* Pointer to the task config it used for execution.
*/
taskNumber?: string | null;
}
export interface Schema$EnterpriseCrmEventbusProtoTaskExecutionDetailsTaskAttemptStats {
/**
* The end time of the task execution for current attempt.
*/
endTime?: string | null;
/**
* The start time of the task execution for current attempt. This could be in the future if it's been scheduled.
*/
startTime?: string | null;
}
/**
* TaskMetadata are attributes that are associated to every common Task we have.
*/
export interface Schema$EnterpriseCrmEventbusProtoTaskMetadata {
/**
* The new task name to replace the current task if it is deprecated. Otherwise, it is the same as the current task name.
*/
activeTaskName?: string | null;
admins?: Schema$EnterpriseCrmEventbusProtoTaskMetadataAdmin[];
category?: string | null;
/**
* The Code Search link to the Task Java file.
*/
codeSearchLink?: string | null;
/**
* Controls whether JSON workflow parameters are validated against provided schemas before and/or after this task's execution.
*/
defaultJsonValidationOption?: string | null;
/**
* Contains the initial configuration of the task with default values set. For now, The string should be compatible to an ASCII-proto format.
*/
defaultSpec?: string | null;
/**
* In a few sentences, describe the purpose and usage of the task.
*/
description?: string | null;
/**
* The string name to show on the task list on the Workflow editor screen. This should be a very short, one to two words name for the task. (e.g. "Send Mail")
*/
descriptiveName?: string | null;
/**
* Snippet of markdown documentation to embed in the RHP for this task.
*/
docMarkdown?: string | null;
externalCategory?: string | null;
/**
* Sequence with which the task in specific category to be displayed in task discovery panel for external users.
*/
externalCategorySequence?: number | null;
/**
* External-facing documention embedded in the RHP for this task.
*/
externalDocHtml?: string | null;
/**
* Doc link for external-facing documentation (separate from g3doc).
*/
externalDocLink?: string | null;
/**
* DEPRECATED: Use external_doc_html.
*/
externalDocMarkdown?: string | null;
/**
* URL to the associated G3 Doc for the task if available
*/
g3DocLink?: string | null;
/**
* URL to gstatic image icon for this task. This icon shows up on the task list panel along with the task name in the Workflow Editor screen. Use the 24p, 2x, gray color icon image format.
*/
iconLink?: string | null;
/**
* The deprecation status of the current task. Default value is false;
*/
isDeprecated?: boolean | null;
/**
* The actual class name or the annotated name of the task. Task Author should initialize this field with value from the getName() method of the Task class.
*/
name?: string | null;
/**
* External-facing documention for standalone IP in