// 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<GoogleAppsDriveLabelsV2Label> {
    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<GoogleAppsDriveLabelsV2ListLabelsResponse> {
    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";
}