// Copyright 2022 Luca Casonato. All rights reserved. MIT license. /** * Drive Labels API Client for Deno * ================================ * * An API for managing Drive Labels * * Docs: https://developers.google.com/drive/labels * Source: https://googleapis.deno.dev/v1/drivelabels:v2.ts */ import { auth, CredentialsClient, GoogleAuth, request } from "/_/base@v1/mod.ts"; export { auth, GoogleAuth }; export type { CredentialsClient }; /** * An API for managing Drive Labels */ export class DriveLabels { #client: CredentialsClient | undefined; #baseUrl: string; constructor(client?: CredentialsClient, baseUrl: string = "https://drivelabels.googleapis.com/") { this.#client = client; this.#baseUrl = baseUrl; } /** * Get a label by its resource name. Resource name may be any of: * * `labels/{id}` - See `labels/{id}@latest` * `labels/{id}@latest` - Gets the * latest revision of the label. * `labels/{id}@published` - Gets the current * published revision of the label. * `labels/{id}@{revision_id}` - Gets the * label at the specified revision ID. * * @param name Required. Label resource name. May be any of: * `labels/{id}` (equivalent to labels/{id}@latest) * `labels/{id}@latest` * `labels/{id}@published` * `labels/{id}@{revision_id}` */ async labelsGet(name: string, opts: LabelsGetOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v2/${ name }`); if (opts.languageCode !== undefined) { url.searchParams.append("languageCode", String(opts.languageCode)); } if (opts.useAdminAccess !== undefined) { url.searchParams.append("useAdminAccess", String(opts.useAdminAccess)); } if (opts.view !== undefined) { url.searchParams.append("view", String(opts.view)); } const data = await request(url.href, { client: this.#client, method: "GET", }); return deserializeGoogleAppsDriveLabelsV2Label(data); } /** * List labels. * */ async labelsList(opts: LabelsListOptions = {}): Promise { const url = new URL(`${this.#baseUrl}v2/labels`); if (opts.languageCode !== undefined) { url.searchParams.append("languageCode", String(opts.languageCode)); } if (opts.minimumRole !== undefined) { url.searchParams.append("minimumRole", String(opts.minimumRole)); } if (opts.pageSize !== undefined) { url.searchParams.append("pageSize", String(opts.pageSize)); } if (opts.pageToken !== undefined) { url.searchParams.append("pageToken", String(opts.pageToken)); } if (opts.publishedOnly !== undefined) { url.searchParams.append("publishedOnly", String(opts.publishedOnly)); } if (opts.useAdminAccess !== undefined) { url.searchParams.append("useAdminAccess", String(opts.useAdminAccess)); } if (opts.view !== undefined) { url.searchParams.append("view", String(opts.view)); } const data = await request(url.href, { client: this.#client, method: "GET", }); return deserializeGoogleAppsDriveLabelsV2ListLabelsResponse(data); } } /** * The color derived from BadgeConfig and changed to the closest recommended * supported color. */ export interface GoogleAppsDriveLabelsV2BadgeColors { /** * Output only. Badge background that pairs with the foreground. */ readonly backgroundColor?: GoogleTypeColor; /** * Output only. Badge foreground that pairs with the background. */ readonly foregroundColor?: GoogleTypeColor; /** * Output only. Color that can be used for text without a background. */ readonly soloColor?: GoogleTypeColor; } /** * Badge status of the label. */ export interface GoogleAppsDriveLabelsV2BadgeConfig { /** * The color of the badge. When not specified, no badge is rendered. The * background, foreground, and solo (light and dark mode) colors set here are * changed in the Drive UI into the closest recommended supported color. */ color?: GoogleTypeColor; /** * Override the default global priority of this badge. When set to 0, the * default priority heuristic is used. */ priorityOverride?: bigint; } function serializeGoogleAppsDriveLabelsV2BadgeConfig(data: any): GoogleAppsDriveLabelsV2BadgeConfig { return { ...data, priorityOverride: data["priorityOverride"] !== undefined ? String(data["priorityOverride"]) : undefined, }; } function deserializeGoogleAppsDriveLabelsV2BadgeConfig(data: any): GoogleAppsDriveLabelsV2BadgeConfig { return { ...data, priorityOverride: data["priorityOverride"] !== undefined ? BigInt(data["priorityOverride"]) : undefined, }; } /** * Defines a field that has a display name, data type, and other configuration * options. This field defines the kind of metadata that may be set on a Drive * item. */ export interface GoogleAppsDriveLabelsV2Field { /** * Output only. The capabilities this user has on this field and its value * when the label is applied on Drive items. */ readonly appliedCapabilities?: GoogleAppsDriveLabelsV2FieldAppliedCapabilities; /** * Output only. The time this field was created. */ readonly createTime?: Date; /** * Output only. The user who created this field. */ readonly creator?: GoogleAppsDriveLabelsV2UserInfo; /** * Date field options. */ dateOptions?: GoogleAppsDriveLabelsV2FieldDateOptions; /** * Output only. The user who disabled this field. This value has no meaning * when the field is not disabled. */ readonly disabler?: GoogleAppsDriveLabelsV2UserInfo; /** * Output only. The time this field was disabled. This value has no meaning * when the field is not disabled. */ readonly disableTime?: Date; /** * Output only. UI display hints for rendering a field. */ readonly displayHints?: GoogleAppsDriveLabelsV2FieldDisplayHints; /** * Output only. The key of a field, unique within a label or library. This * value is autogenerated. Matches the regex: `([a-zA-Z0-9])+` */ readonly id?: string; /** * Integer field options. */ integerOptions?: GoogleAppsDriveLabelsV2FieldIntegerOptions; /** * Output only. The lifecycle of this field. */ readonly lifecycle?: GoogleAppsDriveLabelsV2Lifecycle; /** * Output only. The LockStatus of this field. */ readonly lockStatus?: GoogleAppsDriveLabelsV2LockStatus; /** * The basic properties of the field. */ properties?: GoogleAppsDriveLabelsV2FieldProperties; /** * Output only. The user who published this field. This value has no meaning * when the field is not published. */ readonly publisher?: GoogleAppsDriveLabelsV2UserInfo; /** * Output only. The key to use when constructing Drive search queries to find * files based on values defined for this field on files. For example, * "`{query_key}` > 2001-01-01". */ readonly queryKey?: string; /** * Output only. The capabilities this user has when editing this field. */ readonly schemaCapabilities?: GoogleAppsDriveLabelsV2FieldSchemaCapabilities; /** * Selection field options. */ selectionOptions?: GoogleAppsDriveLabelsV2FieldSelectionOptions; /** * Text field options. */ textOptions?: GoogleAppsDriveLabelsV2FieldTextOptions; /** * Output only. The user who modified this field. */ readonly updater?: GoogleAppsDriveLabelsV2UserInfo; /** * Output only. The time this field was updated. */ readonly updateTime?: Date; /** * User field options. */ userOptions?: GoogleAppsDriveLabelsV2FieldUserOptions; } function serializeGoogleAppsDriveLabelsV2Field(data: any): GoogleAppsDriveLabelsV2Field { return { ...data, selectionOptions: data["selectionOptions"] !== undefined ? serializeGoogleAppsDriveLabelsV2FieldSelectionOptions(data["selectionOptions"]) : undefined, }; } function deserializeGoogleAppsDriveLabelsV2Field(data: any): GoogleAppsDriveLabelsV2Field { return { ...data, createTime: data["createTime"] !== undefined ? new Date(data["createTime"]) : undefined, disableTime: data["disableTime"] !== undefined ? new Date(data["disableTime"]) : undefined, selectionOptions: data["selectionOptions"] !== undefined ? deserializeGoogleAppsDriveLabelsV2FieldSelectionOptions(data["selectionOptions"]) : undefined, updateTime: data["updateTime"] !== undefined ? new Date(data["updateTime"]) : undefined, }; } /** * The capabilities related to this field on applied metadata. */ export interface GoogleAppsDriveLabelsV2FieldAppliedCapabilities { /** * Whether the user can read related applied metadata on items. */ canRead?: boolean; /** * Whether the user can search for Drive items referencing this field. */ canSearch?: boolean; /** * Whether the user can set this field on Drive items. */ canWrite?: boolean; } /** * Options for the date field type. */ export interface GoogleAppsDriveLabelsV2FieldDateOptions { /** * Output only. ICU date format. */ readonly dateFormat?: string; /** * Localized date formatting option. Field values are rendered in this format * according to their locale. */ dateFormatType?: | "DATE_FORMAT_UNSPECIFIED" | "LONG_DATE" | "SHORT_DATE"; /** * Output only. Maximum valid value (year, month, day). */ readonly maxValue?: GoogleTypeDate; /** * Output only. Minimum valid value (year, month, day). */ readonly minValue?: GoogleTypeDate; } /** * UI display hints for rendering a field. */ export interface GoogleAppsDriveLabelsV2FieldDisplayHints { /** * Whether the field should be shown in the UI as disabled. */ disabled?: boolean; /** * This field should be hidden in the search menu when searching for Drive * items. */ hiddenInSearch?: boolean; /** * Whether the field should be shown as required in the UI. */ required?: boolean; /** * This field should be shown in the apply menu when applying values to a * Drive item. */ shownInApply?: boolean; } /** * Options for the Integer field type. */ export interface GoogleAppsDriveLabelsV2FieldIntegerOptions { /** * Output only. The maximum valid value for the integer field. */ readonly maxValue?: bigint; /** * Output only. The minimum valid value for the integer field. */ readonly minValue?: bigint; } /** * Options for a multi-valued variant of an associated field type. */ export interface GoogleAppsDriveLabelsV2FieldListOptions { /** * Maximum number of entries permitted. */ maxEntries?: number; } /** * The basic properties of the field. */ export interface GoogleAppsDriveLabelsV2FieldProperties { /** * Required. The display text to show in the UI identifying this field. */ displayName?: string; /** * Input only. Insert or move this field before the indicated field. If * empty, the field is placed at the end of the list. */ insertBeforeField?: string; /** * Whether the field should be marked as required. */ required?: boolean; } /** * The capabilities related to this field when editing the field. */ export interface GoogleAppsDriveLabelsV2FieldSchemaCapabilities { /** * Whether the user can delete this field. The user must have permission and * the field must be deprecated. */ canDelete?: boolean; /** * Whether the user can disable this field. The user must have permission and * this field must not already be disabled. */ canDisable?: boolean; /** * Whether the user can enable this field. The user must have permission and * this field must be disabled. */ canEnable?: boolean; /** * Whether the user can change this field. */ canUpdate?: boolean; } /** * Options for the selection field type. */ export interface GoogleAppsDriveLabelsV2FieldSelectionOptions { /** * The options available for this selection field. The list order is * consistent, and modified with `insert_before_choice`. */ choices?: GoogleAppsDriveLabelsV2FieldSelectionOptionsChoice[]; /** * When specified, indicates this field supports a list of values. Once the * field is published, this cannot be changed. */ listOptions?: GoogleAppsDriveLabelsV2FieldListOptions; } function serializeGoogleAppsDriveLabelsV2FieldSelectionOptions(data: any): GoogleAppsDriveLabelsV2FieldSelectionOptions { return { ...data, choices: data["choices"] !== undefined ? data["choices"].map((item: any) => (serializeGoogleAppsDriveLabelsV2FieldSelectionOptionsChoice(item))) : undefined, }; } function deserializeGoogleAppsDriveLabelsV2FieldSelectionOptions(data: any): GoogleAppsDriveLabelsV2FieldSelectionOptions { return { ...data, choices: data["choices"] !== undefined ? data["choices"].map((item: any) => (deserializeGoogleAppsDriveLabelsV2FieldSelectionOptionsChoice(item))) : undefined, }; } /** * Selection field choice. */ export interface GoogleAppsDriveLabelsV2FieldSelectionOptionsChoice { /** * Output only. The capabilities related to this choice on applied metadata. */ readonly appliedCapabilities?: GoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceAppliedCapabilities; /** * Output only. The time this choice was created. */ readonly createTime?: Date; /** * Output only. The user who created this choice. */ readonly creator?: GoogleAppsDriveLabelsV2UserInfo; /** * Output only. The user who disabled this choice. This value has no meaning * when the option is not disabled. */ readonly disabler?: GoogleAppsDriveLabelsV2UserInfo; /** * Output only. The time this choice was disabled. This value has no meaning * when the choice is not disabled. */ readonly disableTime?: Date; /** * Output only. UI display hints for rendering a choice. */ readonly displayHints?: GoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceDisplayHints; /** * The unique value of the choice. This ID is autogenerated. Matches the * regex: `([a-zA-Z0-9_])+`. */ id?: string; /** * Output only. Lifecycle of the choice. */ readonly lifecycle?: GoogleAppsDriveLabelsV2Lifecycle; /** * Output only. The LockStatus of this choice. */ readonly lockStatus?: GoogleAppsDriveLabelsV2LockStatus; /** * Basic properties of the choice. */ properties?: GoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceProperties; /** * Output only. The user who published this choice. This value has no meaning * when the choice is not published. */ readonly publisher?: GoogleAppsDriveLabelsV2UserInfo; /** * Output only. The time this choice was published. This value has no meaning * when the choice is not published. */ readonly publishTime?: Date; /** * Output only. The capabilities related to this option when editing the * option. */ readonly schemaCapabilities?: GoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceSchemaCapabilities; /** * Output only. The user who updated this choice last. */ readonly updater?: GoogleAppsDriveLabelsV2UserInfo; /** * Output only. The time this choice was updated last. */ readonly updateTime?: Date; } function serializeGoogleAppsDriveLabelsV2FieldSelectionOptionsChoice(data: any): GoogleAppsDriveLabelsV2FieldSelectionOptionsChoice { return { ...data, properties: data["properties"] !== undefined ? serializeGoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceProperties(data["properties"]) : undefined, }; } function deserializeGoogleAppsDriveLabelsV2FieldSelectionOptionsChoice(data: any): GoogleAppsDriveLabelsV2FieldSelectionOptionsChoice { return { ...data, createTime: data["createTime"] !== undefined ? new Date(data["createTime"]) : undefined, disableTime: data["disableTime"] !== undefined ? new Date(data["disableTime"]) : undefined, displayHints: data["displayHints"] !== undefined ? deserializeGoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceDisplayHints(data["displayHints"]) : undefined, properties: data["properties"] !== undefined ? deserializeGoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceProperties(data["properties"]) : undefined, publishTime: data["publishTime"] !== undefined ? new Date(data["publishTime"]) : undefined, updateTime: data["updateTime"] !== undefined ? new Date(data["updateTime"]) : undefined, }; } /** * The capabilities related to this choice on applied metadata. */ export interface GoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceAppliedCapabilities { /** * Whether the user can read related applied metadata on items. */ canRead?: boolean; /** * Whether the user can use this choice in search queries. */ canSearch?: boolean; /** * Whether the user can select this choice on an item. */ canSelect?: boolean; } /** * UI display hints for rendering an option. */ export interface GoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceDisplayHints { /** * The colors to use for the badge. Changed to Google Material colors based * on the chosen `properties.badge_config.color`. */ badgeColors?: GoogleAppsDriveLabelsV2BadgeColors; /** * The priority of this badge. Used to compare and sort between multiple * badges. A lower number means the badge should be shown first. When a * badging configuration is not present, this will be 0. Otherwise, this will * be set to `BadgeConfig.priority_override` or the default heuristic which * prefers creation date of the label, and field and option priority. */ badgePriority?: bigint; /** * The dark-mode color to use for the badge. Changed to Google Material * colors based on the chosen `properties.badge_config.color`. */ darkBadgeColors?: GoogleAppsDriveLabelsV2BadgeColors; /** * Whether the option should be shown in the UI as disabled. */ disabled?: boolean; /** * This option should be hidden in the search menu when searching for Drive * items. */ hiddenInSearch?: boolean; /** * This option should be shown in the apply menu when applying values to a * Drive item. */ shownInApply?: boolean; } function serializeGoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceDisplayHints(data: any): GoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceDisplayHints { return { ...data, badgePriority: data["badgePriority"] !== undefined ? String(data["badgePriority"]) : undefined, }; } function deserializeGoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceDisplayHints(data: any): GoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceDisplayHints { return { ...data, badgePriority: data["badgePriority"] !== undefined ? BigInt(data["badgePriority"]) : undefined, }; } /** * Basic properties of the choice. */ export interface GoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceProperties { /** * The badge configuration for this choice. When set, the label that owns * this choice is considered a "badged label". */ badgeConfig?: GoogleAppsDriveLabelsV2BadgeConfig; /** * The description of this label. */ description?: string; /** * Required. The display text to show in the UI identifying this field. */ displayName?: string; /** * Input only. Insert or move this choice before the indicated choice. If * empty, the choice is placed at the end of the list. */ insertBeforeChoice?: string; } function serializeGoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceProperties(data: any): GoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceProperties { return { ...data, badgeConfig: data["badgeConfig"] !== undefined ? serializeGoogleAppsDriveLabelsV2BadgeConfig(data["badgeConfig"]) : undefined, }; } function deserializeGoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceProperties(data: any): GoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceProperties { return { ...data, badgeConfig: data["badgeConfig"] !== undefined ? deserializeGoogleAppsDriveLabelsV2BadgeConfig(data["badgeConfig"]) : undefined, }; } /** * The capabilities related to this choice when editing the choice. */ export interface GoogleAppsDriveLabelsV2FieldSelectionOptionsChoiceSchemaCapabilities { /** * Whether the user can delete this choice. */ canDelete?: boolean; /** * Whether the user can disable this choice. */ canDisable?: boolean; /** * Whether the user can enable this choice. */ canEnable?: boolean; /** * Whether the user can update this choice. */ canUpdate?: boolean; } /** * Options for the Text field type. */ export interface GoogleAppsDriveLabelsV2FieldTextOptions { /** * Output only. The maximum valid length of values for the text field. */ readonly maxLength?: number; /** * Output only. The minimum valid length of values for the text field. */ readonly minLength?: number; } /** * Options for the user field type. */ export interface GoogleAppsDriveLabelsV2FieldUserOptions { /** * When specified, indicates that this field supports a list of values. Once * the field is published, this cannot be changed. */ listOptions?: GoogleAppsDriveLabelsV2FieldListOptions; } /** * A label defines a taxonomy that can be applied to Drive items in order to * organize and search across items. Labels can be simple strings, or can * contain fields that describe additional metadata that can be further used to * organize and search Drive items. */ export interface GoogleAppsDriveLabelsV2Label { /** * Output only. The capabilities related to this label on applied metadata. */ readonly appliedCapabilities?: GoogleAppsDriveLabelsV2LabelAppliedCapabilities; /** * Output only. Behavior of this label when it's applied to Drive items. */ readonly appliedLabelPolicy?: GoogleAppsDriveLabelsV2LabelAppliedLabelPolicy; /** * Output only. The time this label was created. */ readonly createTime?: Date; /** * Output only. The user who created this label. */ readonly creator?: GoogleAppsDriveLabelsV2UserInfo; /** * Output only. The user who disabled this label. This value has no meaning * when the label is not disabled. */ readonly disabler?: GoogleAppsDriveLabelsV2UserInfo; /** * Output only. The time this label was disabled. This value has no meaning * when the label is not disabled. */ readonly disableTime?: Date; /** * Output only. UI display hints for rendering the label. */ readonly displayHints?: GoogleAppsDriveLabelsV2LabelDisplayHints; /** * List of fields in descending priority order. */ fields?: GoogleAppsDriveLabelsV2Field[]; /** * Output only. Globally unique identifier of this label. ID makes up part of * the label `name`, but unlike `name`, ID is consistent between revisions. * Matches the regex: `([a-zA-Z0-9])+` */ readonly id?: string; /** * Required. The type of label. */ labelType?: | "LABEL_TYPE_UNSPECIFIED" | "SHARED" | "ADMIN"; /** * Custom URL to present to users to allow them to learn more about this * label and how it should be used. */ learnMoreUri?: string; /** * Output only. The lifecycle state of the label including whether it's * published, deprecated, and has draft changes. */ readonly lifecycle?: GoogleAppsDriveLabelsV2Lifecycle; /** * Output only. The LockStatus of this label. */ readonly lockStatus?: GoogleAppsDriveLabelsV2LockStatus; /** * Output only. Resource name of the label. Will be in the form of either: * `labels/{id}` or `labels/{id}@{revision_id}` depending on the request. See * `id` and `revision_id` below. */ readonly name?: string; /** * Required. The basic properties of the label. */ properties?: GoogleAppsDriveLabelsV2LabelProperties; /** * Output only. The user who published this label. This value has no meaning * when the label is not published. */ readonly publisher?: GoogleAppsDriveLabelsV2UserInfo; /** * Output only. The time this label was published. This value has no meaning * when the label is not published. */ readonly publishTime?: Date; /** * Output only. The time this label revision was created. */ readonly revisionCreateTime?: Date; /** * Output only. The user who created this label revision. */ readonly revisionCreator?: GoogleAppsDriveLabelsV2UserInfo; /** * Output only. Revision ID of the label. Revision ID might be part of the * label `name` depending on the request issued. A new revision is created * whenever revisioned properties of a label are changed. Matches the regex: * `([a-zA-Z0-9])+` */ readonly revisionId?: string; /** * Output only. The capabilities the user has on this label. */ readonly schemaCapabilities?: GoogleAppsDriveLabelsV2LabelSchemaCapabilities; } function serializeGoogleAppsDriveLabelsV2Label(data: any): GoogleAppsDriveLabelsV2Label { return { ...data, fields: data["fields"] !== undefined ? data["fields"].map((item: any) => (serializeGoogleAppsDriveLabelsV2Field(item))) : undefined, }; } function deserializeGoogleAppsDriveLabelsV2Label(data: any): GoogleAppsDriveLabelsV2Label { return { ...data, createTime: data["createTime"] !== undefined ? new Date(data["createTime"]) : undefined, disableTime: data["disableTime"] !== undefined ? new Date(data["disableTime"]) : undefined, displayHints: data["displayHints"] !== undefined ? deserializeGoogleAppsDriveLabelsV2LabelDisplayHints(data["displayHints"]) : undefined, fields: data["fields"] !== undefined ? data["fields"].map((item: any) => (deserializeGoogleAppsDriveLabelsV2Field(item))) : undefined, publishTime: data["publishTime"] !== undefined ? new Date(data["publishTime"]) : undefined, revisionCreateTime: data["revisionCreateTime"] !== undefined ? new Date(data["revisionCreateTime"]) : undefined, }; } /** * The capabilities a user has on this label's applied metadata. */ export interface GoogleAppsDriveLabelsV2LabelAppliedCapabilities { /** * Whether the user can apply this label to items. */ canApply?: boolean; /** * Whether the user can read applied metadata related to this label. */ canRead?: boolean; /** * Whether the user can remove this label from items. */ canRemove?: boolean; } /** * Behavior of this label when it's applied to Drive items. */ export interface GoogleAppsDriveLabelsV2LabelAppliedLabelPolicy { /** * Indicates how the applied label and field values should be copied when a * Drive item is copied. */ copyMode?: | "COPY_MODE_UNSPECIFIED" | "DO_NOT_COPY" | "ALWAYS_COPY" | "COPY_APPLIABLE"; } /** * UI display hints for rendering the label. */ export interface GoogleAppsDriveLabelsV2LabelDisplayHints { /** * Whether the label should be shown in the UI as disabled. */ disabled?: boolean; /** * This label should be hidden in the search menu when searching for Drive * items. */ hiddenInSearch?: boolean; /** * Order to display label in a list. */ priority?: bigint; /** * This label should be shown in the apply menu when applying values to a * Drive item. */ shownInApply?: boolean; } function serializeGoogleAppsDriveLabelsV2LabelDisplayHints(data: any): GoogleAppsDriveLabelsV2LabelDisplayHints { return { ...data, priority: data["priority"] !== undefined ? String(data["priority"]) : undefined, }; } function deserializeGoogleAppsDriveLabelsV2LabelDisplayHints(data: any): GoogleAppsDriveLabelsV2LabelDisplayHints { return { ...data, priority: data["priority"] !== undefined ? BigInt(data["priority"]) : undefined, }; } /** * Basic properties of the label. */ export interface GoogleAppsDriveLabelsV2LabelProperties { /** * The description of the label. */ description?: string; /** * Required. Title of the label. */ title?: string; } /** * The capabilities related to this label when editing the label. */ export interface GoogleAppsDriveLabelsV2LabelSchemaCapabilities { /** * Whether the user can delete this label. The user must have permission and * the label must be disabled. */ canDelete?: boolean; /** * Whether the user can disable this label. The user must have permission and * this label must not already be disabled. */ canDisable?: boolean; /** * Whether the user can enable this label. The user must have permission and * this label must be disabled. */ canEnable?: boolean; /** * Whether the user can change this label. */ canUpdate?: boolean; } /** * The lifecycle state of an object, such as label, field, or choice. The * lifecycle enforces the following transitions: * `UNPUBLISHED_DRAFT` (starting * state) * `UNPUBLISHED_DRAFT` -> `PUBLISHED` * `UNPUBLISHED_DRAFT` -> * (Deleted) * `PUBLISHED` -> `DISABLED` * `DISABLED` -> `PUBLISHED` * * `DISABLED` -> (Deleted) The published and disabled states have some distinct * characteristics: * Published—Some kinds of changes might be made to an object * in this state, in which case `has_unpublished_changes` will be true. Also, * some kinds of changes are not permitted. Generally, any change that would * invalidate or cause new restrictions on existing metadata related to the * label are rejected. * Disabled—When disabled, the configured `DisabledPolicy` * takes effect. */ export interface GoogleAppsDriveLabelsV2Lifecycle { /** * The policy that governs how to show a disabled label, field, or selection * choice. */ disabledPolicy?: GoogleAppsDriveLabelsV2LifecycleDisabledPolicy; /** * Output only. Whether the object associated with this lifecycle has * unpublished changes. */ readonly hasUnpublishedChanges?: boolean; /** * Output only. The state of the object associated with this lifecycle. */ readonly state?: | "STATE_UNSPECIFIED" | "UNPUBLISHED_DRAFT" | "PUBLISHED" | "DISABLED" | "DELETED"; } /** * The policy that governs how to treat a disabled label, field, or selection * choice in different contexts. */ export interface GoogleAppsDriveLabelsV2LifecycleDisabledPolicy { /** * Whether to hide this disabled object in the search menu for Drive items. * * When `false`, the object is generally shown in the UI as disabled but it * appears in the search results when searching for Drive items. * When * `true`, the object is generally hidden in the UI when searching for Drive * items. */ hideInSearch?: boolean; /** * Whether to show this disabled object in the apply menu on Drive items. * * When `true`, the object is generally shown in the UI as disabled and is * unselectable. * When `false`, the object is generally hidden in the UI. */ showInApply?: boolean; } /** * Response for listing Labels. */ export interface GoogleAppsDriveLabelsV2ListLabelsResponse { /** * Labels. */ labels?: GoogleAppsDriveLabelsV2Label[]; /** * The token of the next page in the response. */ nextPageToken?: string; } function serializeGoogleAppsDriveLabelsV2ListLabelsResponse(data: any): GoogleAppsDriveLabelsV2ListLabelsResponse { return { ...data, labels: data["labels"] !== undefined ? data["labels"].map((item: any) => (serializeGoogleAppsDriveLabelsV2Label(item))) : undefined, }; } function deserializeGoogleAppsDriveLabelsV2ListLabelsResponse(data: any): GoogleAppsDriveLabelsV2ListLabelsResponse { return { ...data, labels: data["labels"] !== undefined ? data["labels"].map((item: any) => (deserializeGoogleAppsDriveLabelsV2Label(item))) : undefined, }; } /** * Contains information about whether a label component should be considered * locked. */ export interface GoogleAppsDriveLabelsV2LockStatus { /** * Output only. Indicates whether this label component is the (direct) target * of a LabelLock. A label component can be implicitly locked even if it's not * the direct target of a LabelLock, in which case this field is set to false. */ readonly locked?: boolean; } /** * Information about a user. */ export interface GoogleAppsDriveLabelsV2UserInfo { /** * The identifier for this user that can be used with the People API to get * more information. For example, people/12345678. */ person?: string; } /** * Represents a color in the RGBA color space. This representation is designed * for simplicity of conversion to/from color representations in various * languages over compactness. For example, the fields of this representation * can be trivially provided to the constructor of `java.awt.Color` in Java; it * can also be trivially provided to UIColor's `+colorWithRed:green:blue:alpha` * method in iOS; and, with just a little work, it can be easily formatted into * a CSS `rgba()` string in JavaScript. This reference page doesn't carry * information about the absolute color space that should be used to interpret * the RGB value (e.g. sRGB, Adobe RGB, DCI-P3, BT.2020, etc.). By default, * applications should assume the sRGB color space. When color equality needs to * be decided, implementations, unless documented otherwise, treat two colors as * equal if all their red, green, blue, and alpha values each differ by at most * 1e-5. Example (Java): import com.google.type.Color; // ... public static * java.awt.Color fromProto(Color protocolor) { float alpha = * protocolor.hasAlpha() ? protocolor.getAlpha().getValue() : 1.0; return new * java.awt.Color( protocolor.getRed(), protocolor.getGreen(), * protocolor.getBlue(), alpha); } public static Color toProto(java.awt.Color * color) { float red = (float) color.getRed(); float green = (float) * color.getGreen(); float blue = (float) color.getBlue(); float denominator = * 255.0; Color.Builder resultBuilder = Color .newBuilder() .setRed(red / * denominator) .setGreen(green / denominator) .setBlue(blue / denominator); int * alpha = color.getAlpha(); if (alpha != 255) { result.setAlpha( FloatValue * .newBuilder() .setValue(((float) alpha) / denominator) .build()); } return * resultBuilder.build(); } // ... Example (iOS / Obj-C): // ... static UIColor* * fromProto(Color* protocolor) { float red = [protocolor red]; float green = * [protocolor green]; float blue = [protocolor blue]; FloatValue* alpha_wrapper * = [protocolor alpha]; float alpha = 1.0; if (alpha_wrapper != nil) { alpha = * [alpha_wrapper value]; } return [UIColor colorWithRed:red green:green * blue:blue alpha:alpha]; } static Color* toProto(UIColor* color) { CGFloat * red, green, blue, alpha; if (![color getRed:&red green:&green blue:&blue * alpha:&alpha]) { return nil; } Color* result = [[Color alloc] init]; [result * setRed:red]; [result setGreen:green]; [result setBlue:blue]; if (alpha <= * 0.9999) { [result setAlpha:floatWrapperWithValue(alpha)]; } [result * autorelease]; return result; } // ... Example (JavaScript): // ... var * protoToCssColor = function(rgb_color) { var redFrac = rgb_color.red || 0.0; * var greenFrac = rgb_color.green || 0.0; var blueFrac = rgb_color.blue || 0.0; * var red = Math.floor(redFrac * 255); var green = Math.floor(greenFrac * 255); * var blue = Math.floor(blueFrac * 255); if (!('alpha' in rgb_color)) { return * rgbToCssColor(red, green, blue); } var alphaFrac = rgb_color.alpha.value || * 0.0; var rgbParams = [red, green, blue].join(','); return ['rgba(', * rgbParams, ',', alphaFrac, ')'].join(''); }; var rgbToCssColor = * function(red, green, blue) { var rgbNumber = new Number((red << 16) | (green * << 8) | blue); var hexString = rgbNumber.toString(16); var missingZeros = 6 - * hexString.length; var resultBuilder = ['#']; for (var i = 0; i < * missingZeros; i++) { resultBuilder.push('0'); } * resultBuilder.push(hexString); return resultBuilder.join(''); }; // ... */ export interface GoogleTypeColor { /** * The fraction of this color that should be applied to the pixel. That is, * the final pixel color is defined by the equation: `pixel color = alpha * * (this color) + (1.0 - alpha) * (background color)` This means that a value * of 1.0 corresponds to a solid color, whereas a value of 0.0 corresponds to * a completely transparent color. This uses a wrapper message rather than a * simple float scalar so that it is possible to distinguish between a default * value and the value being unset. If omitted, this color object is rendered * as a solid color (as if the alpha value had been explicitly given a value * of 1.0). */ alpha?: number; /** * The amount of blue in the color as a value in the interval [0, 1]. */ blue?: number; /** * The amount of green in the color as a value in the interval [0, 1]. */ green?: number; /** * The amount of red in the color as a value in the interval [0, 1]. */ red?: number; } /** * Represents a whole or partial calendar date, such as a birthday. The time of * day and time zone are either specified elsewhere or are insignificant. The * date is relative to the Gregorian Calendar. This can represent one of the * following: * A full date, with non-zero year, month, and day values. * A * month and day, with a zero year (for example, an anniversary). * A year on * its own, with a zero month and a zero day. * A year and month, with a zero * day (for example, a credit card expiration date). Related types: * * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp */ export interface GoogleTypeDate { /** * Day of a month. Must be from 1 to 31 and valid for the year and month, or * 0 to specify a year by itself or a year and month where the day isn't * significant. */ day?: number; /** * Month of a year. Must be from 1 to 12, or 0 to specify a year without a * month and day. */ month?: number; /** * Year of the date. Must be from 1 to 9999, or 0 to specify a date without a * year. */ year?: number; } /** * Additional options for DriveLabels#labelsGet. */ export interface LabelsGetOptions { /** * The BCP-47 language code to use for evaluating localized field labels. * When not specified, values in the default configured language are used. */ languageCode?: string; /** * Set to `true` in order to use the user's admin credentials. The server * verifies that the user is an admin for the label before allowing access. */ useAdminAccess?: boolean; /** * When specified, only certain fields belonging to the indicated view are * returned. */ view?: | "LABEL_VIEW_BASIC" | "LABEL_VIEW_FULL"; } /** * Additional options for DriveLabels#labelsList. */ export interface LabelsListOptions { /** * The BCP-47 language code to use for evaluating localized field labels. * When not specified, values in the default configured language are used. */ languageCode?: string; /** * Specifies the level of access the user must have on the returned Labels. * The minimum role a user must have on a label. Defaults to `READER`. */ minimumRole?: | "LABEL_ROLE_UNSPECIFIED" | "READER" | "APPLIER" | "ORGANIZER" | "EDITOR"; /** * Maximum number of labels to return per page. Default: 50. Max: 200. */ pageSize?: number; /** * The token of the page to return. */ pageToken?: string; /** * Whether to include only published labels in the results. * When `true`, * only the current published label revisions are returned. Disabled labels * are included. Returned label resource names reference the published * revision (`labels/{id}/{revision_id}`). * When `false`, the current label * revisions are returned, which might not be published. Returned label * resource names don't reference a specific revision (`labels/{id}`). */ publishedOnly?: boolean; /** * Set to `true` in order to use the user's admin credentials. This will * return all Labels within the customer. */ useAdminAccess?: boolean; /** * When specified, only certain fields belonging to the indicated view are * returned. */ view?: | "LABEL_VIEW_BASIC" | "LABEL_VIEW_FULL"; }