googleapis
Version:
Google APIs Client Library for Node.js
1,099 lines • 129 kB
TypeScript
/**
* Copyright 2019 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { OAuth2Client, JWT, Compute, UserRefreshClient } from 'google-auth-library';
import { GoogleConfigurable, MethodOptions, GlobalOptions, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
import { GaxiosPromise } from 'gaxios';
export declare namespace slides_v1 {
interface Options extends GlobalOptions {
version: 'v1';
}
interface StandardParameters {
/**
* 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
* const {google} = require('googleapis');
* const slides = google.slides('v1');
*
* @namespace slides
* @type {Function}
* @version v1
* @variation v1
* @param {object=} options Options for Slides
*/
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.
*/
interface Schema$AffineTransform {
/**
* The X coordinate scaling element.
*/
scaleX?: number;
/**
* The Y coordinate scaling element.
*/
scaleY?: number;
/**
* The X coordinate shearing element.
*/
shearX?: number;
/**
* The Y coordinate shearing element.
*/
shearY?: number;
/**
* The X coordinate translation element.
*/
translateX?: number;
/**
* The Y coordinate translation element.
*/
translateY?: number;
/**
* The units for translate elements.
*/
unit?: string;
}
/**
* A TextElement kind that represents auto text.
*/
interface Schema$AutoText {
/**
* The rendered content of this auto text, if available.
*/
content?: string;
/**
* The styling applied to this auto text.
*/
style?: Schema$TextStyle;
/**
* The type of this auto text.
*/
type?: string;
}
/**
* Request message for PresentationsService.BatchUpdatePresentation.
*/
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.
*/
interface Schema$BatchUpdatePresentationResponse {
/**
* The presentation the updates were applied to.
*/
presentationId?: string;
/**
* 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.
*/
interface Schema$Bullet {
/**
* The paragraph specific text style applied to this bullet.
*/
bulletStyle?: Schema$TextStyle;
/**
* The rendered bullet glyph for this paragraph.
*/
glyph?: string;
/**
* The ID of the list this paragraph belongs to.
*/
listId?: string;
/**
* The nesting level of this paragraph in the list.
*/
nestingLevel?: number;
}
/**
* The palette of predefined colors for a page.
*/
interface Schema$ColorScheme {
/**
* The ThemeColorType and corresponding concrete color pairs.
*/
colors?: Schema$ThemeColorPair[];
}
/**
* A color and position in a gradient band.
*/
interface Schema$ColorStop {
/**
* The alpha value of this color in the gradient band. Defaults to 1.0, fully opaque.
*/
alpha?: number;
/**
* 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;
}
/**
* Creates an image.
*/
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 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;
/**
* 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 50MB in size, cannot exceed 25 megapixels, and must be in one of PNG, JPEG, or GIF format. The provided URL can be at most 2 kB in length. The URL itself is saved with the image, and exposed via the Image.source_url field.
*/
url?: string;
}
/**
* The result of creating an image.
*/
interface Schema$CreateImageResponse {
/**
* The object ID of the created image.
*/
objectId?: string;
}
/**
* Creates a line.
*/
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;
/**
* The element properties for the line.
*/
elementProperties?: Schema$PageElementProperties;
/**
* The category of the line to be created. <b>Deprecated</b>: 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;
/**
* 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;
}
/**
* The result of creating a line.
*/
interface Schema$CreateLineResponse {
/**
* The object ID of the created line.
*/
objectId?: string;
}
/**
* 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.
*/
interface Schema$CreateParagraphBulletsRequest {
/**
* The kinds of bullet glyphs to be used. Defaults to the `BULLET_DISC_CIRCLE_SQUARE` preset.
*/
bulletPreset?: string;
/**
* 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;
/**
* The range of text to apply the bullet presets to, based on TextElement indexes.
*/
textRange?: Schema$Range;
}
/**
* Creates a new shape.
*/
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;
/**
* The shape type.
*/
shapeType?: string;
}
/**
* The result of creating a shape.
*/
interface Schema$CreateShapeResponse {
/**
* The object ID of the created shape.
*/
objectId?: string;
}
/**
* 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.
*/
interface Schema$CreateSheetsChartRequest {
/**
* The ID of the specific chart in the Google Sheets spreadsheet.
*/
chartId?: number;
/**
* 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;
/**
* 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;
/**
* The ID of the Google Sheets spreadsheet that contains the chart.
*/
spreadsheetId?: string;
}
/**
* The result of creating an embedded Google Sheets chart.
*/
interface Schema$CreateSheetsChartResponse {
/**
* The object ID of the created chart.
*/
objectId?: string;
}
/**
* Creates a new slide.
*/
interface Schema$CreateSlideRequest {
/**
* The optional zero-based index indicating where to insert the slides. If you don't specify an index, the new slide is created at the end.
*/
insertionIndex?: number;
/**
* 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;
/**
* An optional list of object ID mappings from the placeholder(s) on the layout to the placeholder(s) that will be created on the new slide from that 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, then the new slide will use the predefined layout `BLANK`.
*/
slideLayoutReference?: Schema$LayoutReference;
}
/**
* The result of creating a slide.
*/
interface Schema$CreateSlideResponse {
/**
* The object ID of the created slide.
*/
objectId?: string;
}
/**
* Creates a new table.
*/
interface Schema$CreateTableRequest {
/**
* Number of columns in the table.
*/
columns?: number;
/**
* 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;
/**
* Number of rows in the table.
*/
rows?: number;
}
/**
* The result of creating a table.
*/
interface Schema$CreateTableResponse {
/**
* The object ID of the created table.
*/
objectId?: string;
}
/**
* 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.
*/
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.
*/
id?: string;
/**
* 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;
/**
* The video source.
*/
source?: string;
}
/**
* The result of creating a video.
*/
interface Schema$CreateVideoResponse {
/**
* The object ID of the created video.
*/
objectId?: string;
}
/**
* 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.
*/
interface Schema$CropProperties {
/**
* The rotation angle of the crop window around its center, in radians. Rotation angle is applied after the offset.
*/
angle?: number;
/**
* 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;
/**
* 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;
/**
* 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;
/**
* 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;
}
/**
* Deletes an object, either pages or page elements, from the presentation.
*/
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 shapes are also deleted.
*/
objectId?: string;
}
/**
* 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.
*/
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;
/**
* The range of text to delete bullets from, based on TextElement indexes.
*/
textRange?: Schema$Range;
}
/**
* Deletes a column from a table.
*/
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;
}
/**
* Deletes a row from a table.
*/
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;
}
/**
* Deletes text from a shape or a table cell.
*/
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;
/**
* 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.
*/
interface Schema$Dimension {
/**
* The magnitude.
*/
magnitude?: number;
/**
* The units for magnitude.
*/
unit?: string;
}
/**
* 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.
*/
interface Schema$DuplicateObjectRequest {
/**
* The ID of the object to duplicate.
*/
objectId?: string;
/**
* 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;
};
}
/**
* The response of duplicating an object.
*/
interface Schema$DuplicateObjectResponse {
/**
* The ID of the new duplicate object.
*/
objectId?: string;
}
/**
* A PageElement kind representing a joined collection of PageElements.
*/
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.
*/
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 placeholder shapes cannot be grouped.
*/
childrenObjectIds?: string[];
/**
* 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;
}
/**
* The result of grouping objects.
*/
interface Schema$GroupObjectsResponse {
/**
* The object ID of the created group.
*/
objectId?: string;
}
/**
* A PageElement kind representing an image.
*/
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;
/**
* The properties of the image.
*/
imageProperties?: Schema$ImageProperties;
/**
* The source URL is the URL used to insert the image. The source URL can be empty.
*/
sourceUrl?: string;
}
/**
* The properties of the Image.
*/
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;
/**
* 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;
/**
* 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;
}
/**
* Inserts columns into a table. Other columns in the table will be resized to fit the new column.
*/
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;
/**
* The number of columns to be inserted. Maximum 20 per request.
*/
number?: number;
/**
* The table to insert columns into.
*/
tableObjectId?: string;
}
/**
* Inserts rows into a table.
*/
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;
/**
* The number of rows to be inserted. Maximum 20 per request.
*/
number?: number;
/**
* The table to insert rows into.
*/
tableObjectId?: string;
}
/**
* Inserts text into a shape or a table cell.
*/
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;
/**
* The object ID of the shape or table where the text will be inserted.
*/
objectId?: string;
/**
* 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;
}
/**
* The user-specified ID mapping for a placeholder that will be created on a slide from a specified layout.
*/
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;
/**
* 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;
}
/**
* The properties of Page are only relevant for pages with page_type LAYOUT.
*/
interface Schema$LayoutProperties {
/**
* The human-readable name of the layout.
*/
displayName?: string;
/**
* The object ID of the master that this layout is based on.
*/
masterObjectId?: string;
/**
* The name of the layout.
*/
name?: string;
}
/**
* Slide layout reference. This may reference either: - A predefined layout - One of the layouts in the presentation.
*/
interface Schema$LayoutReference {
/**
* Layout ID: the object ID of one of the layouts in the presentation.
*/
layoutId?: string;
/**
* Predefined layout.
*/
predefinedLayout?: string;
}
/**
* A PageElement kind representing a non-connector line, straight connector, curved connector, or bent connector.
*/
interface Schema$Line {
/**
* The category of the line. It matches the `category` specified in CreateLineRequest, and can be updated with UpdateLineCategoryRequest.
*/
lineCategory?: string;
/**
* The properties of the line.
*/
lineProperties?: Schema$LineProperties;
/**
* The type of the line.
*/
lineType?: string;
}
/**
* The properties for one end of a Line connection.
*/
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;
/**
* 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;
}
/**
* The fill of the line.
*/
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.
*/
interface Schema$LineProperties {
/**
* The dash style of the line.
*/
dashStyle?: string;
/**
* The style of the arrow at the end of the line.
*/
endArrow?: string;
/**
* 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;
/**
* 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.
*/
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;
/**
* If set, indicates this is a link to a slide in this presentation, addressed by its position.
*/
relativeLink?: string;
/**
* 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;
/**
* If set, indicates this is a link to the external web page at this URL.
*/
url?: string;
}
/**
* 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.
*/
interface Schema$List {
/**
* The ID of the list.
*/
listId?: string;
/**
* 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;
};
}
/**
* The properties of Page that are only relevant for pages with page_type MASTER.
*/
interface Schema$MasterProperties {
/**
* The human-readable name of the master.
*/
displayName?: string;
}
/**
* Merges cells in a Table.
*/
interface Schema$MergeTableCellsRequest {
/**
* The object ID of the table.
*/
objectId?: string;
/**
* 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.
*/
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.
*/
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;
}
/**
* A themeable solid color value.
*/
interface Schema$OpaqueColor {
/**
* An opaque RGB color.
*/
rgbColor?: Schema$RgbColor;
/**
* An opaque theme color.
*/
themeColor?: string;
}
/**
* A color that can either be fully opaque or fully transparent.
*/
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.
*/
interface Schema$Outline {
/**
* The dash style of the outline.
*/
dashStyle?: string;
/**
* 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;
/**
* The thickness of the outline.
*/
weight?: Schema$Dimension;
}
/**
* The fill of the outline.
*/
interface Schema$OutlineFill {
/**
* Solid color fill.
*/
solidFill?: Schema$SolidFill;
}
/**
* A page in a presentation.
*/
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;
/**
* 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;
/**
* The revision ID of the presentation containing this page. Can be used in update requests to assert that the presentation revision hasn't changed since the last read operation. Only populated if the user has edit access to the presentation. The format of the revision ID may change over time, so it should be treated opaquely. 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;
/**
* Slide specific properties. Only set if page_type = SLIDE.
*/
slideProperties?: Schema$SlideProperties;
}
/**
* The page background fill.
*/
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;
/**
* Solid color fill.
*/
solidFill?: Schema$SolidFill;
/**
* Stretched picture fill.
*/
stretchedPictureFill?: Schema$StretchedPictureFill;
}
/**
* A visual element rendered on a page.
*/
interface Schema$PageElement {
/**
* The description of the page element. Combined with title to display alt text.
*/
description?: string;
/**
* A collection of page elements joined as a single unit.
*/
elementGroup?: Schema$Group;
/**
* An image page element.
*/
image?: Schema$Image;
/**
* A line page element.
*/
line?: Schema$Line;
/**
* The object ID for this page element. Object IDs used by google.apps.slides.v1.Page and google.apps.slides.v1.PageElement share the same namespace.
*/
objectId?: string;
/**
* A generic shape.
*/
shape?: Schema$Shape;
/**
* A linked chart embedded from Google Sheets. Unlinked charts are represented as images.
*/
sheetsChart?: Schema$SheetsChart;
/**
* The size of the page element.
*/
size?: Schema$Size;
/**
* A table page element.
*/
table?: Schema$Table;
/**
* The title of the page element. Combined with description to display alt text.
*/
title?: string;
/**
* The transform of the page element. The visual appearance of the page element is determined by its absolute transform. To compute the absolute transform, preconcatenate a page element's transform with the transforms of all of its parent groups. If the page element is not in a group, its absolute transform is the same as the value in this field. The initial transform for the newly created Group is always the identity transform.
*/
transform?: Schema$AffineTransform;
/**
* A video page element.
*/
video?: Schema$Video;
/**
* A word art page element.
*/
wordArt?: Schema$WordArt;
}
/**
* Common properties for a page element. Note: When you initially create a PageElement, the API may modify the values of both `size` and `transform`, but the visual size will be unchanged.
*/
interface Schema$PageElementProperties {
/**
* The object ID of the page where the element is located.
*/
pageObjectId?: string;
/**
* The size of the element.
*/
size?: Schema$