googleapis/build/src/apis/people/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';
/**
 * People API
 *
 * Provides access to information about profiles and contacts.
 *
 * @example
 * const google = require('googleapis');
 * const people = google.people('v1');
 *
 * @namespace people
 * @type {Function}
 * @version v1
 * @variation v1
 * @param {object=} options Options for People
 */
export declare class People {
    _options: GlobalOptions;
    google: GoogleApis;
    root: this;
    contactGroups: Resource$Contactgroups;
    people: Resource$People;
    constructor(options: GlobalOptions, google: GoogleApis);
    getRoot(): this;
}
/**
 * A person's physical address. May be a P.O. box or street address. All
 * fields are optional.
 */
export interface Schema$Address {
    /**
     * The city of the address.
     */
    city: string;
    /**
     * The country of the address.
     */
    country: string;
    /**
     * The [ISO 3166-1 alpha-2](http://www.iso.org/iso/country_codes.htm) country
     * code of the address.
     */
    countryCode: string;
    /**
     * The extended address of the address; for example, the apartment number.
     */
    extendedAddress: string;
    /**
     * The read-only type of the address translated and formatted in the
     * viewer's account locale or the `Accept-Language` HTTP header locale.
     */
    formattedType: string;
    /**
     * The unstructured value of the address. If this is not set by the user it
     * will be automatically constructed from structured values.
     */
    formattedValue: string;
    /**
     * Metadata about the address.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The P.O. box of the address.
     */
    poBox: string;
    /**
     * The postal code of the address.
     */
    postalCode: string;
    /**
     * The region of the address; for example, the state or province.
     */
    region: string;
    /**
     * The street address.
     */
    streetAddress: string;
    /**
     * The type of the address. The type can be custom or predefined. Possible
     * values include, but are not limited to, the following:  * `home` * `work` *
     * `other`
     */
    type: string;
}
/**
 * A person's age range.
 */
export interface Schema$AgeRangeType {
    /**
     * The age range.
     */
    ageRange: string;
    /**
     * Metadata about the age range.
     */
    metadata: Schema$FieldMetadata;
}
/**
 * The response to a batch get contact groups request.
 */
export interface Schema$BatchGetContactGroupsResponse {
    /**
     * The list of responses for each requested contact group resource.
     */
    responses: Schema$ContactGroupResponse[];
}
/**
 * A person's short biography.
 */
export interface Schema$Biography {
    /**
     * The content type of the biography.
     */
    contentType: string;
    /**
     * Metadata about the biography.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The short biography.
     */
    value: string;
}
/**
 * A person's birthday. At least one of the `date` and `text` fields are
 * specified. The `date` and `text` fields typically represent the same date,
 * but are not guaranteed to.
 */
export interface Schema$Birthday {
    /**
     * The date of the birthday.
     */
    date: Schema$Date;
    /**
     * Metadata about the birthday.
     */
    metadata: Schema$FieldMetadata;
    /**
     * A free-form string representing the user's birthday.
     */
    text: string;
}
/**
 * A person's bragging rights.
 */
export interface Schema$BraggingRights {
    /**
     * Metadata about the bragging rights.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The bragging rights; for example, `climbed mount everest`.
     */
    value: string;
}
/**
 * A contact group.
 */
export interface Schema$ContactGroup {
    /**
     * The [HTTP entity tag](https://en.wikipedia.org/wiki/HTTP_ETag) of the
     * resource. Used for web cache validation.
     */
    etag: string;
    /**
     * The read-only name translated and formatted in the viewer's account
     * locale or the `Accept-Language` HTTP header locale for system groups names.
     * Group names set by the owner are the same as name.
     */
    formattedName: string;
    /**
     * The read-only contact group type.
     */
    groupType: string;
    /**
     * The total number of contacts in the group irrespective of max members in
     * specified in the request.
     */
    memberCount: number;
    /**
     * The list of contact person resource names that are members of the contact
     * group. The field is not populated for LIST requests and can only be updated
     * through the
     * [ModifyContactGroupMembers](/people/api/rest/v1/contactgroups/members/modify).
     */
    memberResourceNames: string[];
    /**
     * Metadata about the contact group.
     */
    metadata: Schema$ContactGroupMetadata;
    /**
     * The contact group name set by the group owner or a system provided name for
     * system groups.
     */
    name: string;
    /**
     * The resource name for the contact group, assigned by the server. An ASCII
     * string, in the form of
     * `contactGroups/`<var>contact_group_id</var>.
     */
    resourceName: string;
}
/**
 * A Google contact group membership.
 */
export interface Schema$ContactGroupMembership {
    /**
     * The contact group ID for the contact group membership. The contact group ID
     * can be custom or predefined. Possible values include, but are not limited
     * to, the following:  *  `myContacts` *  `starred` *  A numerical ID for
     * user-created groups.
     */
    contactGroupId: string;
}
/**
 * The read-only metadata about a contact group.
 */
export interface Schema$ContactGroupMetadata {
    /**
     * True if the contact group resource has been deleted. Populated only for
     * [`ListContactGroups`](/people/api/rest/v1/contactgroups/list) requests that
     * include a sync token.
     */
    deleted: boolean;
    /**
     * The time the group was last updated.
     */
    updateTime: string;
}
/**
 * The response for a specific contact group.
 */
export interface Schema$ContactGroupResponse {
    /**
     * The contact group.
     */
    contactGroup: Schema$ContactGroup;
    /**
     * The original requested resource name.
     */
    requestedResourceName: string;
    /**
     * The status of the response.
     */
    status: Schema$Status;
}
/**
 * A person's read-only cover photo. A large image shown on the person's
 * profile page that represents who they are or what they care about.
 */
export interface Schema$CoverPhoto {
    /**
     * True if the cover photo is the default cover photo; false if the cover
     * photo is a user-provided cover photo.
     */
    default: boolean;
    /**
     * Metadata about the cover photo.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The URL of the cover photo.
     */
    url: string;
}
/**
 * A request to create a new contact group.
 */
export interface Schema$CreateContactGroupRequest {
    /**
     * The contact group to create.
     */
    contactGroup: Schema$ContactGroup;
}
/**
 * Represents a whole calendar date, for example a date of birth. The time of
 * day and time zone are either specified elsewhere or are not significant. The
 * date is relative to the [Proleptic Gregorian
 * Calendar](https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar). The
 * day may be 0 to represent a year and month where the day is not significant.
 * The year may be 0 to represent a month and day independent of year; for
 * example, anniversary date.
 */
export interface Schema$Date {
    /**
     * Day of month. Must be from 1 to 31 and valid for the year and month, or 0
     * if specifying a year/month where the day is not significant.
     */
    day: number;
    /**
     * Month of year. Must be from 1 to 12, or 0 if specifying a date without a
     * month.
     */
    month: number;
    /**
     * Year of date. Must be from 1 to 9999, or 0 if specifying a date without a
     * year.
     */
    year: number;
}
/**
 * A Google Apps Domain membership.
 */
export interface Schema$DomainMembership {
    /**
     * True if the person is in the viewer's Google Apps domain.
     */
    inViewerDomain: boolean;
}
/**
 * A person's email address.
 */
export interface Schema$EmailAddress {
    /**
     * The display name of the email.
     */
    displayName: string;
    /**
     * The read-only type of the email address translated and formatted in the
     * viewer's account locale or the `Accept-Language` HTTP header locale.
     */
    formattedType: string;
    /**
     * Metadata about the email address.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The type of the email address. The type can be custom or predefined.
     * Possible values include, but are not limited to, the following:  * `home` *
     * `work` * `other`
     */
    type: string;
    /**
     * The email address.
     */
    value: string;
}
/**
 * A generic empty message that you can re-use to avoid defining duplicated
 * empty messages in your APIs. A typical example is to use it as the request or
 * the response type of an API method. For instance:      service Foo { rpc
 * Bar(google.protobuf.Empty) returns (google.protobuf.Empty);     }  The JSON
 * representation for `Empty` is empty JSON object `{}`.
 */
export interface Schema$Empty {
}
/**
 * An event related to the person.
 */
export interface Schema$Event {
    /**
     * The date of the event.
     */
    date: Schema$Date;
    /**
     * The read-only type of the event translated and formatted in the
     * viewer's account locale or the `Accept-Language` HTTP header locale.
     */
    formattedType: string;
    /**
     * Metadata about the event.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The type of the event. The type can be custom or predefined. Possible
     * values include, but are not limited to, the following:  * `anniversary` *
     * `other`
     */
    type: string;
}
/**
 * Metadata about a field.
 */
export interface Schema$FieldMetadata {
    /**
     * True if the field is the primary field; false if the field is a secondary
     * field.
     */
    primary: boolean;
    /**
     * The source of the field.
     */
    source: Schema$Source;
    /**
     * True if the field is verified; false if the field is unverified. A verified
     * field is typically a name, email address, phone number, or website that has
     * been confirmed to be owned by the person.
     */
    verified: boolean;
}
/**
 * A person's gender.
 */
export interface Schema$Gender {
    /**
     * The read-only value of the gender translated and formatted in the
     * viewer's account locale or the `Accept-Language` HTTP header locale.
     */
    formattedValue: string;
    /**
     * Metadata about the gender.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The gender for the person. The gender can be custom or predefined. Possible
     * values include, but are not limited to, the following:  * `male` * `female`
     * * `other` * `unknown`
     */
    value: string;
}
export interface Schema$GetPeopleResponse {
    /**
     * The response for each requested resource name.
     */
    responses: Schema$PersonResponse[];
}
/**
 * A person's instant messaging client.
 */
export interface Schema$ImClient {
    /**
     * The read-only protocol of the IM client formatted in the viewer's
     * account locale or the `Accept-Language` HTTP header locale.
     */
    formattedProtocol: string;
    /**
     * The read-only type of the IM client translated and formatted in the
     * viewer's account locale or the `Accept-Language` HTTP header locale.
     */
    formattedType: string;
    /**
     * Metadata about the IM client.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The protocol of the IM client. The protocol can be custom or predefined.
     * Possible values include, but are not limited to, the following:  * `aim` *
     * `msn` * `yahoo` * `skype` * `qq` * `googleTalk` * `icq` * `jabber` *
     * `netMeeting`
     */
    protocol: string;
    /**
     * The type of the IM client. The type can be custom or predefined. Possible
     * values include, but are not limited to, the following:  * `home` * `work` *
     * `other`
     */
    type: string;
    /**
     * The user name used in the IM client.
     */
    username: string;
}
/**
 * One of the person's interests.
 */
export interface Schema$Interest {
    /**
     * Metadata about the interest.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The interest; for example, `stargazing`.
     */
    value: string;
}
export interface Schema$ListConnectionsResponse {
    /**
     * The list of people that the requestor is connected to.
     */
    connections: Schema$Person[];
    /**
     * The token that can be used to retrieve the next page of results.
     */
    nextPageToken: string;
    /**
     * The token that can be used to retrieve changes since the last request.
     */
    nextSyncToken: string;
    /**
     * The total number of items in the list without pagination.
     */
    totalItems: number;
    /**
     * **DEPRECATED** (Please use totalItems) The total number of people in the
     * list without pagination.
     */
    totalPeople: number;
}
/**
 * The response to a list contact groups request.
 */
export interface Schema$ListContactGroupsResponse {
    /**
     * The list of contact groups. Members of the contact groups are not
     * populated.
     */
    contactGroups: Schema$ContactGroup[];
    /**
     * The token that can be used to retrieve the next page of results.
     */
    nextPageToken: string;
    /**
     * The token that can be used to retrieve changes since the last request.
     */
    nextSyncToken: string;
    /**
     * The total number of items in the list without pagination.
     */
    totalItems: number;
}
/**
 * A person's locale preference.
 */
export interface Schema$Locale {
    /**
     * Metadata about the locale.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The well-formed [IETF BCP 47](https://tools.ietf.org/html/bcp47) language
     * tag representing the locale.
     */
    value: string;
}
/**
 * A person's read-only membership in a group.
 */
export interface Schema$Membership {
    /**
     * The contact group membership.
     */
    contactGroupMembership: Schema$ContactGroupMembership;
    /**
     * The domain membership.
     */
    domainMembership: Schema$DomainMembership;
    /**
     * Metadata about the membership.
     */
    metadata: Schema$FieldMetadata;
}
/**
 * A request to modify an existing contact group's members. Contacts can be
 * removed from any group but they can only be added to a user group or
 * myContacts or starred system groups.
 */
export interface Schema$ModifyContactGroupMembersRequest {
    /**
     * The resource names of the contact people to add in the form of in the form
     * `people/`<var>person_id</var>.
     */
    resourceNamesToAdd: string[];
    /**
     * The resource names of the contact people to remove in the form of in the
     * form of `people/`<var>person_id</var>.
     */
    resourceNamesToRemove: string[];
}
/**
 * The response to a modify contact group members request.
 */
export interface Schema$ModifyContactGroupMembersResponse {
    /**
     * The contact people resource names that were not found.
     */
    notFoundResourceNames: string[];
}
/**
 * A person's name. If the name is a mononym, the family name is empty.
 */
export interface Schema$Name {
    /**
     * The read-only display name formatted according to the locale specified by
     * the viewer's account or the `Accept-Language` HTTP header.
     */
    displayName: string;
    /**
     * The read-only display name with the last name first formatted according to
     * the locale specified by the viewer's account or the `Accept-Language`
     * HTTP header.
     */
    displayNameLastFirst: string;
    /**
     * The family name.
     */
    familyName: string;
    /**
     * The given name.
     */
    givenName: string;
    /**
     * The honorific prefixes, such as `Mrs.` or `Dr.`
     */
    honorificPrefix: string;
    /**
     * The honorific suffixes, such as `Jr.`
     */
    honorificSuffix: string;
    /**
     * Metadata about the name.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The middle name(s).
     */
    middleName: string;
    /**
     * The family name spelled as it sounds.
     */
    phoneticFamilyName: string;
    /**
     * The full name spelled as it sounds.
     */
    phoneticFullName: string;
    /**
     * The given name spelled as it sounds.
     */
    phoneticGivenName: string;
    /**
     * The honorific prefixes spelled as they sound.
     */
    phoneticHonorificPrefix: string;
    /**
     * The honorific suffixes spelled as they sound.
     */
    phoneticHonorificSuffix: string;
    /**
     * The middle name(s) spelled as they sound.
     */
    phoneticMiddleName: string;
}
/**
 * A person's nickname.
 */
export interface Schema$Nickname {
    /**
     * Metadata about the nickname.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The type of the nickname.
     */
    type: string;
    /**
     * The nickname.
     */
    value: string;
}
/**
 * A person's occupation.
 */
export interface Schema$Occupation {
    /**
     * Metadata about the occupation.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The occupation; for example, `carpenter`.
     */
    value: string;
}
/**
 * A person's past or current organization. Overlapping date ranges are
 * permitted.
 */
export interface Schema$Organization {
    /**
     * True if the organization is the person's current organization; false if
     * the organization is a past organization.
     */
    current: boolean;
    /**
     * The person's department at the organization.
     */
    department: string;
    /**
     * The domain name associated with the organization; for example,
     * `google.com`.
     */
    domain: string;
    /**
     * The end date when the person left the organization.
     */
    endDate: Schema$Date;
    /**
     * The read-only type of the organization translated and formatted in the
     * viewer's account locale or the `Accept-Language` HTTP header locale.
     */
    formattedType: string;
    /**
     * The person's job description at the organization.
     */
    jobDescription: string;
    /**
     * The location of the organization office the person works at.
     */
    location: string;
    /**
     * Metadata about the organization.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The name of the organization.
     */
    name: string;
    /**
     * The phonetic name of the organization.
     */
    phoneticName: string;
    /**
     * The start date when the person joined the organization.
     */
    startDate: Schema$Date;
    /**
     * The symbol associated with the organization; for example, a stock ticker
     * symbol, abbreviation, or acronym.
     */
    symbol: string;
    /**
     * The person's job title at the organization.
     */
    title: string;
    /**
     * The type of the organization. The type can be custom or predefined.
     * Possible values include, but are not limited to, the following:  * `work` *
     * `school`
     */
    type: string;
}
/**
 * Information about a person merged from various data sources such as the
 * authenticated user's contacts and profile data.  Most fields can have
 * multiple items. The items in a field have no guaranteed order, but each
 * non-empty field is guaranteed to have exactly one field with
 * `metadata.primary` set to true.
 */
export interface Schema$Person {
    /**
     * The person's street addresses.
     */
    addresses: Schema$Address[];
    /**
     * **DEPRECATED** (Please use `person.ageRanges` instead)**  The person's
     * read-only age range.
     */
    ageRange: string;
    /**
     * The person's read-only age ranges.
     */
    ageRanges: Schema$AgeRangeType[];
    /**
     * The person's biographies.
     */
    biographies: Schema$Biography[];
    /**
     * The person's birthdays.
     */
    birthdays: Schema$Birthday[];
    /**
     * The person's bragging rights.
     */
    braggingRights: Schema$BraggingRights[];
    /**
     * The person's read-only cover photos.
     */
    coverPhotos: Schema$CoverPhoto[];
    /**
     * The person's email addresses.
     */
    emailAddresses: Schema$EmailAddress[];
    /**
     * The [HTTP entity tag](https://en.wikipedia.org/wiki/HTTP_ETag) of the
     * resource. Used for web cache validation.
     */
    etag: string;
    /**
     * The person's events.
     */
    events: Schema$Event[];
    /**
     * The person's genders.
     */
    genders: Schema$Gender[];
    /**
     * The person's instant messaging clients.
     */
    imClients: Schema$ImClient[];
    /**
     * The person's interests.
     */
    interests: Schema$Interest[];
    /**
     * The person's locale preferences.
     */
    locales: Schema$Locale[];
    /**
     * The person's read-only group memberships.
     */
    memberships: Schema$Membership[];
    /**
     * Read-only metadata about the person.
     */
    metadata: Schema$PersonMetadata;
    /**
     * The person's names.
     */
    names: Schema$Name[];
    /**
     * The person's nicknames.
     */
    nicknames: Schema$Nickname[];
    /**
     * The person's occupations.
     */
    occupations: Schema$Occupation[];
    /**
     * The person's past or current organizations.
     */
    organizations: Schema$Organization[];
    /**
     * The person's phone numbers.
     */
    phoneNumbers: Schema$PhoneNumber[];
    /**
     * The person's read-only photos.
     */
    photos: Schema$Photo[];
    /**
     * The person's relations.
     */
    relations: Schema$Relation[];
    /**
     * The person's read-only relationship interests.
     */
    relationshipInterests: Schema$RelationshipInterest[];
    /**
     * The person's read-only relationship statuses.
     */
    relationshipStatuses: Schema$RelationshipStatus[];
    /**
     * The person's residences.
     */
    residences: Schema$Residence[];
    /**
     * The resource name for the person, assigned by the server. An ASCII string
     * with a max length of 27 characters, in the form of
     * `people/`<var>person_id</var>.
     */
    resourceName: string;
    /**
     * The person's skills.
     */
    skills: Schema$Skill[];
    /**
     * The person's read-only taglines.
     */
    taglines: Schema$Tagline[];
    /**
     * The person's associated URLs.
     */
    urls: Schema$Url[];
    /**
     * The person's user defined data.
     */
    userDefined: Schema$UserDefined[];
}
/**
 * The read-only metadata about a person.
 */
export interface Schema$PersonMetadata {
    /**
     * True if the person resource has been deleted. Populated only for
     * [`connections.list`](/people/api/rest/v1/people.connections/list) requests
     * that include a sync token.
     */
    deleted: boolean;
    /**
     * Resource names of people linked to this resource.
     */
    linkedPeopleResourceNames: string[];
    /**
     * **DEPRECATED** (Please use
     * `person.metadata.sources.profileMetadata.objectType` instead)  The type of
     * the person object.
     */
    objectType: string;
    /**
     * Any former resource names this person has had. Populated only for
     * [`connections.list`](/people/api/rest/v1/people.connections/list) requests
     * that include a sync token.  The resource name may change when adding or
     * removing fields that link a contact and profile such as a verified email,
     * verified phone number, or profile URL.
     */
    previousResourceNames: string[];
    /**
     * The sources of data for the person.
     */
    sources: Schema$Source[];
}
/**
 * The response for a single person
 */
export interface Schema$PersonResponse {
    /**
     * **DEPRECATED** (Please use status instead)  [HTTP 1.1 status code]
     * (http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html).
     */
    httpStatusCode: number;
    /**
     * The person.
     */
    person: Schema$Person;
    /**
     * The original requested resource name. May be different than the resource
     * name on the returned person.  The resource name can change when adding or
     * removing fields that link a contact and profile such as a verified email,
     * verified phone number, or a profile URL.
     */
    requestedResourceName: string;
    /**
     * The status of the response.
     */
    status: Schema$Status;
}
/**
 * A person's phone number.
 */
export interface Schema$PhoneNumber {
    /**
     * The read-only canonicalized [ITU-T
     * E.164](https://law.resource.org/pub/us/cfr/ibr/004/itu-t.E.164.1.2008.pdf)
     * form of the phone number.
     */
    canonicalForm: string;
    /**
     * The read-only type of the phone number translated and formatted in the
     * viewer's account locale or the `Accept-Language` HTTP header locale.
     */
    formattedType: string;
    /**
     * Metadata about the phone number.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The type of the phone number. The type can be custom or predefined.
     * Possible values include, but are not limited to, the following:  * `home` *
     * `work` * `mobile` * `homeFax` * `workFax` * `otherFax` * `pager` *
     * `workMobile` * `workPager` * `main` * `googleVoice` * `other`
     */
    type: string;
    /**
     * The phone number.
     */
    value: string;
}
/**
 * A person's read-only photo. A picture shown next to the person's name
 * to help others recognize the person.
 */
export interface Schema$Photo {
    /**
     * True if the photo is a default photo; false if the photo is a user-provided
     * photo.
     */
    default: boolean;
    /**
     * Metadata about the photo.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The URL of the photo. You can change the desired size by appending a query
     * parameter `sz=`<var>size</var> at the end of the url. Example:
     * `https://lh3.googleusercontent.com/-T_wVWLlmg7w/AAAAAAAAAAI/AAAAAAAABa8/00gzXvDBYqw/s100/photo.jpg?sz=50`
     */
    url: string;
}
/**
 * The read-only metadata about a profile.
 */
export interface Schema$ProfileMetadata {
    /**
     * The profile object type.
     */
    objectType: string;
    /**
     * The user types.
     */
    userTypes: string[];
}
/**
 * A person's relation to another person.
 */
export interface Schema$Relation {
    /**
     * The type of the relation translated and formatted in the viewer's
     * account locale or the locale specified in the Accept-Language HTTP header.
     */
    formattedType: string;
    /**
     * Metadata about the relation.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The name of the other person this relation refers to.
     */
    person: string;
    /**
     * The person's relation to the other person. The type can be custom or
     * predefined. Possible values include, but are not limited to, the following
     * values:  * `spouse` * `child` * `mother` * `father` * `parent` * `brother`
     * * `sister` * `friend` * `relative` * `domesticPartner` * `manager` *
     * `assistant` * `referredBy` * `partner`
     */
    type: string;
}
/**
 * A person's read-only relationship interest .
 */
export interface Schema$RelationshipInterest {
    /**
     * The value of the relationship interest translated and formatted in the
     * viewer's account locale or the locale specified in the Accept-Language
     * HTTP header.
     */
    formattedValue: string;
    /**
     * Metadata about the relationship interest.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The kind of relationship the person is looking for. The value can be custom
     * or predefined. Possible values include, but are not limited to, the
     * following values:  * `friend` * `date` * `relationship` * `networking`
     */
    value: string;
}
/**
 * A person's read-only relationship status.
 */
export interface Schema$RelationshipStatus {
    /**
     * The read-only value of the relationship status translated and formatted in
     * the viewer's account locale or the `Accept-Language` HTTP header
     * locale.
     */
    formattedValue: string;
    /**
     * Metadata about the relationship status.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The relationship status. The value can be custom or predefined. Possible
     * values include, but are not limited to, the following:  * `single` *
     * `inARelationship` * `engaged` * `married` * `itsComplicated` *
     * `openRelationship` * `widowed` * `inDomesticPartnership` * `inCivilUnion`
     */
    value: string;
}
/**
 * A person's past or current residence.
 */
export interface Schema$Residence {
    /**
     * True if the residence is the person's current residence; false if the
     * residence is a past residence.
     */
    current: boolean;
    /**
     * Metadata about the residence.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The address of the residence.
     */
    value: string;
}
/**
 * A skill that the person has.
 */
export interface Schema$Skill {
    /**
     * Metadata about the skill.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The skill; for example, `underwater basket weaving`.
     */
    value: string;
}
/**
 * The source of a field.
 */
export interface Schema$Source {
    /**
     * **Only populated in `person.metadata.sources`.**  The [HTTP entity
     * tag](https://en.wikipedia.org/wiki/HTTP_ETag) of the source. Used for web
     * cache validation.
     */
    etag: string;
    /**
     * The unique identifier within the source type generated by the server.
     */
    id: string;
    /**
     * **Only populated in `person.metadata.sources`.**  Metadata about a source
     * of type PROFILE.
     */
    profileMetadata: Schema$ProfileMetadata;
    /**
     * The source type.
     */
    type: string;
    /**
     * **Only populated in `person.metadata.sources`.**  Last update timestamp of
     * this source.
     */
    updateTime: string;
}
/**
 * The `Status` type defines a logical error model that is suitable for
 * different programming environments, including REST APIs and RPC APIs. It is
 * used by [gRPC](https://github.com/grpc). The error model is designed to be:
 * - Simple to use and understand for most users - Flexible enough to meet
 * unexpected needs  # Overview  The `Status` message contains three pieces of
 * data: error code, error message, and error details. The error code should be
 * an enum value of google.rpc.Code, but it may accept additional error codes if
 * needed.  The error message should be a developer-facing English message that
 * helps developers *understand* and *resolve* the error. If a localized
 * user-facing error message is needed, put the localized message in the error
 * details or localize it in the client. The optional error details may contain
 * arbitrary information about the error. There is a predefined set of error
 * detail types in the package `google.rpc` that can be used for common error
 * conditions.  # Language mapping  The `Status` message is the logical
 * representation of the error model, but it is not necessarily the actual wire
 * format. When the `Status` message is exposed in different client libraries
 * and different wire protocols, it can be mapped differently. For example, it
 * will likely be mapped to some exceptions in Java, but more likely mapped to
 * some error codes in C.  # Other uses  The error model and the `Status`
 * message can be used in a variety of environments, either with or without
 * APIs, to provide a consistent developer experience across different
 * environments.  Example uses of this error model include:  - Partial errors.
 * If a service needs to return partial errors to the client,     it may embed
 * the `Status` in the normal response to indicate the partial     errors.  -
 * Workflow errors. A typical workflow has multiple steps. Each step may have a
 * `Status` message for error reporting.  - Batch operations. If a client uses
 * batch request and batch response, the     `Status` message should be used
 * directly inside batch response, one for     each error sub-response.  -
 * Asynchronous operations. If an API call embeds asynchronous operation results
 * in its response, the status of those operations should be     represented
 * directly using the `Status` message.  - Logging. If some API errors are
 * stored in logs, the message `Status` could     be used directly after any
 * stripping needed for security/privacy reasons.
 */
export interface Schema$Status {
    /**
     * The status code, which should be an enum value of google.rpc.Code.
     */
    code: number;
    /**
     * A list of messages that carry the error details.  There is a common set of
     * message types for APIs to use.
     */
    details: any[];
    /**
     * A developer-facing error message, which should be in English. Any
     * user-facing error message should be localized and sent in the
     * google.rpc.Status.details field, or localized by the client.
     */
    message: string;
}
/**
 * A read-only brief one-line description of the person.
 */
export interface Schema$Tagline {
    /**
     * Metadata about the tagline.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The tagline.
     */
    value: string;
}
/**
 * A request to update an existing user contact group. All updated fields will
 * be replaced.
 */
export interface Schema$UpdateContactGroupRequest {
    /**
     * The contact group to update.
     */
    contactGroup: Schema$ContactGroup;
}
/**
 * A person's associated URLs.
 */
export interface Schema$Url {
    /**
     * The read-only type of the URL translated and formatted in the viewer's
     * account locale or the `Accept-Language` HTTP header locale.
     */
    formattedType: string;
    /**
     * Metadata about the URL.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The type of the URL. The type can be custom or predefined. Possible values
     * include, but are not limited to, the following:  * `home` * `work` * `blog`
     * * `profile` * `homePage` * `ftp` * `reservations` * `appInstallPage`:
     * website for a Google+ application. * `other`
     */
    type: string;
    /**
     * The URL.
     */
    value: string;
}
/**
 * Arbitrary user data that is populated by the end users.
 */
export interface Schema$UserDefined {
    /**
     * The end user specified key of the user defined data.
     */
    key: string;
    /**
     * Metadata about the user defined data.
     */
    metadata: Schema$FieldMetadata;
    /**
     * The end user specified value of the user defined data.
     */
    value: string;
}
export declare class Resource$Contactgroups {
    root: People;
    members: Resource$Contactgroups$Members;
    constructor(root: People);
    getRoot(): People;
    /**
     * people.contactGroups.batchGet
     * @desc Get a list of contact groups owned by the authenticated user by
     * specifying a list of contact group resource names.
     * @alias people.contactGroups.batchGet
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {integer=} params.maxMembers Specifies the maximum number of members to return for each group.
     * @param {string=} params.resourceNames The resource names of the contact groups to get.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    batchGet(params?: any, options?: MethodOptions): AxiosPromise<Schema$BatchGetContactGroupsResponse>;
    batchGet(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$BatchGetContactGroupsResponse>, callback?: BodyResponseCallback<Schema$BatchGetContactGroupsResponse>): void;
    /**
     * people.contactGroups.create
     * @desc Create a new contact group owned by the authenticated user.
     * @alias people.contactGroups.create
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {().CreateContactGroupRequest} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    create(params?: any, options?: MethodOptions): AxiosPromise<Schema$ContactGroup>;
    create(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$ContactGroup>, callback?: BodyResponseCallback<Schema$ContactGroup>): void;
    /**
     * people.contactGroups.delete
     * @desc Delete an existing contact group owned by the authenticated user by
     * specifying a contact group resource name.
     * @alias people.contactGroups.delete
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {boolean=} params.deleteContacts Set to true to also delete the contacts in the specified group.
     * @param {string} params.resourceName The resource name of the contact group to delete.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    delete(params?: any, options?: MethodOptions): AxiosPromise<Schema$Empty>;
    delete(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Empty>, callback?: BodyResponseCallback<Schema$Empty>): void;
    /**
     * people.contactGroups.get
     * @desc Get a specific contact group owned by the authenticated user by
     * specifying a contact group resource name.
     * @alias people.contactGroups.get
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {integer=} params.maxMembers Specifies the maximum number of members to return.
     * @param {string} params.resourceName The resource name of the contact group to get.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    get(params?: any, options?: MethodOptions): AxiosPromise<Schema$ContactGroup>;
    get(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$ContactGroup>, callback?: BodyResponseCallback<Schema$ContactGroup>): void;
    /**
     * people.contactGroups.list
     * @desc List all contact groups owned by the authenticated user. Members of
     * the contact groups are not populated.
     * @alias people.contactGroups.list
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {integer=} params.pageSize The maximum number of resources to return.
     * @param {string=} params.pageToken The next_page_token value returned from a previous call to [ListContactGroups](/people/api/rest/v1/contactgroups/list). Requests the next page of resources.
     * @param {string=} params.syncToken A sync token, returned by a previous call to `contactgroups.list`. Only resources changed since the sync token was created will be returned.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    list(params?: any, options?: MethodOptions): AxiosPromise<Schema$ListContactGroupsResponse>;
    list(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$ListContactGroupsResponse>, callback?: BodyResponseCallback<Schema$ListContactGroupsResponse>): void;
    /**
     * people.contactGroups.update
     * @desc Update the name of an existing contact group owned by the
     * authenticated user.
     * @alias people.contactGroups.update
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.resourceName The resource name for the contact group, assigned by the server. An ASCII string, in the form of `contactGroups/`<var>contact_group_id</var>.
     * @param {().UpdateContactGroupRequest} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    update(params?: any, options?: MethodOptions): AxiosPromise<Schema$ContactGroup>;
    update(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$ContactGroup>, callback?: BodyResponseCallback<Schema$ContactGroup>): void;
}
export declare class Resource$Contactgroups$Members {
    root: People;
    constructor(root: People);
    getRoot(): People;
    /**
     * people.contactGroups.members.modify
     * @desc Modify the members of a contact group owned by the authenticated
     * user.
     * @alias people.contactGroups.members.modify
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.resourceName The resource name of the contact group to modify.
     * @param {().ModifyContactGroupMembersRequest} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    modify(params?: any, options?: MethodOptions): AxiosPromise<Schema$ModifyContactGroupMembersResponse>;
    modify(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$ModifyContactGroupMembersResponse>, callback?: BodyResponseCallback<Schema$ModifyContactGroupMembersResponse>): void;
}
export declare class Resource$People {
    root: People;
    connections: Resource$People$Connections;
    constructor(root: People);
    getRoot(): People;
    /**
     * people.people.createContact
     * @desc Create a new contact and return the person resource for that contact.
     * @alias people.people.createContact
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string=} params.parent The resource name of the owning person resource.
     * @param {().Person} params.resource Request body data
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    createContact(params?: any, options?: MethodOptions): AxiosPromise<Schema$Person>;
    createContact(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Person>, callback?: BodyResponseCallback<Schema$Person>): void;
    /**
     * people.people.deleteContact
     * @desc Delete a contact person. Any non-contact data will not be deleted.
     * @alias people.people.deleteContact
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string} params.resourceName The resource name of the contact to delete.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    deleteContact(params?: any, options?: MethodOptions): AxiosPromise<Schema$Empty>;
    deleteContact(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Empty>, callback?: BodyResponseCallback<Schema$Empty>): void;
    /**
     * people.people.get
     * @desc Provides information about a person by specifying a resource name.
     * Use `people/me` to indicate the authenticated user. <br> The request throws
     * a 400 error if 'personFields' is not specified.
     * @alias people.people.get
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string=} params.personFields **Required.** A field mask to restrict which fields on the person are returned. Multiple fields can be specified by separating them with commas. Valid values are:  * addresses * ageRanges * biographies * birthdays * braggingRights * coverPhotos * emailAddresses * events * genders * imClients * interests * locales * memberships * metadata * names * nicknames * occupations * organizations * phoneNumbers * photos * relations * relationshipInterests * relationshipStatuses * residences * skills * taglines * urls
     * @param {string=} params.requestMask.includeField **Required.** Comma-separated list of person fields to be included in the response. Each path should start with `person.`: for example, `person.names` or `person.photos`.
     * @param {string} params.resourceName The resource name of the person to provide information about.  - To get information about the authenticated user, specify `people/me`. - To get information about a google account, specify  `people/`<var>account_id</var>. - To get information about a contact, specify the resource name that   identifies the contact as returned by [`people.connections.list`](/people/api/rest/v1/people.connections/list).
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    get(params?: any, options?: MethodOptions): AxiosPromise<Schema$Person>;
    get(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$Person>, callback?: BodyResponseCallback<Schema$Person>): void;
    /**
     * people.people.getBatchGet
     * @desc Provides information about a list of specific people by specifying a
     * list of requested resource names. Use `people/me` to indicate the
     * authenticated user. <br> The request throws a 400 error if 'personFields'
     * is not specified.
     * @alias people.people.getBatchGet
     * @memberOf! ()
     *
     * @param {object} params Parameters for request
     * @param {string=} params.personFields **Required.** A field mask to restrict which fields on each person are returned. Multiple fields can be specified by separating them with commas. Valid values are:  * addresses * ageRanges * biographies * birthdays * braggingRights * coverPhotos * emailAddresses * events * genders * imClients * interests * locales * memberships * metadata * names * nicknames * occupations * organizations * phoneNumbers * photos * relations * relationshipInterests * relationshipStatuses * residences * skills * taglines * urls
     * @param {string=} params.requestMask.includeField **Required.** Comma-separated list of person fields to be included in the response. Each path should start with `person.`: for example, `person.names` or `person.photos`.
     * @param {string=} params.resourceNames The resource names of the people to provide information about.  - To get information about the authenticated user, specify `people/me`. - To get information about a google account, specify   `people/`<var>account_id</var>. - To get information about a contact, specify the resource name that   identifies the contact as returned by [`people.connections.list`](/people/api/rest/v1/people.connections/list).  You can include up to 50 resource names in one request.
     * @param {object} [options] Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param {callback} callback The callback that handles the response.
     * @return {object} Request object
     */
    getBatchGet(params?: any, options?: MethodOptions): AxiosPromise<Schema$GetPeopleResponse>;
    getBatchGet(params?: any, options?: MethodOptions | BodyResponseCallback<Schema$GetPeopleResponse>, callback?: BodyResponseCallback<Schema$GetPeopleResponse>): void;
    /**
     * people.people.updateContact
     * @desc Update contact data for an existing contact person. Any non-contact
     * data will not be modified.  The request throws a 400 error if
     * `updatePersonFields` is not specified. <br> The request throws a 400 error
     * if `person.metadata.sources` is not specified for the contact to be
     * updated. <br> The request throws a 412 error if
     * `person.metadata.sources.etag` is different than the contact's etag, which
     * indicates the contact has changed since its data was read. Clients should
     * get