Method: triggers.fire

Notifies Google that a trigger event has occurred.

HTTP request

POST https://workspacestudio.googleapis.com/v1/{name=triggers/*}:fire

The URL uses gRPC Transcoding syntax.

Path parameters

Parameters
name

string

Required. The resource name of the trigger. Format: triggers/{trigger_id}

Request body

The request body contains data with the following structure:

JSON representation 
{
  "outputs": {
    string: {
      object (VariableData)
    },
    ...
  },
  "log": {
    object (TextFormat)
  },
  "requestId": string
}
Fields
outputs

map (key: string, value: object (VariableData))

Optional. The output variables from the trigger event in the 3P application.

An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
log

object (TextFormat)

Optional. Optional user facing log for the trigger event.
requestId

string

Optional. A unique identifier for this request. Restricted to 36 ASCII characters. A random UUID is recommended. This request is only idempotent if a requestId is provided.

Response body

If successful, the response body is empty.

Authorization scopes

Requires the following OAuth scope:

  • https://www.googleapis.com/auth/workspace.studio.trigger

For more information, see the Authorization guide.

VariableData

Represents variable data, which can hold multiple values of different types.

JSON representation 
{
  "booleanValues": [
    boolean
  ],
  "integerValues": [
    string
  ],
  "stringValues": [
    string
  ],
  "timestampValues": [
    string
  ],
  "resourceReferences": [
    string
  ],
  "resourceDataValues": [
    {
      object (ResourceData)
    }
  ],
  "emailAddressValues": [
    string
  ],
  "users": [
    string
  ]
}
Fields
booleanValues[]

boolean

Boolean values.
integerValues[]

string (int64 format)

Integer values.
stringValues[]

string

String values.
timestampValues[]

string (Timestamp format)

Timestamp values.

Uses RFC 3339, where generated output will always be Z-normalized and use 0, 3, 6 or 9 fractional digits. Offsets other than "Z" are also accepted. Examples: "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" or "2014-10-02T15:01:23+05:30".
resourceReferences[]

string

A list of resource IDs (e.g. "spaces/123").
resourceDataValues[]

object (ResourceData)

A list of resource data.
emailAddressValues[]

string

Email address values.
users[]

string

Google user values in the format users/{user}.

ResourceData

Application specific resource value.

JSON representation 
{
  "fields": {
    string: {
      object (VariableData)
    },
    ...
  }
}
Fields
fields

map (key: string, value: object (VariableData))

A map of the resource fields keyed by the field name.

An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.

TextFormat

A block of text with rich formatting options including styles, hyperlinks, and interactive elements.

JSON representation 
{
  "textFormatElements": [
    {
      object (TextFormatElement)
    }
  ]
}
Fields
textFormatElements[]

object (TextFormatElement)

Optional. A collection of text format elements.

TextFormatElement

A single element within a WorkflowTextFormatMarkup message, which can be a chip, styled text, a hyperlink, or a list container.

JSON representation 
{

  "text": string,
  "chip": {
    object (Chip)
  },
  "styledText": {
    object (StyledText)
  },
  "hyperlink": {
    object (Hyperlink)
  },
  "listContainer": {
    object (ListContainer)
  }
}
Fields
Union field element. Element that represents one of several possible text format elements. element can be only one of the following:
text

string

Text in the text format.
chip

object (Chip)

Clickable chip in the text format.
styledText

object (StyledText)

Styled text in the text format.
listContainer

object (ListContainer)

List container in the text format.

Chip

A clickable chip in the text format.

JSON representation 
{
  "icon": {
    object (Icon)
  },
  "label": string,
  "url": string
}
Fields
icon

object (Icon)

Optional. The icon displayed in the chip.
label

string

Optional. The text displayed in the chip.
url

string

Optional. The URL to navigate to when the chip is clicked.

Icon

An icon in the chip.

JSON representation 
{

  "iconUrl": string,
  "materialIcon": string
}
Fields
Union field icons. The icon displayed in the chip. icons can be only one of the following:
iconUrl

string

Display a custom icon hosted at an HTTPS URL.

For example:

"iconUrl":
"https://developers.google.com/workspace/chat/images/quickstart-app-avatar.png"

Supported file types include .png and .jpg.
materialIcon

string

The icon name defined in the Google Material Icon, for example, check_box. Any invalid names are abandoned and replaced with empty string and results in the icon failing to render.

StyledText

Text element with styles such as bold, italic and color.

JSON representation 
{
  "text": string,
  "styles": [
    enum (Style)
  ],
  "fontWeight": enum (FontWeight),
  "color": {
    object (Color)
  },
  "wrapStyle": enum (WrapStyle)
}
Fields
text

string

Optional. The main content of the text.
styles[]

enum (Style)

Optional. A collection of styles applied to the text.
fontWeight

enum (FontWeight)

Optional. The font weight of the text.
color

object (Color)

Optional. The color of the text.
wrapStyle

enum (WrapStyle)

Optional. The wrap style of the text.

Style

Enum for different text styles such as italic, underline, etc.

Enums
STYLE_UNSPECIFIED No style applied.
ITALIC Italic style.
UNDERLINE Underline style.
STRIKETHROUGH Strikethrough style.
LINE_BREAK Line break.
UPPERCASE Uppercase style.
CODE Code.
CODE_BLOCK Code block.

FontWeight

Enum for different font weights.

Enums
FONT_WEIGHT_UNSPECIFIED Standard weight with normal thickness.
LIGHT Lighter weight with reduced thickness.
MEDIUM Intermediate weight between light and bold.
BOLD Heavier weight with increased thickness.

Color

Represents a color in the RGBA color space. This representation is designed for simplicity of conversion to and from color representations in various languages over compactness. For example, the fields of this representation can be trivially provided to the constructor of java.awt.Color in Java; it can also be trivially provided to UIColor's +colorWithRed:green:blue:alpha method in iOS; and, with just a little work, it can be easily formatted into a CSS rgba() string in JavaScript.

This reference page doesn't have information about the absolute color space that should be used to interpret the RGB value—for example, sRGB, Adobe RGB, DCI-P3, and BT.2020. By default, applications should assume the sRGB color space.

When color equality needs to be decided, implementations, unless documented otherwise, treat two colors as equal if all their red, green, blue, and alpha values each differ by at most 1e-5.

Example (Java):

 import com.google.type.Color;

 // ...
 public static java.awt.Color fromProto(Color protocolor) {
   float alpha = protocolor.hasAlpha()
       ? protocolor.getAlpha().getValue()
       : 1.0;

   return new java.awt.Color(
       protocolor.getRed(),
       protocolor.getGreen(),
       protocolor.getBlue(),
       alpha);
 }

 public static Color toProto(java.awt.Color color) {
   float red = (float) color.getRed();
   float green = (float) color.getGreen();
   float blue = (float) color.getBlue();
   float denominator = 255.0;
   Color.Builder resultBuilder =
       Color
           .newBuilder()
           .setRed(red / denominator)
           .setGreen(green / denominator)
           .setBlue(blue / denominator);
   int alpha = color.getAlpha();
   if (alpha != 255) {
     result.setAlpha(
         FloatValue
             .newBuilder()
             .setValue(((float) alpha) / denominator)
             .build());
   }
   return resultBuilder.build();
 }
 // ...

Example (iOS / Obj-C):

 // ...
 static UIColor* fromProto(Color* protocolor) {
    float red = [protocolor red];
    float green = [protocolor green];
    float blue = [protocolor blue];
    FloatValue* alpha_wrapper = [protocolor alpha];
    float alpha = 1.0;
    if (alpha_wrapper != nil) {
      alpha = [alpha_wrapper value];
    }
    return [UIColor colorWithRed:red green:green blue:blue alpha:alpha];
 }

 static Color* toProto(UIColor* color) {
     CGFloat red, green, blue, alpha;
     if (![color getRed:&red green:&green blue:&blue alpha:&alpha]) {
       return nil;
     }
     Color* result = [[Color alloc] init];
     [result setRed:red];
     [result setGreen:green];
     [result setBlue:blue];
     if (alpha <= 0.9999) {
       [result setAlpha:floatWrapperWithValue(alpha)];
     }
     [result autorelease];
     return result;
}
// ...

Example (JavaScript):

// ...

var protoToCssColor = function(rgb_color) {
   var redFrac = rgb_color.red || 0.0;
   var greenFrac = rgb_color.green || 0.0;
   var blueFrac = rgb_color.blue || 0.0;
   var red = Math.floor(redFrac * 255);
   var green = Math.floor(greenFrac * 255);
   var blue = Math.floor(blueFrac * 255);

   if (!('alpha' in rgb_color)) {
      return rgbToCssColor(red, green, blue);
   }

   var alphaFrac = rgb_color.alpha.value || 0.0;
   var rgbParams = [red, green, blue].join(',');
   return ['rgba(', rgbParams, ',', alphaFrac, ')'].join('');
};

var rgbToCssColor = function(red, green, blue) {
  var rgbNumber = new Number((red << 16) | (green << 8) | blue);
  var hexString = rgbNumber.toString(16);
  var missingZeros = 6 - hexString.length;
  var resultBuilder = ['#'];
  for (var i = 0; i < missingZeros; i++) {
     resultBuilder.push('0');
  }
  resultBuilder.push(hexString);
  return resultBuilder.join('');
};

// ...
JSON representation 
{
  "red": number,
  "green": number,
  "blue": number,
  "alpha": number
}
Fields
red

number

The amount of red in the color as a value in the interval [0, 1].
green

number

The amount of green in the color as a value in the interval [0, 1].
blue

number

The amount of blue in the color as a value in the interval [0, 1].
alpha

number

The fraction of this color that should be applied to the pixel. That is, the final pixel color is defined by the equation:

pixel color = alpha * (this color) + (1.0 - alpha) * (background color)

This means that a value of 1.0 corresponds to a solid color, whereas a value of 0.0 corresponds to a completely transparent color. This uses a wrapper message rather than a simple float scalar so that it is possible to distinguish between a default value and the value being unset. If omitted, this color object is rendered as a solid color (as if the alpha value had been explicitly given a value of 1.0).

WrapStyle

Enum for different wrap styles.

Enums
WRAP_STYLE_UNSPECIFIED No wrap style specified.
NO_WRAP No wrap style.

ListContainer

Container for list items, where each list item can contain multiple TextFormatElement's.

JSON representation 
{
  "listNestLevel": string,
  "listType": enum (ListType),
  "listItems": [
    {
      object (ListItem)
    }
  ]
}
Fields
listNestLevel

string (int64 format)

Optional. The nest level of the list. Starts from 0 for the top level, and increases by 1 for each nested list.
listType

enum (ListType)

Optional. The type of the list.
listItems[]

object (ListItem)

Optional. A collection of list items.

ListType

Enum for different list types.

Enums
LIST_TYPE_UNSPECIFIED No list type specified.
ORDERED Ordered list.
UNORDERED Unordered list.

ListItem

A list item.

JSON representation 
{
  "textFormatElements": [
    {
      object (TextFormatElement)
    }
  ]
}
Fields
textFormatElements[]

object (TextFormatElement)

Optional. A collection of text format elements.