/**
         * directory.members.update
         * @desc Update membership of a user in the specified group.
         * @alias directory.members.update
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.groupKey Email or immutable ID of the group. If ID, it should match with id of group object
         * @param {string} params.memberKey Email or immutable ID of the user. If ID, it should match with id of member object
         * @param {().Member} 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?: Params$Resource$Members$Update, options?: MethodOptions): GaxiosPromise<Schema$Member>;


update(params: Params$Resource$Members$Update, options: MethodOptions | BodyResponseCallback<Schema$Member>, callback: BodyResponseCallback<Schema$Member>): void;


update(params: Params$Resource$Members$Update, callback: BodyResponseCallback<Schema$Member>): void;


update(callback: BodyResponseCallback<Schema$Member>): void;


/**
         * directory.mobiledevices.action
         * @desc Take action on Mobile Device
         * @alias directory.mobiledevices.action
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {string} params.resourceId Immutable ID of Mobile Device
         * @param {().MobileDeviceAction} 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
         */
action(params?: Params$Resource$Mobiledevices$Action, options?: MethodOptions): GaxiosPromise<void>;


action(params: Params$Resource$Mobiledevices$Action, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


action(params: Params$Resource$Mobiledevices$Action, callback: BodyResponseCallback<void>): void;


/**
         * directory.mobiledevices.delete
         * @desc Delete Mobile Device
         * @alias directory.mobiledevices.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {string} params.resourceId Immutable ID of Mobile Device
         * @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?: Params$Resource$Mobiledevices$Delete, options?: MethodOptions): GaxiosPromise<void>;


delete(params: Params$Resource$Mobiledevices$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


delete(params: Params$Resource$Mobiledevices$Delete, callback: BodyResponseCallback<void>): void;


/**
         * directory.mobiledevices.get
         * @desc Retrieve Mobile Device
         * @alias directory.mobiledevices.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {string=} params.projection Restrict information returned to a set of selected fields.
         * @param {string} params.resourceId Immutable ID of Mobile Device
         * @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?: Params$Resource$Mobiledevices$Get, options?: MethodOptions): GaxiosPromise<Schema$MobileDevice>;


get(params: Params$Resource$Mobiledevices$Get, options: MethodOptions | BodyResponseCallback<Schema$MobileDevice>, callback: BodyResponseCallback<Schema$MobileDevice>): void;


get(params: Params$Resource$Mobiledevices$Get, callback: BodyResponseCallback<Schema$MobileDevice>): void;


get(callback: BodyResponseCallback<Schema$MobileDevice>): void;


/**
         * directory.mobiledevices.list
         * @desc Retrieve all Mobile Devices of a customer (paginated)
         * @alias directory.mobiledevices.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {integer=} params.maxResults Maximum number of results to return. Default is 100
         * @param {string=} params.orderBy Column to use for sorting results
         * @param {string=} params.pageToken Token to specify next page in the list
         * @param {string=} params.projection Restrict information returned to a set of selected fields.
         * @param {string=} params.query Search string in the format given at http://support.google.com/a/bin/answer.py?answer=1408863#search
         * @param {string=} params.sortOrder Whether to return results in ascending or descending order. Only of use when orderBy is also used
         * @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?: Params$Resource$Mobiledevices$List, options?: MethodOptions): GaxiosPromise<Schema$MobileDevices>;


list(params: Params$Resource$Mobiledevices$List, options: MethodOptions | BodyResponseCallback<Schema$MobileDevices>, callback: BodyResponseCallback<Schema$MobileDevices>): void;


list(params: Params$Resource$Mobiledevices$List, callback: BodyResponseCallback<Schema$MobileDevices>): void;


list(callback: BodyResponseCallback<Schema$MobileDevices>): void;


/**
         * directory.notifications.delete
         * @desc Deletes a notification
         * @alias directory.notifications.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account. The customerId is also returned as part of the Users resource.
         * @param {string} params.notificationId The unique ID of the notification.
         * @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?: Params$Resource$Notifications$Delete, options?: MethodOptions): GaxiosPromise<void>;


delete(params: Params$Resource$Notifications$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


delete(params: Params$Resource$Notifications$Delete, callback: BodyResponseCallback<void>): void;


/**
         * directory.notifications.get
         * @desc Retrieves a notification.
         * @alias directory.notifications.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account. The customerId is also returned as part of the Users resource.
         * @param {string} params.notificationId The unique ID of the notification.
         * @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?: Params$Resource$Notifications$Get, options?: MethodOptions): GaxiosPromise<Schema$Notification>;


get(params: Params$Resource$Notifications$Get, options: MethodOptions | BodyResponseCallback<Schema$Notification>, callback: BodyResponseCallback<Schema$Notification>): void;


get(params: Params$Resource$Notifications$Get, callback: BodyResponseCallback<Schema$Notification>): void;


get(callback: BodyResponseCallback<Schema$Notification>): void;


/**
         * directory.notifications.list
         * @desc Retrieves a list of notifications.
         * @alias directory.notifications.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account.
         * @param {string=} params.language The ISO 639-1 code of the language notifications are returned in. The default is English (en).
         * @param {integer=} params.maxResults Maximum number of notifications to return per page. The default is 100.
         * @param {string=} params.pageToken The token to specify the page of results to retrieve.
         * @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?: Params$Resource$Notifications$List, options?: MethodOptions): GaxiosPromise<Schema$Notifications>;


list(params: Params$Resource$Notifications$List, options: MethodOptions | BodyResponseCallback<Schema$Notifications>, callback: BodyResponseCallback<Schema$Notifications>): void;


list(params: Params$Resource$Notifications$List, callback: BodyResponseCallback<Schema$Notifications>): void;


list(callback: BodyResponseCallback<Schema$Notifications>): void;


/**
         * directory.notifications.patch
         * @desc Updates a notification. This method supports patch semantics.
         * @alias directory.notifications.patch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account.
         * @param {string} params.notificationId The unique ID of the notification.
         * @param {().Notification} 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
         */
patch(params?: Params$Resource$Notifications$Patch, options?: MethodOptions): GaxiosPromise<Schema$Notification>;


patch(params: Params$Resource$Notifications$Patch, options: MethodOptions | BodyResponseCallback<Schema$Notification>, callback: BodyResponseCallback<Schema$Notification>): void;


patch(params: Params$Resource$Notifications$Patch, callback: BodyResponseCallback<Schema$Notification>): void;


patch(callback: BodyResponseCallback<Schema$Notification>): void;


/**
         * directory.notifications.update
         * @desc Updates a notification.
         * @alias directory.notifications.update
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account.
         * @param {string} params.notificationId The unique ID of the notification.
         * @param {().Notification} 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?: Params$Resource$Notifications$Update, options?: MethodOptions): GaxiosPromise<Schema$Notification>;


update(params: Params$Resource$Notifications$Update, options: MethodOptions | BodyResponseCallback<Schema$Notification>, callback: BodyResponseCallback<Schema$Notification>): void;


update(params: Params$Resource$Notifications$Update, callback: BodyResponseCallback<Schema$Notification>): void;


update(callback: BodyResponseCallback<Schema$Notification>): void;


/**
         * directory.orgunits.delete
         * @desc Remove organizational unit
         * @alias directory.orgunits.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {string} params.orgUnitPath Full path of the organizational unit or its ID
         * @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?: Params$Resource$Orgunits$Delete, options?: MethodOptions): GaxiosPromise<void>;


delete(params: Params$Resource$Orgunits$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


delete(params: Params$Resource$Orgunits$Delete, callback: BodyResponseCallback<void>): void;


/**
         * directory.orgunits.get
         * @desc Retrieve organizational unit
         * @alias directory.orgunits.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {string} params.orgUnitPath Full path of the organizational unit or its ID
         * @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?: Params$Resource$Orgunits$Get, options?: MethodOptions): GaxiosPromise<Schema$OrgUnit>;


get(params: Params$Resource$Orgunits$Get, options: MethodOptions | BodyResponseCallback<Schema$OrgUnit>, callback: BodyResponseCallback<Schema$OrgUnit>): void;


get(params: Params$Resource$Orgunits$Get, callback: BodyResponseCallback<Schema$OrgUnit>): void;


get(callback: BodyResponseCallback<Schema$OrgUnit>): void;


/**
         * directory.orgunits.insert
         * @desc Add organizational unit
         * @alias directory.orgunits.insert
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {().OrgUnit} 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
         */
insert(params?: Params$Resource$Orgunits$Insert, options?: MethodOptions): GaxiosPromise<Schema$OrgUnit>;


insert(params: Params$Resource$Orgunits$Insert, options: MethodOptions | BodyResponseCallback<Schema$OrgUnit>, callback: BodyResponseCallback<Schema$OrgUnit>): void;


insert(params: Params$Resource$Orgunits$Insert, callback: BodyResponseCallback<Schema$OrgUnit>): void;


insert(callback: BodyResponseCallback<Schema$OrgUnit>): void;


/**
         * directory.orgunits.list
         * @desc Retrieve all organizational units
         * @alias directory.orgunits.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {string=} params.orgUnitPath the URL-encoded organizational unit's path or its ID
         * @param {string=} params.type Whether to return all sub-organizations or just immediate children
         * @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?: Params$Resource$Orgunits$List, options?: MethodOptions): GaxiosPromise<Schema$OrgUnits>;


list(params: Params$Resource$Orgunits$List, options: MethodOptions | BodyResponseCallback<Schema$OrgUnits>, callback: BodyResponseCallback<Schema$OrgUnits>): void;


list(params: Params$Resource$Orgunits$List, callback: BodyResponseCallback<Schema$OrgUnits>): void;


list(callback: BodyResponseCallback<Schema$OrgUnits>): void;


/**
         * directory.orgunits.patch
         * @desc Update organizational unit. This method supports patch semantics.
         * @alias directory.orgunits.patch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {string} params.orgUnitPath Full path of the organizational unit or its ID
         * @param {().OrgUnit} 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
         */
patch(params?: Params$Resource$Orgunits$Patch, options?: MethodOptions): GaxiosPromise<Schema$OrgUnit>;


patch(params: Params$Resource$Orgunits$Patch, options: MethodOptions | BodyResponseCallback<Schema$OrgUnit>, callback: BodyResponseCallback<Schema$OrgUnit>): void;


patch(params: Params$Resource$Orgunits$Patch, callback: BodyResponseCallback<Schema$OrgUnit>): void;


patch(callback: BodyResponseCallback<Schema$OrgUnit>): void;


/**
         * directory.orgunits.update
         * @desc Update organizational unit
         * @alias directory.orgunits.update
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {string} params.orgUnitPath Full path of the organizational unit or its ID
         * @param {().OrgUnit} 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?: Params$Resource$Orgunits$Update, options?: MethodOptions): GaxiosPromise<Schema$OrgUnit>;


update(params: Params$Resource$Orgunits$Update, options: MethodOptions | BodyResponseCallback<Schema$OrgUnit>, callback: BodyResponseCallback<Schema$OrgUnit>): void;


update(params: Params$Resource$Orgunits$Update, callback: BodyResponseCallback<Schema$OrgUnit>): void;


update(callback: BodyResponseCallback<Schema$OrgUnit>): void;


/**
         * directory.privileges.list
         * @desc Retrieves a paginated list of all privileges for a customer.
         * @alias directory.privileges.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer Immutable ID of the G Suite account.
         * @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?: Params$Resource$Privileges$List, options?: MethodOptions): GaxiosPromise<Schema$Privileges>;


list(params: Params$Resource$Privileges$List, options: MethodOptions | BodyResponseCallback<Schema$Privileges>, callback: BodyResponseCallback<Schema$Privileges>): void;


list(params: Params$Resource$Privileges$List, callback: BodyResponseCallback<Schema$Privileges>): void;


list(callback: BodyResponseCallback<Schema$Privileges>): void;


/**
         * directory.resolvedAppAccessSettings.GetSettings
         * @desc Retrieves resolved app access settings of the logged in user.
         * @alias directory.resolvedAppAccessSettings.GetSettings
         * @memberOf! ()
         *
         * @param {object=} params Parameters for 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
         */
GetSettings(params?: Params$Resource$Resolvedappaccesssettings$Getsettings, options?: MethodOptions): GaxiosPromise<Schema$AppAccessCollections>;


GetSettings(params: Params$Resource$Resolvedappaccesssettings$Getsettings, options: MethodOptions | BodyResponseCallback<Schema$AppAccessCollections>, callback: BodyResponseCallback<Schema$AppAccessCollections>): void;


GetSettings(params: Params$Resource$Resolvedappaccesssettings$Getsettings, callback: BodyResponseCallback<Schema$AppAccessCollections>): void;


GetSettings(callback: BodyResponseCallback<Schema$AppAccessCollections>): void;


/**
         * directory.resolvedAppAccessSettings.ListTrustedApps
         * @desc Retrieves the list of apps trusted by the admin of the logged in
         * user.
         * @alias directory.resolvedAppAccessSettings.ListTrustedApps
         * @memberOf! ()
         *
         * @param {object=} params Parameters for 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
         */
ListTrustedApps(params?: Params$Resource$Resolvedappaccesssettings$Listtrustedapps, options?: MethodOptions): GaxiosPromise<Schema$TrustedApps>;


ListTrustedApps(params: Params$Resource$Resolvedappaccesssettings$Listtrustedapps, options: MethodOptions | BodyResponseCallback<Schema$TrustedApps>, callback: BodyResponseCallback<Schema$TrustedApps>): void;


ListTrustedApps(params: Params$Resource$Resolvedappaccesssettings$Listtrustedapps, callback: BodyResponseCallback<Schema$TrustedApps>): void;


ListTrustedApps(callback: BodyResponseCallback<Schema$TrustedApps>): void;


/**
         * directory.resources.buildings.delete
         * @desc Deletes a building.
         * @alias directory.resources.buildings.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.buildingId The ID of the building to delete.
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @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?: Params$Resource$Resources$Buildings$Delete, options?: MethodOptions): GaxiosPromise<void>;


delete(params: Params$Resource$Resources$Buildings$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


delete(params: Params$Resource$Resources$Buildings$Delete, callback: BodyResponseCallback<void>): void;


/**
         * directory.resources.buildings.get
         * @desc Retrieves a building.
         * @alias directory.resources.buildings.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.buildingId The unique ID of the building to retrieve.
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @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?: Params$Resource$Resources$Buildings$Get, options?: MethodOptions): GaxiosPromise<Schema$Building>;


get(params: Params$Resource$Resources$Buildings$Get, options: MethodOptions | BodyResponseCallback<Schema$Building>, callback: BodyResponseCallback<Schema$Building>): void;


get(params: Params$Resource$Resources$Buildings$Get, callback: BodyResponseCallback<Schema$Building>): void;


get(callback: BodyResponseCallback<Schema$Building>): void;


/**
         * directory.resources.buildings.insert
         * @desc Inserts a building.
         * @alias directory.resources.buildings.insert
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string=} params.coordinatesSource Source from which Building.coordinates are derived.
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {().Building} 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
         */
insert(params?: Params$Resource$Resources$Buildings$Insert, options?: MethodOptions): GaxiosPromise<Schema$Building>;


insert(params: Params$Resource$Resources$Buildings$Insert, options: MethodOptions | BodyResponseCallback<Schema$Building>, callback: BodyResponseCallback<Schema$Building>): void;


insert(params: Params$Resource$Resources$Buildings$Insert, callback: BodyResponseCallback<Schema$Building>): void;


insert(callback: BodyResponseCallback<Schema$Building>): void;


/**
         * directory.resources.buildings.list
         * @desc Retrieves a list of buildings for an account.
         * @alias directory.resources.buildings.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {integer=} params.maxResults Maximum number of results to return.
         * @param {string=} params.pageToken Token to specify the next page in the 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
         */
list(params?: Params$Resource$Resources$Buildings$List, options?: MethodOptions): GaxiosPromise<Schema$Buildings>;


list(params: Params$Resource$Resources$Buildings$List, options: MethodOptions | BodyResponseCallback<Schema$Buildings>, callback: BodyResponseCallback<Schema$Buildings>): void;


list(params: Params$Resource$Resources$Buildings$List, callback: BodyResponseCallback<Schema$Buildings>): void;


list(callback: BodyResponseCallback<Schema$Buildings>): void;


/**
         * directory.resources.buildings.patch
         * @desc Updates a building. This method supports patch semantics.
         * @alias directory.resources.buildings.patch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.buildingId The ID of the building to update.
         * @param {string=} params.coordinatesSource Source from which Building.coordinates are derived.
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {().Building} 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
         */
patch(params?: Params$Resource$Resources$Buildings$Patch, options?: MethodOptions): GaxiosPromise<Schema$Building>;


patch(params: Params$Resource$Resources$Buildings$Patch, options: MethodOptions | BodyResponseCallback<Schema$Building>, callback: BodyResponseCallback<Schema$Building>): void;


patch(params: Params$Resource$Resources$Buildings$Patch, callback: BodyResponseCallback<Schema$Building>): void;


patch(callback: BodyResponseCallback<Schema$Building>): void;


/**
         * directory.resources.buildings.update
         * @desc Updates a building.
         * @alias directory.resources.buildings.update
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.buildingId The ID of the building to update.
         * @param {string=} params.coordinatesSource Source from which Building.coordinates are derived.
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {().Building} 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?: Params$Resource$Resources$Buildings$Update, options?: MethodOptions): GaxiosPromise<Schema$Building>;


update(params: Params$Resource$Resources$Buildings$Update, options: MethodOptions | BodyResponseCallback<Schema$Building>, callback: BodyResponseCallback<Schema$Building>): void;


update(params: Params$Resource$Resources$Buildings$Update, callback: BodyResponseCallback<Schema$Building>): void;


update(callback: BodyResponseCallback<Schema$Building>): void;


/**
         * directory.resources.calendars.delete
         * @desc Deletes a calendar resource.
         * @alias directory.resources.calendars.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.calendarResourceId The unique ID of the calendar resource to delete.
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @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?: Params$Resource$Resources$Calendars$Delete, options?: MethodOptions): GaxiosPromise<void>;


delete(params: Params$Resource$Resources$Calendars$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


delete(params: Params$Resource$Resources$Calendars$Delete, callback: BodyResponseCallback<void>): void;


/**
         * directory.resources.calendars.get
         * @desc Retrieves a calendar resource.
         * @alias directory.resources.calendars.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.calendarResourceId The unique ID of the calendar resource to retrieve.
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @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?: Params$Resource$Resources$Calendars$Get, options?: MethodOptions): GaxiosPromise<Schema$CalendarResource>;


get(params: Params$Resource$Resources$Calendars$Get, options: MethodOptions | BodyResponseCallback<Schema$CalendarResource>, callback: BodyResponseCallback<Schema$CalendarResource>): void;


get(params: Params$Resource$Resources$Calendars$Get, callback: BodyResponseCallback<Schema$CalendarResource>): void;


get(callback: BodyResponseCallback<Schema$CalendarResource>): void;


/**
         * directory.resources.calendars.insert
         * @desc Inserts a calendar resource.
         * @alias directory.resources.calendars.insert
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {().CalendarResource} 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
         */
insert(params?: Params$Resource$Resources$Calendars$Insert, options?: MethodOptions): GaxiosPromise<Schema$CalendarResource>;


insert(params: Params$Resource$Resources$Calendars$Insert, options: MethodOptions | BodyResponseCallback<Schema$CalendarResource>, callback: BodyResponseCallback<Schema$CalendarResource>): void;


insert(params: Params$Resource$Resources$Calendars$Insert, callback: BodyResponseCallback<Schema$CalendarResource>): void;


insert(callback: BodyResponseCallback<Schema$CalendarResource>): void;


/**
         * directory.resources.calendars.list
         * @desc Retrieves a list of calendar resources for an account.
         * @alias directory.resources.calendars.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {integer=} params.maxResults Maximum number of results to return.
         * @param {string=} params.orderBy Field(s) to sort results by in either ascending or descending order. Supported fields include resourceId, resourceName, capacity, buildingId, and floorName. If no order is specified, defaults to ascending. Should be of the form "field [asc|desc], field [asc|desc], ...". For example buildingId, capacity desc would return results sorted first by buildingId in ascending order then by capacity in descending order.
         * @param {string=} params.pageToken Token to specify the next page in the list.
         * @param {string=} params.query String query used to filter results. Should be of the form "field operator value" where field can be any of supported fields and operators can be any of supported operations. Operators include '=' for exact match and ':' for prefix match or HAS match where applicable. For prefix match, the value should always be followed by a *. Supported fields include generatedResourceName, name, buildingId, featureInstances.feature.name. For example buildingId=US-NYC-9TH AND featureInstances.feature.name:Phone.
         * @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?: Params$Resource$Resources$Calendars$List, options?: MethodOptions): GaxiosPromise<Schema$CalendarResources>;


list(params: Params$Resource$Resources$Calendars$List, options: MethodOptions | BodyResponseCallback<Schema$CalendarResources>, callback: BodyResponseCallback<Schema$CalendarResources>): void;


list(params: Params$Resource$Resources$Calendars$List, callback: BodyResponseCallback<Schema$CalendarResources>): void;


list(callback: BodyResponseCallback<Schema$CalendarResources>): void;


/**
         * directory.resources.calendars.patch
         * @desc Updates a calendar resource.  This method supports patch semantics,
         * meaning you only need to include the fields you wish to update. Fields
         * that are not present in the request will be preserved. This method
         * supports patch semantics.
         * @alias directory.resources.calendars.patch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.calendarResourceId The unique ID of the calendar resource to update.
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {().CalendarResource} 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
         */
patch(params?: Params$Resource$Resources$Calendars$Patch, options?: MethodOptions): GaxiosPromise<Schema$CalendarResource>;


patch(params: Params$Resource$Resources$Calendars$Patch, options: MethodOptions | BodyResponseCallback<Schema$CalendarResource>, callback: BodyResponseCallback<Schema$CalendarResource>): void;


patch(params: Params$Resource$Resources$Calendars$Patch, callback: BodyResponseCallback<Schema$CalendarResource>): void;


patch(callback: BodyResponseCallback<Schema$CalendarResource>): void;


/**
         * directory.resources.calendars.update
         * @desc Updates a calendar resource.  This method supports patch semantics,
         * meaning you only need to include the fields you wish to update. Fields
         * that are not present in the request will be preserved.
         * @alias directory.resources.calendars.update
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.calendarResourceId The unique ID of the calendar resource to update.
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {().CalendarResource} 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?: Params$Resource$Resources$Calendars$Update, options?: MethodOptions): GaxiosPromise<Schema$CalendarResource>;


update(params: Params$Resource$Resources$Calendars$Update, options: MethodOptions | BodyResponseCallback<Schema$CalendarResource>, callback: BodyResponseCallback<Schema$CalendarResource>): void;


update(params: Params$Resource$Resources$Calendars$Update, callback: BodyResponseCallback<Schema$CalendarResource>): void;


update(callback: BodyResponseCallback<Schema$CalendarResource>): void;


/**
         * directory.resources.features.delete
         * @desc Deletes a feature.
         * @alias directory.resources.features.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {string} params.featureKey The unique ID of the feature 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?: Params$Resource$Resources$Features$Delete, options?: MethodOptions): GaxiosPromise<void>;


delete(params: Params$Resource$Resources$Features$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


delete(params: Params$Resource$Resources$Features$Delete, callback: BodyResponseCallback<void>): void;


/**
         * directory.resources.features.get
         * @desc Retrieves a feature.
         * @alias directory.resources.features.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {string} params.featureKey The unique ID of the feature to retrieve.
         * @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?: Params$Resource$Resources$Features$Get, options?: MethodOptions): GaxiosPromise<Schema$Feature>;


get(params: Params$Resource$Resources$Features$Get, options: MethodOptions | BodyResponseCallback<Schema$Feature>, callback: BodyResponseCallback<Schema$Feature>): void;


get(params: Params$Resource$Resources$Features$Get, callback: BodyResponseCallback<Schema$Feature>): void;


get(callback: BodyResponseCallback<Schema$Feature>): void;


/**
         * directory.resources.features.insert
         * @desc Inserts a feature.
         * @alias directory.resources.features.insert
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {().Feature} 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
         */
insert(params?: Params$Resource$Resources$Features$Insert, options?: MethodOptions): GaxiosPromise<Schema$Feature>;


insert(params: Params$Resource$Resources$Features$Insert, options: MethodOptions | BodyResponseCallback<Schema$Feature>, callback: BodyResponseCallback<Schema$Feature>): void;


insert(params: Params$Resource$Resources$Features$Insert, callback: BodyResponseCallback<Schema$Feature>): void;


insert(callback: BodyResponseCallback<Schema$Feature>): void;


/**
         * directory.resources.features.list
         * @desc Retrieves a list of features for an account.
         * @alias directory.resources.features.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {integer=} params.maxResults Maximum number of results to return.
         * @param {string=} params.pageToken Token to specify the next page in the 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
         */
list(params?: Params$Resource$Resources$Features$List, options?: MethodOptions): GaxiosPromise<Schema$Features>;


list(params: Params$Resource$Resources$Features$List, options: MethodOptions | BodyResponseCallback<Schema$Features>, callback: BodyResponseCallback<Schema$Features>): void;


list(params: Params$Resource$Resources$Features$List, callback: BodyResponseCallback<Schema$Features>): void;


list(callback: BodyResponseCallback<Schema$Features>): void;


/**
         * directory.resources.features.patch
         * @desc Updates a feature. This method supports patch semantics.
         * @alias directory.resources.features.patch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {string} params.featureKey The unique ID of the feature to update.
         * @param {().Feature} 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
         */
patch(params?: Params$Resource$Resources$Features$Patch, options?: MethodOptions): GaxiosPromise<Schema$Feature>;


patch(params: Params$Resource$Resources$Features$Patch, options: MethodOptions | BodyResponseCallback<Schema$Feature>, callback: BodyResponseCallback<Schema$Feature>): void;


patch(params: Params$Resource$Resources$Features$Patch, callback: BodyResponseCallback<Schema$Feature>): void;


patch(callback: BodyResponseCallback<Schema$Feature>): void;


/**
         * directory.resources.features.rename
         * @desc Renames a feature.
         * @alias directory.resources.features.rename
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {string} params.oldName The unique ID of the feature to rename.
         * @param {().FeatureRename} 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
         */
rename(params?: Params$Resource$Resources$Features$Rename, options?: MethodOptions): GaxiosPromise<void>;


rename(params: Params$Resource$Resources$Features$Rename, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


rename(params: Params$Resource$Resources$Features$Rename, callback: BodyResponseCallback<void>): void;


rename(callback: BodyResponseCallback<void>): void;


/**
         * directory.resources.features.update
         * @desc Updates a feature.
         * @alias directory.resources.features.update
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer The unique ID for the customer's G Suite account. As an account administrator, you can also use the my_customer alias to represent your account's customer ID.
         * @param {string} params.featureKey The unique ID of the feature to update.
         * @param {().Feature} 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?: Params$Resource$Resources$Features$Update, options?: MethodOptions): GaxiosPromise<Schema$Feature>;


update(params: Params$Resource$Resources$Features$Update, options: MethodOptions | BodyResponseCallback<Schema$Feature>, callback: BodyResponseCallback<Schema$Feature>): void;


update(params: Params$Resource$Resources$Features$Update, callback: BodyResponseCallback<Schema$Feature>): void;


update(callback: BodyResponseCallback<Schema$Feature>): void;


/**
         * directory.roleAssignments.delete
         * @desc Deletes a role assignment.
         * @alias directory.roleAssignments.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer Immutable ID of the G Suite account.
         * @param {string} params.roleAssignmentId Immutable ID of the role assignment.
         * @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?: Params$Resource$Roleassignments$Delete, options?: MethodOptions): GaxiosPromise<void>;


delete(params: Params$Resource$Roleassignments$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


delete(params: Params$Resource$Roleassignments$Delete, callback: BodyResponseCallback<void>): void;


/**
         * directory.roleAssignments.get
         * @desc Retrieve a role assignment.
         * @alias directory.roleAssignments.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer Immutable ID of the G Suite account.
         * @param {string} params.roleAssignmentId Immutable ID of the role assignment.
         * @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?: Params$Resource$Roleassignments$Get, options?: MethodOptions): GaxiosPromise<Schema$RoleAssignment>;


get(params: Params$Resource$Roleassignments$Get, options: MethodOptions | BodyResponseCallback<Schema$RoleAssignment>, callback: BodyResponseCallback<Schema$RoleAssignment>): void;


get(params: Params$Resource$Roleassignments$Get, callback: BodyResponseCallback<Schema$RoleAssignment>): void;


get(callback: BodyResponseCallback<Schema$RoleAssignment>): void;


/**
         * directory.roleAssignments.insert
         * @desc Creates a role assignment.
         * @alias directory.roleAssignments.insert
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer Immutable ID of the G Suite account.
         * @param {().RoleAssignment} 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
         */
insert(params?: Params$Resource$Roleassignments$Insert, options?: MethodOptions): GaxiosPromise<Schema$RoleAssignment>;


insert(params: Params$Resource$Roleassignments$Insert, options: MethodOptions | BodyResponseCallback<Schema$RoleAssignment>, callback: BodyResponseCallback<Schema$RoleAssignment>): void;


insert(params: Params$Resource$Roleassignments$Insert, callback: BodyResponseCallback<Schema$RoleAssignment>): void;


insert(callback: BodyResponseCallback<Schema$RoleAssignment>): void;


/**
         * directory.roleAssignments.list
         * @desc Retrieves a paginated list of all roleAssignments.
         * @alias directory.roleAssignments.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer Immutable ID of the G Suite account.
         * @param {integer=} params.maxResults Maximum number of results to return.
         * @param {string=} params.pageToken Token to specify the next page in the list.
         * @param {string=} params.roleId Immutable ID of a role. If included in the request, returns only role assignments containing this role ID.
         * @param {string=} params.userKey The user's primary email address, alias email address, or unique user ID. If included in the request, returns role assignments only for this user.
         * @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?: Params$Resource$Roleassignments$List, options?: MethodOptions): GaxiosPromise<Schema$RoleAssignments>;


list(params: Params$Resource$Roleassignments$List, options: MethodOptions | BodyResponseCallback<Schema$RoleAssignments>, callback: BodyResponseCallback<Schema$RoleAssignments>): void;


list(params: Params$Resource$Roleassignments$List, callback: BodyResponseCallback<Schema$RoleAssignments>): void;


list(callback: BodyResponseCallback<Schema$RoleAssignments>): void;


/**
         * directory.roles.delete
         * @desc Deletes a role.
         * @alias directory.roles.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer Immutable ID of the G Suite account.
         * @param {string} params.roleId Immutable ID of the role.
         * @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?: Params$Resource$Roles$Delete, options?: MethodOptions): GaxiosPromise<void>;


delete(params: Params$Resource$Roles$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


delete(params: Params$Resource$Roles$Delete, callback: BodyResponseCallback<void>): void;


/**
         * directory.roles.get
         * @desc Retrieves a role.
         * @alias directory.roles.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer Immutable ID of the G Suite account.
         * @param {string} params.roleId Immutable ID of the role.
         * @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?: Params$Resource$Roles$Get, options?: MethodOptions): GaxiosPromise<Schema$Role>;


get(params: Params$Resource$Roles$Get, options: MethodOptions | BodyResponseCallback<Schema$Role>, callback: BodyResponseCallback<Schema$Role>): void;


get(params: Params$Resource$Roles$Get, callback: BodyResponseCallback<Schema$Role>): void;


get(callback: BodyResponseCallback<Schema$Role>): void;


/**
         * directory.roles.insert
         * @desc Creates a role.
         * @alias directory.roles.insert
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer Immutable ID of the G Suite account.
         * @param {().Role} 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
         */
insert(params?: Params$Resource$Roles$Insert, options?: MethodOptions): GaxiosPromise<Schema$Role>;


insert(params: Params$Resource$Roles$Insert, options: MethodOptions | BodyResponseCallback<Schema$Role>, callback: BodyResponseCallback<Schema$Role>): void;


insert(params: Params$Resource$Roles$Insert, callback: BodyResponseCallback<Schema$Role>): void;


insert(callback: BodyResponseCallback<Schema$Role>): void;


/**
         * directory.roles.list
         * @desc Retrieves a paginated list of all the roles in a domain.
         * @alias directory.roles.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer Immutable ID of the G Suite account.
         * @param {integer=} params.maxResults Maximum number of results to return.
         * @param {string=} params.pageToken Token to specify the next page in the 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
         */
list(params?: Params$Resource$Roles$List, options?: MethodOptions): GaxiosPromise<Schema$Roles>;


list(params: Params$Resource$Roles$List, options: MethodOptions | BodyResponseCallback<Schema$Roles>, callback: BodyResponseCallback<Schema$Roles>): void;


list(params: Params$Resource$Roles$List, callback: BodyResponseCallback<Schema$Roles>): void;


list(callback: BodyResponseCallback<Schema$Roles>): void;


/**
         * directory.roles.patch
         * @desc Updates a role. This method supports patch semantics.
         * @alias directory.roles.patch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer Immutable ID of the G Suite account.
         * @param {string} params.roleId Immutable ID of the role.
         * @param {().Role} 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
         */
patch(params?: Params$Resource$Roles$Patch, options?: MethodOptions): GaxiosPromise<Schema$Role>;


patch(params: Params$Resource$Roles$Patch, options: MethodOptions | BodyResponseCallback<Schema$Role>, callback: BodyResponseCallback<Schema$Role>): void;


patch(params: Params$Resource$Roles$Patch, callback: BodyResponseCallback<Schema$Role>): void;


patch(callback: BodyResponseCallback<Schema$Role>): void;


/**
         * directory.roles.update
         * @desc Updates a role.
         * @alias directory.roles.update
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customer Immutable ID of the G Suite account.
         * @param {string} params.roleId Immutable ID of the role.
         * @param {().Role} 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?: Params$Resource$Roles$Update, options?: MethodOptions): GaxiosPromise<Schema$Role>;


update(params: Params$Resource$Roles$Update, options: MethodOptions | BodyResponseCallback<Schema$Role>, callback: BodyResponseCallback<Schema$Role>): void;


update(params: Params$Resource$Roles$Update, callback: BodyResponseCallback<Schema$Role>): void;


update(callback: BodyResponseCallback<Schema$Role>): void;


/**
         * directory.schemas.delete
         * @desc Delete schema
         * @alias directory.schemas.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {string} params.schemaKey Name or immutable ID of the schema
         * @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?: Params$Resource$Schemas$Delete, options?: MethodOptions): GaxiosPromise<void>;


delete(params: Params$Resource$Schemas$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


delete(params: Params$Resource$Schemas$Delete, callback: BodyResponseCallback<void>): void;


/**
         * directory.schemas.get
         * @desc Retrieve schema
         * @alias directory.schemas.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {string} params.schemaKey Name or immutable ID of the schema
         * @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?: Params$Resource$Schemas$Get, options?: MethodOptions): GaxiosPromise<Schema$Schema>;


get(params: Params$Resource$Schemas$Get, options: MethodOptions | BodyResponseCallback<Schema$Schema>, callback: BodyResponseCallback<Schema$Schema>): void;


get(params: Params$Resource$Schemas$Get, callback: BodyResponseCallback<Schema$Schema>): void;


get(callback: BodyResponseCallback<Schema$Schema>): void;


/**
         * directory.schemas.insert
         * @desc Create schema.
         * @alias directory.schemas.insert
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {().Schema} 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
         */
insert(params?: Params$Resource$Schemas$Insert, options?: MethodOptions): GaxiosPromise<Schema$Schema>;


insert(params: Params$Resource$Schemas$Insert, options: MethodOptions | BodyResponseCallback<Schema$Schema>, callback: BodyResponseCallback<Schema$Schema>): void;


insert(params: Params$Resource$Schemas$Insert, callback: BodyResponseCallback<Schema$Schema>): void;


insert(callback: BodyResponseCallback<Schema$Schema>): void;


/**
         * directory.schemas.list
         * @desc Retrieve all schemas for a customer
         * @alias directory.schemas.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @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?: Params$Resource$Schemas$List, options?: MethodOptions): GaxiosPromise<Schema$Schemas>;


list(params: Params$Resource$Schemas$List, options: MethodOptions | BodyResponseCallback<Schema$Schemas>, callback: BodyResponseCallback<Schema$Schemas>): void;


list(params: Params$Resource$Schemas$List, callback: BodyResponseCallback<Schema$Schemas>): void;


list(callback: BodyResponseCallback<Schema$Schemas>): void;


/**
         * directory.schemas.patch
         * @desc Update schema. This method supports patch semantics.
         * @alias directory.schemas.patch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {string} params.schemaKey Name or immutable ID of the schema.
         * @param {().Schema} 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
         */
patch(params?: Params$Resource$Schemas$Patch, options?: MethodOptions): GaxiosPromise<Schema$Schema>;


patch(params: Params$Resource$Schemas$Patch, options: MethodOptions | BodyResponseCallback<Schema$Schema>, callback: BodyResponseCallback<Schema$Schema>): void;


patch(params: Params$Resource$Schemas$Patch, callback: BodyResponseCallback<Schema$Schema>): void;


patch(callback: BodyResponseCallback<Schema$Schema>): void;


/**
         * directory.schemas.update
         * @desc Update schema
         * @alias directory.schemas.update
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.customerId Immutable ID of the G Suite account
         * @param {string} params.schemaKey Name or immutable ID of the schema.
         * @param {().Schema} 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?: Params$Resource$Schemas$Update, options?: MethodOptions): GaxiosPromise<Schema$Schema>;


update(params: Params$Resource$Schemas$Update, options: MethodOptions | BodyResponseCallback<Schema$Schema>, callback: BodyResponseCallback<Schema$Schema>): void;


update(params: Params$Resource$Schemas$Update, callback: BodyResponseCallback<Schema$Schema>): void;


update(callback: BodyResponseCallback<Schema$Schema>): void;


/**
         * directory.tokens.delete
         * @desc Delete all access tokens issued by a user for an application.
         * @alias directory.tokens.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.clientId The Client ID of the application the token is issued to.
         * @param {string} params.userKey Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID.
         * @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?: Params$Resource$Tokens$Delete, options?: MethodOptions): GaxiosPromise<void>;


delete(params: Params$Resource$Tokens$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


delete(params: Params$Resource$Tokens$Delete, callback: BodyResponseCallback<void>): void;


/**
         * directory.tokens.get
         * @desc Get information about an access token issued by a user.
         * @alias directory.tokens.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.clientId The Client ID of the application the token is issued to.
         * @param {string} params.userKey Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID.
         * @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?: Params$Resource$Tokens$Get, options?: MethodOptions): GaxiosPromise<Schema$Token>;


get(params: Params$Resource$Tokens$Get, options: MethodOptions | BodyResponseCallback<Schema$Token>, callback: BodyResponseCallback<Schema$Token>): void;


get(params: Params$Resource$Tokens$Get, callback: BodyResponseCallback<Schema$Token>): void;


get(callback: BodyResponseCallback<Schema$Token>): void;


/**
         * directory.tokens.list
         * @desc Returns the set of tokens specified user has issued to 3rd party
         * applications.
         * @alias directory.tokens.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID.
         * @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?: Params$Resource$Tokens$List, options?: MethodOptions): GaxiosPromise<Schema$Tokens>;


list(params: Params$Resource$Tokens$List, options: MethodOptions | BodyResponseCallback<Schema$Tokens>, callback: BodyResponseCallback<Schema$Tokens>): void;


list(params: Params$Resource$Tokens$List, callback: BodyResponseCallback<Schema$Tokens>): void;


list(callback: BodyResponseCallback<Schema$Tokens>): void;


/**
         * directory.users.delete
         * @desc Delete user
         * @alias directory.users.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey Email or immutable ID of the user
         * @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?: Params$Resource$Users$Delete, options?: MethodOptions): GaxiosPromise<void>;


delete(params: Params$Resource$Users$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


delete(params: Params$Resource$Users$Delete, callback: BodyResponseCallback<void>): void;


/**
         * directory.users.get
         * @desc retrieve user
         * @alias directory.users.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string=} params.customFieldMask Comma-separated list of schema names. All fields from these schemas are fetched. This should only be set when projection=custom.
         * @param {string=} params.projection What subset of fields to fetch for this user.
         * @param {string} params.userKey Email or immutable ID of the user
         * @param {string=} params.viewType Whether to fetch the ADMIN_VIEW or DOMAIN_PUBLIC view of the user.
         * @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?: Params$Resource$Users$Get, options?: MethodOptions): GaxiosPromise<Schema$User>;


get(params: Params$Resource$Users$Get, options: MethodOptions | BodyResponseCallback<Schema$User>, callback: BodyResponseCallback<Schema$User>): void;


get(params: Params$Resource$Users$Get, callback: BodyResponseCallback<Schema$User>): void;


get(callback: BodyResponseCallback<Schema$User>): void;


/**
         * directory.users.insert
         * @desc create user.
         * @alias directory.users.insert
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {().User} 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
         */
insert(params?: Params$Resource$Users$Insert, options?: MethodOptions): GaxiosPromise<Schema$User>;


insert(params: Params$Resource$Users$Insert, options: MethodOptions | BodyResponseCallback<Schema$User>, callback: BodyResponseCallback<Schema$User>): void;


insert(params: Params$Resource$Users$Insert, callback: BodyResponseCallback<Schema$User>): void;


insert(callback: BodyResponseCallback<Schema$User>): void;


/**
         * directory.users.list
         * @desc Retrieve either deleted users or all users in a domain (paginated)
         * @alias directory.users.list
         * @memberOf! ()
         *
         * @param {object=} params Parameters for request
         * @param {string=} params.customer Immutable ID of the G Suite account. In case of multi-domain, to fetch all users for a customer, fill this field instead of domain.
         * @param {string=} params.customFieldMask Comma-separated list of schema names. All fields from these schemas are fetched. This should only be set when projection=custom.
         * @param {string=} params.domain Name of the domain. Fill this field to get users from only this domain. To return all users in a multi-domain fill customer field instead.
         * @param {string=} params.event Event on which subscription is intended (if subscribing)
         * @param {integer=} params.maxResults Maximum number of results to return. Default is 100. Max allowed is 500
         * @param {string=} params.orderBy Column to use for sorting results
         * @param {string=} params.pageToken Token to specify next page in the list
         * @param {string=} params.projection What subset of fields to fetch for this user.
         * @param {string=} params.query Query string search. Should be of the form "". Complete documentation is at https://developers.google.com/admin-sdk/directory/v1/guides/search-users
         * @param {string=} params.showDeleted If set to true retrieves the list of deleted users. Default is false
         * @param {string=} params.sortOrder Whether to return results in ascending or descending order.
         * @param {string=} params.viewType Whether to fetch the ADMIN_VIEW or DOMAIN_PUBLIC view of the user.
         * @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?: Params$Resource$Users$List, options?: MethodOptions): GaxiosPromise<Schema$Users>;


list(params: Params$Resource$Users$List, options: MethodOptions | BodyResponseCallback<Schema$Users>, callback: BodyResponseCallback<Schema$Users>): void;


list(params: Params$Resource$Users$List, callback: BodyResponseCallback<Schema$Users>): void;


list(callback: BodyResponseCallback<Schema$Users>): void;


/**
         * directory.users.makeAdmin
         * @desc change admin status of a user
         * @alias directory.users.makeAdmin
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey Email or immutable ID of the user as admin
         * @param {().UserMakeAdmin} 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
         */
makeAdmin(params?: Params$Resource$Users$Makeadmin, options?: MethodOptions): GaxiosPromise<void>;


makeAdmin(params: Params$Resource$Users$Makeadmin, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


makeAdmin(params: Params$Resource$Users$Makeadmin, callback: BodyResponseCallback<void>): void;


makeAdmin(callback: BodyResponseCallback<void>): void;


/**
         * directory.users.patch
         * @desc update user. This method supports patch semantics.
         * @alias directory.users.patch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey Email or immutable ID of the user. If ID, it should match with id of user object
         * @param {().User} 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
         */
patch(params?: Params$Resource$Users$Patch, options?: MethodOptions): GaxiosPromise<Schema$User>;


patch(params: Params$Resource$Users$Patch, options: MethodOptions | BodyResponseCallback<Schema$User>, callback: BodyResponseCallback<Schema$User>): void;


patch(params: Params$Resource$Users$Patch, callback: BodyResponseCallback<Schema$User>): void;


patch(callback: BodyResponseCallback<Schema$User>): void;


/**
         * directory.users.undelete
         * @desc Undelete a deleted user
         * @alias directory.users.undelete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey The immutable id of the user
         * @param {().UserUndelete} 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
         */
undelete(params?: Params$Resource$Users$Undelete, options?: MethodOptions): GaxiosPromise<void>;


undelete(params: Params$Resource$Users$Undelete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


undelete(params: Params$Resource$Users$Undelete, callback: BodyResponseCallback<void>): void;


undelete(callback: BodyResponseCallback<void>): void;


/**
         * directory.users.update
         * @desc update user
         * @alias directory.users.update
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey Email or immutable ID of the user. If ID, it should match with id of user object
         * @param {().User} 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?: Params$Resource$Users$Update, options?: MethodOptions): GaxiosPromise<Schema$User>;


update(params: Params$Resource$Users$Update, options: MethodOptions | BodyResponseCallback<Schema$User>, callback: BodyResponseCallback<Schema$User>): void;


update(params: Params$Resource$Users$Update, callback: BodyResponseCallback<Schema$User>): void;


update(callback: BodyResponseCallback<Schema$User>): void;


/**
         * directory.users.watch
         * @desc Watch for changes in users list
         * @alias directory.users.watch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string=} params.customer Immutable ID of the G Suite account. In case of multi-domain, to fetch all users for a customer, fill this field instead of domain.
         * @param {string=} params.customFieldMask Comma-separated list of schema names. All fields from these schemas are fetched. This should only be set when projection=custom.
         * @param {string=} params.domain Name of the domain. Fill this field to get users from only this domain. To return all users in a multi-domain fill customer field instead.
         * @param {string=} params.event Event on which subscription is intended (if subscribing)
         * @param {integer=} params.maxResults Maximum number of results to return. Default is 100. Max allowed is 500
         * @param {string=} params.orderBy Column to use for sorting results
         * @param {string=} params.pageToken Token to specify next page in the list
         * @param {string=} params.projection What subset of fields to fetch for this user.
         * @param {string=} params.query Query string search. Should be of the form "". Complete documentation is at https://developers.google.com/admin-sdk/directory/v1/guides/search-users
         * @param {string=} params.showDeleted If set to true retrieves the list of deleted users. Default is false
         * @param {string=} params.sortOrder Whether to return results in ascending or descending order.
         * @param {string=} params.viewType Whether to fetch the ADMIN_VIEW or DOMAIN_PUBLIC view of the user.
         * @param {().Channel} 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
         */
watch(params?: Params$Resource$Users$Watch, options?: MethodOptions): GaxiosPromise<Schema$Channel>;


watch(params: Params$Resource$Users$Watch, options: MethodOptions | BodyResponseCallback<Schema$Channel>, callback: BodyResponseCallback<Schema$Channel>): void;


watch(params: Params$Resource$Users$Watch, callback: BodyResponseCallback<Schema$Channel>): void;


watch(callback: BodyResponseCallback<Schema$Channel>): void;


/**
         * directory.users.aliases.delete
         * @desc Remove a alias for the user
         * @alias directory.users.aliases.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.alias The alias to be removed
         * @param {string} params.userKey Email or immutable ID of the user
         * @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?: Params$Resource$Users$Aliases$Delete, options?: MethodOptions): GaxiosPromise<void>;


delete(params: Params$Resource$Users$Aliases$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


delete(params: Params$Resource$Users$Aliases$Delete, callback: BodyResponseCallback<void>): void;


/**
         * directory.users.aliases.insert
         * @desc Add a alias for the user
         * @alias directory.users.aliases.insert
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey Email or immutable ID of the user
         * @param {().Alias} 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
         */
insert(params?: Params$Resource$Users$Aliases$Insert, options?: MethodOptions): GaxiosPromise<Schema$Alias>;


insert(params: Params$Resource$Users$Aliases$Insert, options: MethodOptions | BodyResponseCallback<Schema$Alias>, callback: BodyResponseCallback<Schema$Alias>): void;


insert(params: Params$Resource$Users$Aliases$Insert, callback: BodyResponseCallback<Schema$Alias>): void;


/**
         * directory.users.aliases.list
         * @desc List all aliases for a user
         * @alias directory.users.aliases.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string=} params.event Event on which subscription is intended (if subscribing)
         * @param {string} params.userKey Email or immutable ID of the user
         * @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?: Params$Resource$Users$Aliases$List, options?: MethodOptions): GaxiosPromise<Schema$Aliases>;


list(params: Params$Resource$Users$Aliases$List, options: MethodOptions | BodyResponseCallback<Schema$Aliases>, callback: BodyResponseCallback<Schema$Aliases>): void;


list(params: Params$Resource$Users$Aliases$List, callback: BodyResponseCallback<Schema$Aliases>): void;


/**
         * directory.users.aliases.watch
         * @desc Watch for changes in user aliases list
         * @alias directory.users.aliases.watch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string=} params.event Event on which subscription is intended (if subscribing)
         * @param {string} params.userKey Email or immutable ID of the user
         * @param {().Channel} 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
         */
watch(params?: Params$Resource$Users$Aliases$Watch, options?: MethodOptions): GaxiosPromise<Schema$Channel>;


watch(params: Params$Resource$Users$Aliases$Watch, options: MethodOptions | BodyResponseCallback<Schema$Channel>, callback: BodyResponseCallback<Schema$Channel>): void;


watch(params: Params$Resource$Users$Aliases$Watch, callback: BodyResponseCallback<Schema$Channel>): void;


/**
         * directory.users.photos.delete
         * @desc Remove photos for the user
         * @alias directory.users.photos.delete
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey Email or immutable ID of the user
         * @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?: Params$Resource$Users$Photos$Delete, options?: MethodOptions): GaxiosPromise<void>;


delete(params: Params$Resource$Users$Photos$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


delete(params: Params$Resource$Users$Photos$Delete, callback: BodyResponseCallback<void>): void;


/**
         * directory.users.photos.get
         * @desc Retrieve photo of a user
         * @alias directory.users.photos.get
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey Email or immutable ID of the user
         * @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?: Params$Resource$Users$Photos$Get, options?: MethodOptions): GaxiosPromise<Schema$UserPhoto>;


get(params: Params$Resource$Users$Photos$Get, options: MethodOptions | BodyResponseCallback<Schema$UserPhoto>, callback: BodyResponseCallback<Schema$UserPhoto>): void;


get(params: Params$Resource$Users$Photos$Get, callback: BodyResponseCallback<Schema$UserPhoto>): void;


get(callback: BodyResponseCallback<Schema$UserPhoto>): void;


/**
         * directory.users.photos.patch
         * @desc Add a photo for the user. This method supports patch semantics.
         * @alias directory.users.photos.patch
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey Email or immutable ID of the user
         * @param {().UserPhoto} 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
         */
patch(params?: Params$Resource$Users$Photos$Patch, options?: MethodOptions): GaxiosPromise<Schema$UserPhoto>;


patch(params: Params$Resource$Users$Photos$Patch, options: MethodOptions | BodyResponseCallback<Schema$UserPhoto>, callback: BodyResponseCallback<Schema$UserPhoto>): void;


patch(params: Params$Resource$Users$Photos$Patch, callback: BodyResponseCallback<Schema$UserPhoto>): void;


patch(callback: BodyResponseCallback<Schema$UserPhoto>): void;


/**
         * directory.users.photos.update
         * @desc Add a photo for the user
         * @alias directory.users.photos.update
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey Email or immutable ID of the user
         * @param {().UserPhoto} 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?: Params$Resource$Users$Photos$Update, options?: MethodOptions): GaxiosPromise<Schema$UserPhoto>;


update(params: Params$Resource$Users$Photos$Update, options: MethodOptions | BodyResponseCallback<Schema$UserPhoto>, callback: BodyResponseCallback<Schema$UserPhoto>): void;


update(params: Params$Resource$Users$Photos$Update, callback: BodyResponseCallback<Schema$UserPhoto>): void;


update(callback: BodyResponseCallback<Schema$UserPhoto>): void;


/**
         * directory.verificationCodes.generate
         * @desc Generate new backup verification codes for the user.
         * @alias directory.verificationCodes.generate
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey Email or immutable ID of the user
         * @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
         */
generate(params?: Params$Resource$Verificationcodes$Generate, options?: MethodOptions): GaxiosPromise<void>;


generate(params: Params$Resource$Verificationcodes$Generate, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


generate(params: Params$Resource$Verificationcodes$Generate, callback: BodyResponseCallback<void>): void;


generate(callback: BodyResponseCallback<void>): void;


/**
         * directory.verificationCodes.invalidate
         * @desc Invalidate the current backup verification codes for the user.
         * @alias directory.verificationCodes.invalidate
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey Email or immutable ID of the user
         * @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
         */
invalidate(params?: Params$Resource$Verificationcodes$Invalidate, options?: MethodOptions): GaxiosPromise<void>;


invalidate(params: Params$Resource$Verificationcodes$Invalidate, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;


invalidate(params: Params$Resource$Verificationcodes$Invalidate, callback: BodyResponseCallback<void>): void;


invalidate(callback: BodyResponseCallback<void>): void;


/**
         * directory.verificationCodes.list
         * @desc Returns the current set of valid backup verification codes for the
         * specified user.
         * @alias directory.verificationCodes.list
         * @memberOf! ()
         *
         * @param {object} params Parameters for request
         * @param {string} params.userKey Identifies the user in the API request. The value can be the user's primary email address, alias email address, or unique user ID.
         * @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?: Params$Resource$Verificationcodes$List, options?: MethodOptions): GaxiosPromise<Schema$VerificationCodes>;


list(params: Params$Resource$Verificationcodes$List, options: MethodOptions | BodyResponseCallback<Schema$VerificationCodes>, callback: BodyResponseCallback<Schema$VerificationCodes>): void;


list(params: Params$Resource$Verificationcodes$List, callback: BodyResponseCallback<Schema$VerificationCodes>): void;


list(callback: BodyResponseCallback<Schema$VerificationCodes>): void;


async t => {
    const { cb0Mismatched, cb1Mismatched } = t.params;
    const mismatched = cb0Mismatched || cb1Mismatched;

    if (mismatched) {
      await t.selectMismatchedDeviceOrSkipTestCase(undefined);
    }

    const encoder0 = cb0Mismatched
      ? t.mismatchedDevice.createCommandEncoder()
      : t.device.createCommandEncoder();
    const cb0 = encoder0.finish();

    const encoder1 = cb1Mismatched
      ? t.mismatchedDevice.createCommandEncoder()
      : t.device.createCommandEncoder();
    const cb1 = encoder1.finish();

    t.expectValidationError(() => {
      t.device.queue.submit([cb0, cb1]);
    }, mismatched);
  }


() => {
      t.device.queue.submit([cb0, cb1]);
    }


/// <reference types="react" />
export interface UseSliderOptions<T> {
    allItems: T[];
    pageSize?: number;
    autoplay?: boolean;
    autoplayTimeout?: number;
}


@Injectable({
  providedIn: 'root'
})
export class GruposClasesService {

  ls = window.localStorage;
  httpOptions:any
  headers:any
  token:any
  constructor(private http:HttpClient,private store: LocalService,) {
   }
   crear(GrupoClaseGen:GrupoClaseGenInterface){
    console.log("crud NUEVOOOO:::");
      this.insertHead()
      return this.http.post<GrupoClaseGenInterface>(`${environment.apiUrl}/pat/grupos_clases`,GrupoClaseGen,this.httpOptions)
      .pipe(map(data => data));
   }
   modificar(GrupoClaseGen:GrupoClaseGenInterface){
     console.log("crud MODIFICSR:::");
        const idR=GrupoClaseGen.iGrupoClaseGenId;
        this.insertHead()
        return this.http.put<GrupoClaseGenInterface>(`${environment.apiUrl}/pat/grupos_clases/${idR}`,GrupoClaseGen,this.httpOptions)
        .pipe(map(data => data));
    }
    delete(id:string){
      this.insertHead()
      return this.http.delete<GrupoClaseGenInterface>(`${environment.apiUrl}/pat/grupos_clases/${id}`,this.httpOptions)
      .pipe(map(data => data));
   }

   getCombo(): Observable<GrupoClaseGenInterface[]>{
    this.insertHead()
    return this.http.post<GrupoClaseGenInterface[]>(`${environment.apiUrl}/pat/grupos_clases/combo`,this.httpOptions)
    .pipe(map(data => data));
   }

  insertHead(){
    this.ls.getItem('unamToken');
    let data = this.store.getItem("unamToken");
    this.token = data['access_token']
    if(data['access_token']){
      this.httpOptions = {
        headers: new HttpHeaders({
          'Content-Type':  'application/json',
          'Authorization': 'Bearer ' + this.token
        },
        )
      }
    }

  }

}


crear(GrupoClaseGen:GrupoClaseGenInterface){
    console.log("crud NUEVOOOO:::");
      this.insertHead()
      return this.http.post<GrupoClaseGenInterface>(`${environment.apiUrl}/pat/grupos_clases`,GrupoClaseGen,this.httpOptions)
      .pipe(map(data => data));
   }


modificar(GrupoClaseGen:GrupoClaseGenInterface){
     console.log("crud MODIFICSR:::");
        const idR=GrupoClaseGen.iGrupoClaseGenId;
        this.insertHead()
        return this.http.put<GrupoClaseGenInterface>(`${environment.apiUrl}/pat/grupos_clases/${idR}`,GrupoClaseGen,this.httpOptions)
        .pipe(map(data => data));
    }


delete(id:string){
      this.insertHead()
      return this.http.delete<GrupoClaseGenInterface>(`${environment.apiUrl}/pat/grupos_clases/${id}`,this.httpOptions)
      .pipe(map(data => data));
   }


getCombo(): Observable<GrupoClaseGenInterface[]>{
    this.insertHead()
    return this.http.post<GrupoClaseGenInterface[]>(`${environment.apiUrl}/pat/grupos_clases/combo`,this.httpOptions)
    .pipe(map(data => data));
   }


insertHead(){
    this.ls.getItem('unamToken');
    let data = this.store.getItem("unamToken");
    this.token = data['access_token']
    if(data['access_token']){
      this.httpOptions = {
        headers: new HttpHeaders({
          'Content-Type':  'application/json',
          'Authorization': 'Bearer ' + this.token
        },
        )
      }
    }

  }


function ensurePaths(): void {
    shelljs.mkdir('-p', 'build/dist')
    shelljs.mkdir('-p', 'build/bundles')
    shelljs.mkdir('-p', 'build/chrome')
    shelljs.mkdir('-p', 'build/firefox')
}


export function copyAssets(env: BuildEnv): void {
    signale.await('Copy assets')
    const dir = 'build/dist'
    shelljs.rm('-rf', dir)
    shelljs.mkdir('-p', dir)
    shelljs.cp('-R', 'src/extension/assets/*', dir)
    shelljs.cp('-R', 'src/extension/views/*', dir)
    signale.success('Assets copied')
}


function copyDist(toDir: string): void {
    shelljs.mkdir('-p', toDir)
    shelljs.cp('-R', 'build/dist/*', toDir)
}


export function copyPhabricator(): void {
    shelljs.mkdir('-p', 'build/phabricator/dist/scripts')
    shelljs.mkdir('-p', 'build/phabricator/dist/css')
    shelljs.cp('build/dist/js/phabricator.bundle.js', 'build/phabricator/dist/scripts')
    shelljs.cp('build/dist/css/style.bundle.css', 'build/phabricator/dist/css')
}


function writeSchema(env: BuildEnv, browser: Browser, writeDir: string): void {
    fs.writeFileSync(`${writeDir}/schema.json`, JSON.stringify(schema, null, 4))
}


function writeManifest(env: BuildEnv, browser: Browser, writeDir: string): void {
    const manifest = {
        ...omit(extensionInfo, ['dev', 'prod', ...BROWSER_BLACKLIST[browser]]),
        ...omit(extensionInfo[env], BROWSER_BLACKLIST[browser]),
    }

    if (browser === 'firefox') {
        manifest.permissions.push('<all_urls>')
        delete manifest.storage
    }

    delete manifest.$schema

    if (env === 'prod') {
        manifest.version = version
    }

    fs.writeFileSync(`${writeDir}/manifest.json`, JSON.stringify(manifest, null, 4))
}


function buildForBrowser(browser: Browser): (env: BuildEnv) => () => void {
    ensurePaths()
    return env => {
        const title = BROWSER_TITLES[browser]

        const buildDir = path.resolve(process.cwd(), `${BUILDS_DIR}/${browser}`)

        writeManifest(env, browser, buildDir)
        writeSchema(env, browser, buildDir)

        return () => {
            // Allow only building for specific browser targets. Useful in local dev for faster
            // builds.
            if (process.env.TARGETS && !process.env.TARGETS.includes(browser)) {
                return
            }

            signale.await(`Building the ${title} ${env} bundle`)

            copyDist(buildDir)

            const zipDest = path.resolve(process.cwd(), `${BUILDS_DIR}/bundles/${BROWSER_BUNDLE_ZIPS[browser]}`)
            if (zipDest) {
                shelljs.mkdir('-p', `./${BUILDS_DIR}/bundles`)
                shelljs.exec(`cd ${buildDir} && zip -q -r ${zipDest} *`)
            }

            signale.success(`Done building the ${title} ${env} bundle`)
        }
    }
}