googleapis
Version:
Google APIs Client Library for Node.js
1,035 lines • 133 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 slides_v1 {
export interface Options extends GlobalOptions {
version: 'v1';
}
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;
}
/**
* Google Slides API
*
* Reads and writes Google Slides presentations.
*
* @example
* ```js
* const {google} = require('googleapis');
* const slides = google.slides('v1');
* ```
*/
export class Slides {
context: APIRequestContext;
presentations: Resource$Presentations;
constructor(options: GlobalOptions, google?: GoogleConfigurable);
}
/**
* AffineTransform uses a 3x3 matrix with an implied last row of [ 0 0 1 ] to transform source coordinates (x,y) into destination coordinates (x', y') according to: x' x = shear_y scale_y translate_y 1 [ 1 ] After transformation, x' = scale_x * x + shear_x * y + translate_x; y' = scale_y * y + shear_y * x + translate_y; This message is therefore composed of these six matrix elements.
*/
export interface Schema$AffineTransform {
/**
* The X coordinate scaling element.
*/
scaleX?: number | null;
/**
* The Y coordinate scaling element.
*/
scaleY?: number | null;
/**
* The X coordinate shearing element.
*/
shearX?: number | null;
/**
* The Y coordinate shearing element.
*/
shearY?: number | null;
/**
* The X coordinate translation element.
*/
translateX?: number | null;
/**
* The Y coordinate translation element.
*/
translateY?: number | null;
/**
* The units for translate elements.
*/
unit?: string | null;
}
/**
* The autofit properties of a Shape.
*/
export interface Schema$Autofit {
/**
* The autofit type of the shape. If the autofit type is AUTOFIT_TYPE_UNSPECIFIED, the autofit type is inherited from a parent placeholder if it exists. The field is automatically set to NONE if a request is made that might affect text fitting within its bounding text box. In this case the font_scale is applied to the font_size and the line_spacing_reduction is applied to the line_spacing. Both properties are also reset to default values.
*/
autofitType?: string | null;
/**
* The font scale applied to the shape. For shapes with autofit_type NONE or SHAPE_AUTOFIT, this value is the default value of 1. For TEXT_AUTOFIT, this value multiplied by the font_size gives the font size that is rendered in the editor. This property is read-only.
*/
fontScale?: number | null;
/**
* The line spacing reduction applied to the shape. For shapes with autofit_type NONE or SHAPE_AUTOFIT, this value is the default value of 0. For TEXT_AUTOFIT, this value subtracted from the line_spacing gives the line spacing that is rendered in the editor. This property is read-only.
*/
lineSpacingReduction?: number | null;
}
/**
* A TextElement kind that represents auto text.
*/
export interface Schema$AutoText {
/**
* The rendered content of this auto text, if available.
*/
content?: string | null;
/**
* The styling applied to this auto text.
*/
style?: Schema$TextStyle;
/**
* The type of this auto text.
*/
type?: string | null;
}
/**
* Request message for PresentationsService.BatchUpdatePresentation.
*/
export interface Schema$BatchUpdatePresentationRequest {
/**
* A list of updates to apply to the presentation.
*/
requests?: Schema$Request[];
/**
* Provides control over how write requests are executed.
*/
writeControl?: Schema$WriteControl;
}
/**
* Response message from a batch update.
*/
export interface Schema$BatchUpdatePresentationResponse {
/**
* The presentation the updates were applied to.
*/
presentationId?: string | null;
/**
* The reply of the updates. This maps 1:1 with the updates, although replies to some requests may be empty.
*/
replies?: Schema$Response[];
/**
* The updated write control after applying the request.
*/
writeControl?: Schema$WriteControl;
}
/**
* Describes the bullet of a paragraph.
*/
export interface Schema$Bullet {
/**
* The paragraph specific text style applied to this bullet.
*/
bulletStyle?: Schema$TextStyle;
/**
* The rendered bullet glyph for this paragraph.
*/
glyph?: string | null;
/**
* The ID of the list this paragraph belongs to.
*/
listId?: string | null;
/**
* The nesting level of this paragraph in the list.
*/
nestingLevel?: number | null;
}
/**
* The palette of predefined colors for a page.
*/
export interface Schema$ColorScheme {
/**
* The ThemeColorType and corresponding concrete color pairs.
*/
colors?: Schema$ThemeColorPair[];
}
/**
* A color and position in a gradient band.
*/
export interface Schema$ColorStop {
/**
* The alpha value of this color in the gradient band. Defaults to 1.0, fully opaque.
*/
alpha?: number | null;
/**
* The color of the gradient stop.
*/
color?: Schema$OpaqueColor;
/**
* The relative position of the color stop in the gradient band measured in percentage. The value should be in the interval [0.0, 1.0].
*/
position?: number | null;
}
/**
* Creates an image.
*/
export interface Schema$CreateImageRequest {
/**
* The element properties for the image. When the aspect ratio of the provided size does not match the image aspect ratio, the image is scaled and centered with respect to the size in order to maintain the aspect ratio. The provided transform is applied after this operation. The PageElementProperties.size property is optional. If you don't specify the size, the default size of the image is used. The PageElementProperties.transform property is optional. If you don't specify a transform, the image will be placed at the top-left corner of the page.
*/
elementProperties?: Schema$PageElementProperties;
/**
* A user-supplied object ID. If you specify an ID, it must be unique among all pages and page elements in the presentation. The ID must start with an alphanumeric character or an underscore (matches regex `[a-zA-Z0-9_]`); remaining characters may include those as well as a hyphen or colon (matches regex `[a-zA-Z0-9_-:]`). The length of the ID must not be less than 5 or greater than 50. If you don't specify an ID, a unique one is generated.
*/
objectId?: string | null;
/**
* The image URL. The image is fetched once at insertion time and a copy is stored for display inside the presentation. Images must be less than 50 MB in size, can't exceed 25 megapixels, and must be in one of PNG, JPEG, or GIF formats. The provided URL must be publicly accessible and up to 2 KB in length. The URL is saved with the image, and exposed through the Image.source_url field.
*/
url?: string | null;
}
/**
* The result of creating an image.
*/
export interface Schema$CreateImageResponse {
/**
* The object ID of the created image.
*/
objectId?: string | null;
}
/**
* Creates a line.
*/
export interface Schema$CreateLineRequest {
/**
* The category of the line to be created. The exact line type created is determined based on the category and how it's routed to connect to other page elements. If you specify both a `category` and a `line_category`, the `category` takes precedence. If you do not specify a value for `category`, but specify a value for `line_category`, then the specified `line_category` value is used. If you do not specify either, then STRAIGHT is used.
*/
category?: string | null;
/**
* The element properties for the line.
*/
elementProperties?: Schema$PageElementProperties;
/**
* The category of the line to be created. *Deprecated*: use `category` instead. The exact line type created is determined based on the category and how it's routed to connect to other page elements. If you specify both a `category` and a `line_category`, the `category` takes precedence.
*/
lineCategory?: string | null;
/**
* A user-supplied object ID. If you specify an ID, it must be unique among all pages and page elements in the presentation. The ID must start with an alphanumeric character or an underscore (matches regex `[a-zA-Z0-9_]`); remaining characters may include those as well as a hyphen or colon (matches regex `[a-zA-Z0-9_-:]`). The length of the ID must not be less than 5 or greater than 50. If you don't specify an ID, a unique one is generated.
*/
objectId?: string | null;
}
/**
* The result of creating a line.
*/
export interface Schema$CreateLineResponse {
/**
* The object ID of the created line.
*/
objectId?: string | null;
}
/**
* Creates bullets for all of the paragraphs that overlap with the given text index range. The nesting level of each paragraph will be determined by counting leading tabs in front of each paragraph. To avoid excess space between the bullet and the corresponding paragraph, these leading tabs are removed by this request. This may change the indices of parts of the text. If the paragraph immediately before paragraphs being updated is in a list with a matching preset, the paragraphs being updated are added to that preceding list.
*/
export interface Schema$CreateParagraphBulletsRequest {
/**
* The kinds of bullet glyphs to be used. Defaults to the `BULLET_DISC_CIRCLE_SQUARE` preset.
*/
bulletPreset?: string | null;
/**
* The optional table cell location if the text to be modified is in a table cell. If present, the object_id must refer to a table.
*/
cellLocation?: Schema$TableCellLocation;
/**
* The object ID of the shape or table containing the text to add bullets to.
*/
objectId?: string | null;
/**
* The range of text to apply the bullet presets to, based on TextElement indexes.
*/
textRange?: Schema$Range;
}
/**
* Creates a new shape.
*/
export interface Schema$CreateShapeRequest {
/**
* The element properties for the shape.
*/
elementProperties?: Schema$PageElementProperties;
/**
* A user-supplied object ID. If you specify an ID, it must be unique among all pages and page elements in the presentation. The ID must start with an alphanumeric character or an underscore (matches regex `[a-zA-Z0-9_]`); remaining characters may include those as well as a hyphen or colon (matches regex `[a-zA-Z0-9_-:]`). The length of the ID must not be less than 5 or greater than 50. If empty, a unique identifier will be generated.
*/
objectId?: string | null;
/**
* The shape type.
*/
shapeType?: string | null;
}
/**
* The result of creating a shape.
*/
export interface Schema$CreateShapeResponse {
/**
* The object ID of the created shape.
*/
objectId?: string | null;
}
/**
* Creates an embedded Google Sheets chart. NOTE: Chart creation requires at least one of the spreadsheets.readonly, spreadsheets, drive.readonly, drive.file, or drive OAuth scopes.
*/
export interface Schema$CreateSheetsChartRequest {
/**
* The ID of the specific chart in the Google Sheets spreadsheet.
*/
chartId?: number | null;
/**
* The element properties for the chart. When the aspect ratio of the provided size does not match the chart aspect ratio, the chart is scaled and centered with respect to the size in order to maintain aspect ratio. The provided transform is applied after this operation.
*/
elementProperties?: Schema$PageElementProperties;
/**
* The mode with which the chart is linked to the source spreadsheet. When not specified, the chart will be an image that is not linked.
*/
linkingMode?: string | null;
/**
* A user-supplied object ID. If specified, the ID must be unique among all pages and page elements in the presentation. The ID should start with a word character [a-zA-Z0-9_] and then followed by any number of the following characters [a-zA-Z0-9_-:]. The length of the ID should not be less than 5 or greater than 50. If empty, a unique identifier will be generated.
*/
objectId?: string | null;
/**
* The ID of the Google Sheets spreadsheet that contains the chart. You might need to add a resource key to the HTTP header for a subset of old files. For more information, see [Access link-shared files using resource keys](https://developers.google.com/drive/api/v3/resource-keys).
*/
spreadsheetId?: string | null;
}
/**
* The result of creating an embedded Google Sheets chart.
*/
export interface Schema$CreateSheetsChartResponse {
/**
* The object ID of the created chart.
*/
objectId?: string | null;
}
/**
* Creates a slide.
*/
export interface Schema$CreateSlideRequest {
/**
* The optional zero-based index indicating where to insert the slides. If you don't specify an index, the slide is created at the end.
*/
insertionIndex?: number | null;
/**
* A user-supplied object ID. If you specify an ID, it must be unique among all pages and page elements in the presentation. The ID must start with an alphanumeric character or an underscore (matches regex `[a-zA-Z0-9_]`); remaining characters may include those as well as a hyphen or colon (matches regex `[a-zA-Z0-9_-:]`). The ID length must be between 5 and 50 characters, inclusive. If you don't specify an ID, a unique one is generated.
*/
objectId?: string | null;
/**
* An optional list of object ID mappings from the placeholder(s) on the layout to the placeholders that are created on the slide from the specified layout. Can only be used when `slide_layout_reference` is specified.
*/
placeholderIdMappings?: Schema$LayoutPlaceholderIdMapping[];
/**
* Layout reference of the slide to be inserted, based on the *current master*, which is one of the following: - The master of the previous slide index. - The master of the first slide, if the insertion_index is zero. - The first master in the presentation, if there are no slides. If the LayoutReference is not found in the current master, a 400 bad request error is returned. If you don't specify a layout reference, the slide uses the predefined `BLANK` layout.
*/
slideLayoutReference?: Schema$LayoutReference;
}
/**
* The result of creating a slide.
*/
export interface Schema$CreateSlideResponse {
/**
* The object ID of the created slide.
*/
objectId?: string | null;
}
/**
* Creates a new table.
*/
export interface Schema$CreateTableRequest {
/**
* Number of columns in the table.
*/
columns?: number | null;
/**
* The element properties for the table. The table will be created at the provided size, subject to a minimum size. If no size is provided, the table will be automatically sized. Table transforms must have a scale of 1 and no shear components. If no transform is provided, the table will be centered on the page.
*/
elementProperties?: Schema$PageElementProperties;
/**
* A user-supplied object ID. If you specify an ID, it must be unique among all pages and page elements in the presentation. The ID must start with an alphanumeric character or an underscore (matches regex `[a-zA-Z0-9_]`); remaining characters may include those as well as a hyphen or colon (matches regex `[a-zA-Z0-9_-:]`). The length of the ID must not be less than 5 or greater than 50. If you don't specify an ID, a unique one is generated.
*/
objectId?: string | null;
/**
* Number of rows in the table.
*/
rows?: number | null;
}
/**
* The result of creating a table.
*/
export interface Schema$CreateTableResponse {
/**
* The object ID of the created table.
*/
objectId?: string | null;
}
/**
* Creates a video. NOTE: Creating a video from Google Drive requires that the requesting app have at least one of the drive, drive.readonly, or drive.file OAuth scopes.
*/
export interface Schema$CreateVideoRequest {
/**
* The element properties for the video. The PageElementProperties.size property is optional. If you don't specify a size, a default size is chosen by the server. The PageElementProperties.transform property is optional. The transform must not have shear components. If you don't specify a transform, the video will be placed at the top left corner of the page.
*/
elementProperties?: Schema$PageElementProperties;
/**
* The video source's unique identifier for this video. e.g. For YouTube video https://www.youtube.com/watch?v=7U3axjORYZ0, the ID is 7U3axjORYZ0. For a Google Drive video https://drive.google.com/file/d/1xCgQLFTJi5_Xl8DgW_lcUYq5e-q6Hi5Q the ID is 1xCgQLFTJi5_Xl8DgW_lcUYq5e-q6Hi5Q. To access a Google Drive video file, you might need to add a resource key to the HTTP header for a subset of old files. For more information, see [Access link-shared files using resource keys](https://developers.google.com/drive/api/v3/resource-keys).
*/
id?: string | null;
/**
* A user-supplied object ID. If you specify an ID, it must be unique among all pages and page elements in the presentation. The ID must start with an alphanumeric character or an underscore (matches regex `[a-zA-Z0-9_]`); remaining characters may include those as well as a hyphen or colon (matches regex `[a-zA-Z0-9_-:]`). The length of the ID must not be less than 5 or greater than 50. If you don't specify an ID, a unique one is generated.
*/
objectId?: string | null;
/**
* The video source.
*/
source?: string | null;
}
/**
* The result of creating a video.
*/
export interface Schema$CreateVideoResponse {
/**
* The object ID of the created video.
*/
objectId?: string | null;
}
/**
* The crop properties of an object enclosed in a container. For example, an Image. The crop properties is represented by the offsets of four edges which define a crop rectangle. The offsets are measured in percentage from the corresponding edges of the object's original bounding rectangle towards inside, relative to the object's original dimensions. - If the offset is in the interval (0, 1), the corresponding edge of crop rectangle is positioned inside of the object's original bounding rectangle. - If the offset is negative or greater than 1, the corresponding edge of crop rectangle is positioned outside of the object's original bounding rectangle. - If the left edge of the crop rectangle is on the right side of its right edge, the object will be flipped horizontally. - If the top edge of the crop rectangle is below its bottom edge, the object will be flipped vertically. - If all offsets and rotation angle is 0, the object is not cropped. After cropping, the content in the crop rectangle will be stretched to fit its container.
*/
export interface Schema$CropProperties {
/**
* The rotation angle of the crop window around its center, in radians. Rotation angle is applied after the offset.
*/
angle?: number | null;
/**
* The offset specifies the bottom edge of the crop rectangle that is located above the original bounding rectangle bottom edge, relative to the object's original height.
*/
bottomOffset?: number | null;
/**
* The offset specifies the left edge of the crop rectangle that is located to the right of the original bounding rectangle left edge, relative to the object's original width.
*/
leftOffset?: number | null;
/**
* The offset specifies the right edge of the crop rectangle that is located to the left of the original bounding rectangle right edge, relative to the object's original width.
*/
rightOffset?: number | null;
/**
* The offset specifies the top edge of the crop rectangle that is located below the original bounding rectangle top edge, relative to the object's original height.
*/
topOffset?: number | null;
}
/**
* Deletes an object, either pages or page elements, from the presentation.
*/
export interface Schema$DeleteObjectRequest {
/**
* The object ID of the page or page element to delete. If after a delete operation a group contains only 1 or no page elements, the group is also deleted. If a placeholder is deleted on a layout, any empty inheriting placeholders are also deleted.
*/
objectId?: string | null;
}
/**
* Deletes bullets from all of the paragraphs that overlap with the given text index range. The nesting level of each paragraph will be visually preserved by adding indent to the start of the corresponding paragraph.
*/
export interface Schema$DeleteParagraphBulletsRequest {
/**
* The optional table cell location if the text to be modified is in a table cell. If present, the object_id must refer to a table.
*/
cellLocation?: Schema$TableCellLocation;
/**
* The object ID of the shape or table containing the text to delete bullets from.
*/
objectId?: string | null;
/**
* The range of text to delete bullets from, based on TextElement indexes.
*/
textRange?: Schema$Range;
}
/**
* Deletes a column from a table.
*/
export interface Schema$DeleteTableColumnRequest {
/**
* The reference table cell location from which a column will be deleted. The column this cell spans will be deleted. If this is a merged cell, multiple columns will be deleted. If no columns remain in the table after this deletion, the whole table is deleted.
*/
cellLocation?: Schema$TableCellLocation;
/**
* The table to delete columns from.
*/
tableObjectId?: string | null;
}
/**
* Deletes a row from a table.
*/
export interface Schema$DeleteTableRowRequest {
/**
* The reference table cell location from which a row will be deleted. The row this cell spans will be deleted. If this is a merged cell, multiple rows will be deleted. If no rows remain in the table after this deletion, the whole table is deleted.
*/
cellLocation?: Schema$TableCellLocation;
/**
* The table to delete rows from.
*/
tableObjectId?: string | null;
}
/**
* Deletes text from a shape or a table cell.
*/
export interface Schema$DeleteTextRequest {
/**
* The optional table cell location if the text is to be deleted from a table cell. If present, the object_id must refer to a table.
*/
cellLocation?: Schema$TableCellLocation;
/**
* The object ID of the shape or table from which the text will be deleted.
*/
objectId?: string | null;
/**
* The range of text to delete, based on TextElement indexes. There is always an implicit newline character at the end of a shape's or table cell's text that cannot be deleted. `Range.Type.ALL` will use the correct bounds, but care must be taken when specifying explicit bounds for range types `FROM_START_INDEX` and `FIXED_RANGE`. For example, if the text is "ABC", followed by an implicit newline, then the maximum value is 2 for `text_range.start_index` and 3 for `text_range.end_index`. Deleting text that crosses a paragraph boundary may result in changes to paragraph styles and lists as the two paragraphs are merged. Ranges that include only one code unit of a surrogate pair are expanded to include both code units.
*/
textRange?: Schema$Range;
}
/**
* A magnitude in a single direction in the specified units.
*/
export interface Schema$Dimension {
/**
* The magnitude.
*/
magnitude?: number | null;
/**
* The units for magnitude.
*/
unit?: string | null;
}
/**
* Duplicates a slide or page element. When duplicating a slide, the duplicate slide will be created immediately following the specified slide. When duplicating a page element, the duplicate will be placed on the same page at the same position as the original.
*/
export interface Schema$DuplicateObjectRequest {
/**
* The ID of the object to duplicate.
*/
objectId?: string | null;
/**
* The object being duplicated may contain other objects, for example when duplicating a slide or a group page element. This map defines how the IDs of duplicated objects are generated: the keys are the IDs of the original objects and its values are the IDs that will be assigned to the corresponding duplicate object. The ID of the source object's duplicate may be specified in this map as well, using the same value of the `object_id` field as a key and the newly desired ID as the value. All keys must correspond to existing IDs in the presentation. All values must be unique in the presentation and must start with an alphanumeric character or an underscore (matches regex `[a-zA-Z0-9_]`); remaining characters may include those as well as a hyphen or colon (matches regex `[a-zA-Z0-9_-:]`). The length of the new ID must not be less than 5 or greater than 50. If any IDs of source objects are omitted from the map, a new random ID will be assigned. If the map is empty or unset, all duplicate objects will receive a new random ID.
*/
objectIds?: {
[key: string]: string;
} | null;
}
/**
* The response of duplicating an object.
*/
export interface Schema$DuplicateObjectResponse {
/**
* The ID of the new duplicate object.
*/
objectId?: string | null;
}
/**
* A PageElement kind representing a joined collection of PageElements.
*/
export interface Schema$Group {
/**
* The collection of elements in the group. The minimum size of a group is 2.
*/
children?: Schema$PageElement[];
}
/**
* Groups objects to create an object group. For example, groups PageElements to create a Group on the same page as all the children.
*/
export interface Schema$GroupObjectsRequest {
/**
* The object IDs of the objects to group. Only page elements can be grouped. There should be at least two page elements on the same page that are not already in another group. Some page elements, such as videos, tables and placeholders cannot be grouped.
*/
childrenObjectIds?: string[] | null;
/**
* A user-supplied object ID for the group to be created. If you specify an ID, it must be unique among all pages and page elements in the presentation. The ID must start with an alphanumeric character or an underscore (matches regex `[a-zA-Z0-9_]`); remaining characters may include those as well as a hyphen or colon (matches regex `[a-zA-Z0-9_-:]`). The length of the ID must not be less than 5 or greater than 50. If you don't specify an ID, a unique one is generated.
*/
groupObjectId?: string | null;
}
/**
* The result of grouping objects.
*/
export interface Schema$GroupObjectsResponse {
/**
* The object ID of the created group.
*/
objectId?: string | null;
}
/**
* A PageElement kind representing an image.
*/
export interface Schema$Image {
/**
* An URL to an image with a default lifetime of 30 minutes. This URL is tagged with the account of the requester. Anyone with the URL effectively accesses the image as the original requester. Access to the image may be lost if the presentation's sharing settings change.
*/
contentUrl?: string | null;
/**
* The properties of the image.
*/
imageProperties?: Schema$ImageProperties;
/**
* Placeholders are page elements that inherit from corresponding placeholders on layouts and masters. If set, the image is a placeholder image and any inherited properties can be resolved by looking at the parent placeholder identified by the Placeholder.parent_object_id field.
*/
placeholder?: Schema$Placeholder;
/**
* The source URL is the URL used to insert the image. The source URL can be empty.
*/
sourceUrl?: string | null;
}
/**
* The properties of the Image.
*/
export interface Schema$ImageProperties {
/**
* The brightness effect of the image. The value should be in the interval [-1.0, 1.0], where 0 means no effect. This property is read-only.
*/
brightness?: number | null;
/**
* The contrast effect of the image. The value should be in the interval [-1.0, 1.0], where 0 means no effect. This property is read-only.
*/
contrast?: number | null;
/**
* The crop properties of the image. If not set, the image is not cropped. This property is read-only.
*/
cropProperties?: Schema$CropProperties;
/**
* The hyperlink destination of the image. If unset, there is no link.
*/
link?: Schema$Link;
/**
* The outline of the image. If not set, the image has no outline.
*/
outline?: Schema$Outline;
/**
* The recolor effect of the image. If not set, the image is not recolored. This property is read-only.
*/
recolor?: Schema$Recolor;
/**
* The shadow of the image. If not set, the image has no shadow. This property is read-only.
*/
shadow?: Schema$Shadow;
/**
* The transparency effect of the image. The value should be in the interval [0.0, 1.0], where 0 means no effect and 1 means completely transparent. This property is read-only.
*/
transparency?: number | null;
}
/**
* Inserts columns into a table. Other columns in the table will be resized to fit the new column.
*/
export interface Schema$InsertTableColumnsRequest {
/**
* The reference table cell location from which columns will be inserted. A new column will be inserted to the left (or right) of the column where the reference cell is. If the reference cell is a merged cell, a new column will be inserted to the left (or right) of the merged cell.
*/
cellLocation?: Schema$TableCellLocation;
/**
* Whether to insert new columns to the right of the reference cell location. - `True`: insert to the right. - `False`: insert to the left.
*/
insertRight?: boolean | null;
/**
* The number of columns to be inserted. Maximum 20 per request.
*/
number?: number | null;
/**
* The table to insert columns into.
*/
tableObjectId?: string | null;
}
/**
* Inserts rows into a table.
*/
export interface Schema$InsertTableRowsRequest {
/**
* The reference table cell location from which rows will be inserted. A new row will be inserted above (or below) the row where the reference cell is. If the reference cell is a merged cell, a new row will be inserted above (or below) the merged cell.
*/
cellLocation?: Schema$TableCellLocation;
/**
* Whether to insert new rows below the reference cell location. - `True`: insert below the cell. - `False`: insert above the cell.
*/
insertBelow?: boolean | null;
/**
* The number of rows to be inserted. Maximum 20 per request.
*/
number?: number | null;
/**
* The table to insert rows into.
*/
tableObjectId?: string | null;
}
/**
* Inserts text into a shape or a table cell.
*/
export interface Schema$InsertTextRequest {
/**
* The optional table cell location if the text is to be inserted into a table cell. If present, the object_id must refer to a table.
*/
cellLocation?: Schema$TableCellLocation;
/**
* The index where the text will be inserted, in Unicode code units, based on TextElement indexes. The index is zero-based and is computed from the start of the string. The index may be adjusted to prevent insertions inside Unicode grapheme clusters. In these cases, the text will be inserted immediately after the grapheme cluster.
*/
insertionIndex?: number | null;
/**
* The object ID of the shape or table where the text will be inserted.
*/
objectId?: string | null;
/**
* The text to be inserted. Inserting a newline character will implicitly create a new ParagraphMarker at that index. The paragraph style of the new paragraph will be copied from the paragraph at the current insertion index, including lists and bullets. Text styles for inserted text will be determined automatically, generally preserving the styling of neighboring text. In most cases, the text will be added to the TextRun that exists at the insertion index. Some control characters (U+0000-U+0008, U+000C-U+001F) and characters from the Unicode Basic Multilingual Plane Private Use Area (U+E000-U+F8FF) will be stripped out of the inserted text.
*/
text?: string | null;
}
/**
* The user-specified ID mapping for a placeholder that will be created on a slide from a specified layout.
*/
export interface Schema$LayoutPlaceholderIdMapping {
/**
* The placeholder on a layout that will be applied to a slide. Only type and index are needed. For example, a predefined `TITLE_AND_BODY` layout may usually have a TITLE placeholder with index 0 and a BODY placeholder with index 0.
*/
layoutPlaceholder?: Schema$Placeholder;
/**
* The object ID of the placeholder on a layout that will be applied to a slide.
*/
layoutPlaceholderObjectId?: string | null;
/**
* A user-supplied object ID for the placeholder identified above that to be created onto a slide. If you specify an ID, it must be unique among all pages and page elements in the presentation. The ID must start with an alphanumeric character or an underscore (matches regex `[a-zA-Z0-9_]`); remaining characters may include those as well as a hyphen or colon (matches regex `[a-zA-Z0-9_-:]`). The length of the ID must not be less than 5 or greater than 50. If you don't specify an ID, a unique one is generated.
*/
objectId?: string | null;
}
/**
* The properties of Page are only relevant for pages with page_type LAYOUT.
*/
export interface Schema$LayoutProperties {
/**
* The human-readable name of the layout.
*/
displayName?: string | null;
/**
* The object ID of the master that this layout is based on.
*/
masterObjectId?: string | null;
/**
* The name of the layout.
*/
name?: string | null;
}
/**
* Slide layout reference. This may reference either: - A predefined layout - One of the layouts in the presentation.
*/
export interface Schema$LayoutReference {
/**
* Layout ID: the object ID of one of the layouts in the presentation.
*/
layoutId?: string | null;
/**
* Predefined layout.
*/
predefinedLayout?: string | null;
}
/**
* A PageElement kind representing a non-connector line, straight connector, curved connector, or bent connector.
*/
export interface Schema$Line {
/**
* The category of the line. It matches the `category` specified in CreateLineRequest, and can be updated with UpdateLineCategoryRequest.
*/
lineCategory?: string | null;
/**
* The properties of the line.
*/
lineProperties?: Schema$LineProperties;
/**
* The type of the line.
*/
lineType?: string | null;
}
/**
* The properties for one end of a Line connection.
*/
export interface Schema$LineConnection {
/**
* The object ID of the connected page element. Some page elements, such as groups, tables, and lines do not have connection sites and therefore cannot be connected to a connector line.
*/
connectedObjectId?: string | null;
/**
* The index of the connection site on the connected page element. In most cases, it corresponds to the predefined connection site index from the ECMA-376 standard. More information on those connection sites can be found in the description of the "cnx" attribute in section 20.1.9.9 and Annex H. "Predefined DrawingML Shape and Text Geometries" of "Office Open XML File Formats-Fundamentals and Markup Language Reference", part 1 of [ECMA-376 5th edition] (http://www.ecma-international.org/publications/standards/Ecma-376.htm). The position of each connection site can also be viewed from Slides editor.
*/
connectionSiteIndex?: number | null;
}
/**
* The fill of the line.
*/
export interface Schema$LineFill {
/**
* Solid color fill.
*/
solidFill?: Schema$SolidFill;
}
/**
* The properties of the Line. When unset, these fields default to values that match the appearance of new lines created in the Slides editor.
*/
export interface Schema$LineProperties {
/**
* The dash style of the line.
*/
dashStyle?: string | null;
/**
* The style of the arrow at the end of the line.
*/
endArrow?: string | null;
/**
* The connection at the end of the line. If unset, there is no connection. Only lines with a Type indicating it is a "connector" can have an `end_connection`.
*/
endConnection?: Schema$LineConnection;
/**
* The fill of the line. The default line fill matches the defaults for new lines created in the Slides editor.
*/
lineFill?: Schema$LineFill;
/**
* The hyperlink destination of the line. If unset, there is no link.
*/
link?: Schema$Link;
/**
* The style of the arrow at the beginning of the line.
*/
startArrow?: string | null;
/**
* The connection at the beginning of the line. If unset, there is no connection. Only lines with a Type indicating it is a "connector" can have a `start_connection`.
*/
startConnection?: Schema$LineConnection;
/**
* The thickness of the line.
*/
weight?: Schema$Dimension;
}
/**
* A hypertext link.
*/
export interface Schema$Link {
/**
* If set, indicates this is a link to the specific page in this presentation with this ID. A page with this ID may not exist.
*/
pageObjectId?: string | null;
/**
* If set, indicates this is a link to a slide in this presentation, addressed by its position.
*/
relativeLink?: string | null;
/**
* If set, indicates this is a link to the slide at this zero-based index in the presentation. There may not be a slide at this index.
*/
slideIndex?: number | null;
/**
* If set, indicates this is a link to the external web page at this URL.
*/
url?: string | null;
}
/**
* A List describes the look and feel of bullets belonging to paragraphs associated with a list. A paragraph that is part of a list has an implicit reference to that list's ID.
*/
export interface Schema$List {
/**
* The ID of the list.
*/
listId?: string | null;
/**
* A map of nesting levels to the properties of bullets at the associated level. A list has at most nine levels of nesting, so the possible values for the keys of this map are 0 through 8, inclusive.
*/
nestingLevel?: {
[key: string]: Schema$NestingLevel;
} | null;
}
/**
* The properties of Page that are only relevant for pages with page_type MASTER.
*/
export interface Schema$MasterProperties {
/**
* The human-readable name of the master.
*/
displayName?: string | null;
}
/**
* Merges cells in a Table.
*/
export interface Schema$MergeTableCellsRequest {
/**
* The object ID of the table.
*/
objectId?: string | null;
/**
* The table range specifying which cells of the table to merge. Any text in the cells being merged will be concatenated and stored in the upper-left ("head") cell of the range. If the range is non-rectangular (which can occur in some cases where the range covers cells that are already merged), a 400 bad request error is returned.
*/
tableRange?: Schema$TableRange;
}
/**
* Contains properties describing the look and feel of a list bullet at a given level of nesting.
*/
export interface Schema$NestingLevel {
/**
* The style of a bullet at this level of nesting.
*/
bulletStyle?: Schema$TextStyle;
}
/**
* The properties of Page that are only relevant for pages with page_type NOTES.
*/
export interface Schema$NotesProperties {
/**
* The object ID of the shape on this notes page that contains the speaker notes for the corresponding slide. The actual shape may not always exist on the notes page. Inserting text using this object ID will automatically create the shape. In this case, the actual shape may have different object ID. The `GetPresentation` or `GetPage` action will always return the latest object ID.
*/
speakerNotesObjectId?: string | null;
}
/**
* A themeable solid color value.
*/
export interface Schema$OpaqueColor {
/**
* An opaque RGB color.
*/
rgbColor?: Schema$RgbColor;
/**
* An opaque theme color.
*/
themeColor?: string | null;
}
/**
* A color that can either be fully opaque or fully transparent.
*/
export interface Schema$OptionalColor {
/**
* If set, this will be used as an opaque color. If unset, this represents a transparent color.
*/
opaqueColor?: Schema$OpaqueColor;
}
/**
* The outline of a PageElement. If these fields are unset, they may be inherited from a parent placeholder if it exists. If there is no parent, the fields will default to the value used for new page elements created in the Slides editor, which may depend on the page element kind.
*/
export interface Schema$Outline {
/**
* The dash style of the outline.
*/
dashStyle?: string | null;
/**
* The fill of the outline.
*/
outlineFill?: Schema$OutlineFill;
/**
* The outline property state. Updating the outline on a page element will implicitly update this field to `RENDERED`, unless another value is specified in the same request. To have no outline on a page element, set this field to `NOT_RENDERED`. In this case, any other outline fields set in the same request will be ignored.
*/
propertyState?: string | null;
/**
* The thickness of the outline.
*/
weight?: Schema$Dimension;
}
/**
* The fill of the outline.
*/
export interface Schema$OutlineFill {
/**
* Solid color fill.
*/
solidFill?: Schema$SolidFill;
}
/**
* A page in a presentation.
*/
export interface Schema$Page {
/**
* Layout specific properties. Only set if page_type = LAYOUT.
*/
layoutProperties?: Schema$LayoutProperties;
/**
* Master specific properties. Only set if page_type = MASTER.
*/
masterProperties?: Schema$MasterProperties;
/**
* Notes specific properties. Only set if page_type = NOTES.
*/
notesProperties?: Schema$NotesProperties;
/**
* The object ID for this page. Object IDs used by Page and PageElement share the same namespace.
*/
objectId?: string | null;
/**
* The page elements rendered on the page.
*/
pageElements?: Schema$PageElement[];
/**
* The properties of the page.
*/
pageProperties?: Schema$PageProperties;
/**
* The type of the page.
*/
pageType?: string | null;
/**
* Output only. The revision ID of the presentation. Can be used in update requests to assert the presentation revision hasn't changed since the last read operation. Only populated if the user has edit access to the presentation. The revision ID is not a sequential number but an opaque string. The format of the revision ID might change over time. A returned revision ID is only guaranteed to be valid for 24 hours after it has been returned and cannot be shared across users. If the revision ID is unchanged between calls, then the presentation has not changed. Conversely, a changed ID (for the same presentation and user) usually means the presentation has been updated. However, a changed ID can also be due to internal factors such as ID format changes.
*/
revisionId?: string | null;
/**
* Slide specific properties. Only set if page_type = SLIDE.
*/
slideProperties?: Schema$SlideProperties;
}
/**
* The page background fill.
*/
export interface Schema$PageBackgroundFill {
/**
* The background fill property state. Updating the fill on a page will implicitly update this field to `RENDERED`, unless another value is specified in the same request. To have no fill on a page, set this field to `NOT_RENDERED`. In this case, any other fill fields set in the same request will be ignored.
*/
propertyState?: string | null;
/**
* Solid color fill.
*/
solidFill?: Schema$SolidFill;
/**
* Stretched picture fill.
*/
stretchedPictureFill?: Schema$Stretche