googleapis/build/src/apis/slides/v1.d.ts

Google APIs Client Library for Node.js

/**
 * Copyright 2015 Google Inc. All Rights Reserved.
 *
 * 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 { AxiosPromise } from 'axios';
import { GoogleApis } from '../..';
import { BodyResponseCallback, GlobalOptions, MethodOptions } from '../../lib/api';
/**
 * Google Slides API
 *
 * An API for creating and editing 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
 */
export declare class Slides {
    _options: GlobalOptions;
    google: GoogleApis;
    root: this;
    presentations: Resource$Presentations;
    constructor(options: GlobalOptions, google: GoogleApis);
    getRoot(): this;
}
/**
 * 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;
    /**
     * 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.
 */
export 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.
 */
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;
    /**
     * 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;
    /**
     * 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.
 */
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;
    /**
     * 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.
 */
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 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.
 */
export interface Schema$CreateImageResponse {
    /**
     * The object ID of the created image.
     */
    objectId: string;
}
/**
 * Creates a line.
 */
export interface Schema$CreateLineRequest {
    /**
     * The element properties for the line.
     */
    elementProperties: Schema$PageElementProperties;
    /**
     * The category of line to be created.
     */
    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.
 */
export 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.
 */
export 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.
 */
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;
    /**
     * The shape type.
     */
    shapeType: string;
}
/**
 * The result of creating a shape.
 */
export 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.
 */
export 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.
 */
export interface Schema$CreateSheetsChartResponse {
    /**
     * The object ID of the created chart.
     */
    objectId: string;
}
/**
 * Creates a new slide.
 */
export 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.
 */
export interface Schema$CreateSlideResponse {
    /**
     * The object ID of the created slide.
     */
    objectId: string;
}
/**
 * Creates a new table.
 */
export 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.
 */
export interface Schema$CreateTableResponse {
    /**
     * The object ID of the created table.
     */
    objectId: string;
}
/**
 * Creates a video.
 */
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.
     */
    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.
 */
export 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.
 */
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;
    /**
     * 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.
 */
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
     * 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.
 */
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;
    /**
     * 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;
}
/**
 * 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;
}
/**
 * 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;
    /**
     * 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;
    /**
     * 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.
 */
export 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: any;
}
/**
 * The response of duplicating an object.
 */
export interface Schema$DuplicateObjectResponse {
    /**
     * The ID of the new duplicate object.
     */
    objectId: string;
}
/**
 * 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
     * 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.
 */
export interface Schema$GroupObjectsResponse {
    /**
     * The object ID of the created group.
     */
    objectId: string;
}
/**
 * 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;
    /**
     * 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.
 */
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;
    /**
     * 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.
 */
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;
    /**
     * 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.
 */
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;
    /**
     * 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.
 */
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;
    /**
     * 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.
 */
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;
    /**
     * 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.
 */
export 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.
 */
export 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.
 */
export interface Schema$Line {
    /**
     * The properties of the line.
     */
    lineProperties: Schema$LineProperties;
    /**
     * The type of the line.
     */
    lineType: string;
}
/**
 * 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;
    /**
     * The style of the arrow at the end of the line.
     */
    endArrow: string;
    /**
     * 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 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;
    /**
     * 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.
 */
export 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: any;
}
/**
 * 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;
}
/**
 * Merges cells in a Table.
 */
export 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.
 */
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;
}
/**
 * A themeable solid color value.
 */
export 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.
 */
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;
    /**
     * 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.
 */
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;
    /**
     * 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.
 */
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;
    /**
     * Solid color fill.
     */
    solidFill: Schema$SolidFill;
    /**
     * Stretched picture fill.
     */
    stretchedPictureFill: Schema$StretchedPictureFill;
}
/**
 * A visual element rendered on a page.
 */
export 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.
 */
export interface Schema$PageElementProperties {
    /**
     * The object ID of the page where the element is located.
     */
    pageObjectId: string;
    /**
     * The size of the element.
     */
    size: Schema$Size;
    /**
     * The transform for the element.
     */
    transform: Schema$AffineTransform;
}
/**
 * The properties of the Page.  The page will inherit properties from the parent
 * page. Depending on the page type the hierarchy is defined in either
 * SlideProperties or LayoutProperties.
 */
export interface Schema$PageProperties {
    /**
     * The color scheme of the page. If unset, the color scheme is inherited from
     * a parent page. If the page has no parent, the color scheme uses a default
     * Slides color scheme. This field is read-only.
     */
    colorScheme: Schema$ColorScheme;
    /**
     * The background fill of the page. If unset, the background fill is inherited
     * from a parent page if it exists. If the page has no parent, then the
     * background fill defaults to the corresponding fill in the Slides editor.
     */
    pageBackgroundFill: Schema$PageBackgroundFill;
}
/**
 * A TextElement kind that represents the beginning of a new paragraph.
 */
export interface Schema$ParagraphMarker {
    /**
     * The bullet for this paragraph. If not present, the paragraph does not
     * belong to a list.
     */
    bullet: Schema$Bullet;
    /**
     * The paragraph's style
     */
    style: Schema$ParagraphStyle;
}
/**
 * Styles that apply to a whole paragraph.  If this text is contained in a shape
 * with a parent placeholder, then these paragraph styles may be inherited from
 * the parent. Which paragraph styles are inherited depend on the nesting level
 * of lists:  * A paragraph not in a list will inherit its paragraph style from
 * the   paragraph at the 0 nesting level of the list inside the parent
 * placeholder. * A paragraph in a list will inherit its paragraph style from
 * the paragraph   at its corresponding nesting level of the list inside the
 * parent   placeholder.  Inherited paragraph styles are represented as unset
 * fields in this message.
 */
export interface Schema$ParagraphStyle {
    /**
     * The text alignment for this paragraph.
     */
    alignment: string;
    /**
     * The text direction of this paragraph. If unset, the value defaults to
     * LEFT_TO_RIGHT since text direction is not inherited.
     */
    direction: string;
    /**
     * The amount indentation for the paragraph on the side that corresponds to
     * the end of the text, based on the current text direction. If unset, the
     * value is inherited from the parent.
     */
    indentEnd: Schema$Dimension;
    /**
     * The amount of indentation for the start of the first line of the paragraph.
     * If unset, the value is inherited from the parent.
     */
    indentFirstLine: Schema$Dimension;
    /**
     * The amount indentation for the paragraph on the side that corresponds to
     * the start of the text, based on the current text direction. If unset, the
     * value is inherited from the parent.
     */
    indentStart: Schema$Dimension;
    /**
     * The amount of space between lines, as a percentage of normal, where normal
     * is represented as 100.0. If unset, the value is inherited from the parent.
     */
    lineSpacing: number;
    /**
     * The amount of extra space above the paragraph. If unset, the value is
     * inherited from the parent.
     */
    spaceAbove: Schema$Dimension;
    /**
     * The amount of extra space above the paragraph. If unset, the value is
     * inherited from the parent.
     */
    spaceBelow: Schema$Dimension;
    /**
     * The spacing mode for the paragraph.
     */
    spacingMode: string;
}
/**
 * The placeholder information that uniquely identifies a placeholder shape.
 */
export interface Schema$Placeholder {
    /**
     * The index of the placeholder. If the same placeholder types are present in
     * the same page, they would have different index values.
     */
    index: number;
    /**
     * The object ID of this shape's parent placeholder. If unset, the parent
     * placeholder shape does not exist, so the shape does not inherit properties
     * from any other shape.
     */
    parentObjectId: string;
    /**
     * The type of the placeholder.
     */
    type: string;
}
/**
 * A Google Slides presentation.
 */
export interface Schema$Presentation {
    /**
     * The layouts in the presentation. A layout is a template that determines how
     * content is arranged and styled on the slides that inherit from that layout.
     */
    layouts: Schema$Page[];
    /**
     * The locale of the presentation, as an IETF BCP 47 language tag.
     */
    locale: string;
    /**
     * The slide masters in the presentation. A slide master contains all common
     * page elements and the common properties for a set of layouts. They serve
     * three purposes:  - Placeholder shapes on a master contain the default text
     * styles and shape   properties of all placeholder shapes on pages that use
     * that master. - The master page properties define the common page properties
     * inherited by   its layouts. - Any other shapes on the master slide will
     * appear on all slides using that   master, regardless of their layout.
     */
    masters: Schema$Page[];
    /**
     * The notes master in the presentation. It serves three purposes:  -
     * Placeholder shapes on a notes master contain the default text styles and
     * shape properties of all placeholder shapes on notes pages. Specifically, a
     * `SLIDE_IMAGE` placeholder shape contains the slide thumbnail, and a `BODY`
     * placeholder shape contains the speaker notes. - The notes master page
     * properties define the common page properties   inherited by all notes
     * pages. - Any other shapes on the notes master will appear on all notes
     * pages.  The notes master is read-only.
     */
    notesMaster: Schema$Page;
    /**
     * The size of pages in the presentation.
     */
    pageSize: Schema$Size;
    /**
     * The ID of the presentation.
     */
    presentationId: string;
    /**
     * The revision ID of the presentation. 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 revis