class Resource$Roles {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * 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;
        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;
    }


class Resource$Schemas {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * 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;
        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;
    }


class Resource$Tokens {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * 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;
        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;
    }


class Resource$Users$Aliases {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * 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;
        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;
        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;
        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;
        watch(callback: BodyResponseCallback<Schema$Channel>): void;
    }


class Resource$Users$Photos {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * 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;
        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;
    }


class Resource$Verificationcodes {
        context: APIRequestContext;
        constructor(context: APIRequestContext);
        /**
         * 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;
    }


interface Options extends GlobalOptions {
        version: 'directory_v1';
    }


interface StandardParameters {
        /**
         * Data format for the response.
         */
        alt?: string;
        /**
         * Selector specifying which fields to include in a partial response.
         */
        fields?: string;
        /**
         * API key. Your API key identifies your project and provides you with API
         * access, quota, and reports. Required unless you provide an OAuth 2.0
         * token.
         */
        key?: string;
        /**
         * OAuth 2.0 token for the current user.
         */
        oauth_token?: string;
        /**
         * Returns response with indentations and line breaks.
         */
        prettyPrint?: boolean;
        /**
         * An opaque string that represents a user for quota purposes. Must not
         * exceed 40 characters.
         */
        quotaUser?: string;
        /**
         * Deprecated. Please use quotaUser instead.
         */
        userIp?: string;
    }


/**
     * JSON template for Alias object in Directory API.
     */
interface Schema$Alias {
        /**
         * A alias email
         */
        alias?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Unique id of the group (Read-only) Unique id of the user (Read-only)
         */
        id?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * Group's primary email (Read-only) User's primary email
         * (Read-only)
         */
        primaryEmail?: string;
    }


/**
     * JSON response template to list aliases in Directory API.
     */
interface Schema$Aliases {
        /**
         * List of alias objects.
         */
        aliases?: any[];
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
    }


/**
     * JSON template for App Access Collections Resource object in Directory API.
     */
interface Schema$AppAccessCollections {
        /**
         * List of blocked api access buckets.
         */
        blockedApiAccessBuckets?: string[];
        /**
         * Boolean to indicate whether to enforce app access settings on Android
         * Drive or not.
         */
        enforceSettingsForAndroidDrive?: boolean;
        /**
         * Error message provided by the Admin that will be shown to the user when
         * an app is blocked.
         */
        errorMessage?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Identifies the resource as an app access collection. Value:
         * admin#directory#appaccesscollection
         */
        kind?: string;
        /**
         * Unique ID of app access collection. (Readonly)
         */
        resourceId?: string;
        /**
         * Resource name given by the customer while creating/updating. Should be
         * unique under given customer.
         */
        resourceName?: string;
        /**
         * Boolean that indicates whether to trust domain owned apps.
         */
        trustDomainOwnedApps?: boolean;
    }


/**
     * The template that returns individual ASP (Access Code) data.
     */
interface Schema$Asp {
        /**
         * The unique ID of the ASP.
         */
        codeId?: number;
        /**
         * The time when the ASP was created. Expressed in Unix time format.
         */
        creationTime?: string;
        /**
         * ETag of the ASP.
         */
        etag?: string;
        /**
         * The type of the API resource. This is always admin#directory#asp.
         */
        kind?: string;
        /**
         * The time when the ASP was last used. Expressed in Unix time format.
         */
        lastTimeUsed?: string;
        /**
         * The name of the application that the user, represented by their userId,
         * entered when the ASP was created.
         */
        name?: string;
        /**
         * The unique ID of the user who issued the ASP.
         */
        userKey?: string;
    }


interface Schema$Asps {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * A list of ASP resources.
         */
        items?: Schema$Asp[];
        /**
         * The type of the API resource. This is always admin#directory#aspList.
         */
        kind?: string;
    }


/**
     * JSON template for Building object in Directory API.
     */
interface Schema$Building {
        /**
         * The postal address of the building. See PostalAddress for details. Note
         * that only a single address line and region code are required.
         */
        address?: Schema$BuildingAddress;
        /**
         * Unique identifier for the building. The maximum length is 100 characters.
         */
        buildingId?: string;
        /**
         * The building name as seen by users in Calendar. Must be unique for the
         * customer. For example, "NYC-CHEL". The maximum length is 100
         * characters.
         */
        buildingName?: string;
        /**
         * The geographic coordinates of the center of the building, expressed as
         * latitude and longitude in decimal degrees.
         */
        coordinates?: Schema$BuildingCoordinates;
        /**
         * A brief description of the building. For example, "Chelsea
         * Market".
         */
        description?: string;
        /**
         * ETag of the resource.
         */
        etags?: string;
        /**
         * The display names for all floors in this building. The floors are
         * expected to be sorted in ascending order, from lowest floor to highest
         * floor. For example, ["B2", "B1", "L",
         * "1", "2", "2M", "3",
         * "PH"] Must contain at least one entry.
         */
        floorNames?: string[];
        /**
         * Kind of resource this is.
         */
        kind?: string;
    }


/**
     * JSON template for the postal address of a building in Directory API.
     */
interface Schema$BuildingAddress {
        /**
         * Unstructured address lines describing the lower levels of an address.
         */
        addressLines?: string[];
        /**
         * Optional. Highest administrative subdivision which is used for postal
         * addresses of a country or region.
         */
        administrativeArea?: string;
        /**
         * Optional. BCP-47 language code of the contents of this address (if
         * known).
         */
        languageCode?: string;
        /**
         * Optional. Generally refers to the city/town portion of the address.
         * Examples: US city, IT comune, UK post town. In regions of the world where
         * localities are not well defined or do not fit into this structure well,
         * leave locality empty and use addressLines.
         */
        locality?: string;
        /**
         * Optional. Postal code of the address.
         */
        postalCode?: string;
        /**
         * Required. CLDR region code of the country/region of the address.
         */
        regionCode?: string;
        /**
         * Optional. Sublocality of the address.
         */
        sublocality?: string;
    }


/**
     * JSON template for coordinates of a building in Directory API.
     */
interface Schema$BuildingCoordinates {
        /**
         * Latitude in decimal degrees.
         */
        latitude?: number;
        /**
         * Longitude in decimal degrees.
         */
        longitude?: number;
    }


/**
     * JSON template for Building List Response object in Directory API.
     */
interface Schema$Buildings {
        /**
         * The Buildings in this page of results.
         */
        buildings?: Schema$Building[];
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * The continuation token, used to page through large result sets. Provide
         * this value in a subsequent request to return the next page of results.
         */
        nextPageToken?: string;
    }


/**
     * JSON template for Calendar Resource object in Directory API.
     */
interface Schema$CalendarResource {
        /**
         * Unique ID for the building a resource is located in.
         */
        buildingId?: string;
        /**
         * Capacity of a resource, number of seats in a room.
         */
        capacity?: number;
        /**
         * ETag of the resource.
         */
        etags?: string;
        featureInstances?: any;
        /**
         * Name of the floor a resource is located on.
         */
        floorName?: string;
        /**
         * Name of the section within a floor a resource is located in.
         */
        floorSection?: string;
        /**
         * The read-only auto-generated name of the calendar resource which includes
         * metadata about the resource such as building name, floor, capacity, etc.
         * For example, "NYC-2-Training Room 1A (16)".
         */
        generatedResourceName?: string;
        /**
         * The type of the resource. For calendar resources, the value is
         * admin#directory#resources#calendars#CalendarResource.
         */
        kind?: string;
        /**
         * The category of the calendar resource. Either CONFERENCE_ROOM or OTHER.
         * Legacy data is set to CATEGORY_UNKNOWN.
         */
        resourceCategory?: string;
        /**
         * Description of the resource, visible only to admins.
         */
        resourceDescription?: string;
        /**
         * The read-only email for the calendar resource. Generated as part of
         * creating a new calendar resource.
         */
        resourceEmail?: string;
        /**
         * The unique ID for the calendar resource.
         */
        resourceId?: string;
        /**
         * The name of the calendar resource. For example, "Training Room
         * 1A".
         */
        resourceName?: string;
        /**
         * The type of the calendar resource, intended for non-room resources.
         */
        resourceType?: string;
        /**
         * Description of the resource, visible to users and admins.
         */
        userVisibleDescription?: string;
    }


/**
     * JSON template for Calendar Resource List Response object in Directory API.
     */
interface Schema$CalendarResources {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * The CalendarResources in this page of results.
         */
        items?: Schema$CalendarResource[];
        /**
         * Identifies this as a collection of CalendarResources. This is always
         * admin#directory#resources#calendars#calendarResourcesList.
         */
        kind?: string;
        /**
         * The continuation token, used to page through large result sets. Provide
         * this value in a subsequent request to return the next page of results.
         */
        nextPageToken?: string;
    }


/**
     * An notification channel used to watch for resource changes.
     */
interface Schema$Channel {
        /**
         * The address where notifications are delivered for this channel.
         */
        address?: string;
        /**
         * Date and time of notification channel expiration, expressed as a Unix
         * timestamp, in milliseconds. Optional.
         */
        expiration?: string;
        /**
         * A UUID or similar unique string that identifies this channel.
         */
        id?: string;
        /**
         * Identifies this as a notification channel used to watch for changes to a
         * resource. Value: the fixed string "api#channel".
         */
        kind?: string;
        /**
         * Additional parameters controlling delivery channel behavior. Optional.
         */
        params?: {
            [key: string]: string;
        };
        /**
         * A Boolean value to indicate whether payload is wanted. Optional.
         */
        payload?: boolean;
        /**
         * An opaque ID that identifies the resource being watched on this channel.
         * Stable across different API versions.
         */
        resourceId?: string;
        /**
         * A version-specific identifier for the watched resource.
         */
        resourceUri?: string;
        /**
         * An arbitrary string delivered to the target address with each
         * notification delivered over this channel. Optional.
         */
        token?: string;
        /**
         * The type of delivery mechanism used for this channel.
         */
        type?: string;
    }


/**
     * JSON template for Chrome Os Device resource in Directory API.
     */
interface Schema$ChromeOsDevice {
        /**
         * List of active time ranges (Read-only)
         */
        activeTimeRanges?: Array<{
            activeTime?: number;
            date?: string;
        }>;
        /**
         * AssetId specified during enrollment or through later annotation
         */
        annotatedAssetId?: string;
        /**
         * Address or location of the device as noted by the administrator
         */
        annotatedLocation?: string;
        /**
         * User of the device
         */
        annotatedUser?: string;
        /**
         * Chromebook boot mode (Read-only)
         */
        bootMode?: string;
        /**
         * Reports of CPU utilization and temperature (Read-only)
         */
        cpuStatusReports?: Array<{
            cpuTemperatureInfo?: Array<{
                label?: string;
                temperature?: number;
            }>;
            cpuUtilizationPercentageInfo?: number[];
            reportTime?: string;
        }>;
        /**
         * List of device files to download (Read-only)
         */
        deviceFiles?: Array<{
            createTime?: string;
            downloadUrl?: string;
            name?: string;
            type?: string;
        }>;
        /**
         * Unique identifier of Chrome OS Device (Read-only)
         */
        deviceId?: string;
        /**
         * Reports of disk space and other info about mounted/connected volumes.
         */
        diskVolumeReports?: Array<{
            volumeInfo?: Array<{
                storageFree?: string;
                storageTotal?: string;
                volumeId?: string;
            }>;
        }>;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Chromebook Mac Address on ethernet network interface (Read-only)
         */
        ethernetMacAddress?: string;
        /**
         * Chromebook firmware version (Read-only)
         */
        firmwareVersion?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * Date and time the device was last enrolled (Read-only)
         */
        lastEnrollmentTime?: string;
        /**
         * Date and time the device was last synchronized with the policy settings
         * in the G Suite administrator control panel (Read-only)
         */
        lastSync?: string;
        /**
         * Chromebook Mac Address on wifi network interface (Read-only)
         */
        macAddress?: string;
        /**
         * Mobile Equipment identifier for the 3G mobile card in the Chromebook
         * (Read-only)
         */
        meid?: string;
        /**
         * Chromebook Model (Read-only)
         */
        model?: string;
        /**
         * Notes added by the administrator
         */
        notes?: string;
        /**
         * Chromebook order number (Read-only)
         */
        orderNumber?: string;
        /**
         * OrgUnit of the device
         */
        orgUnitPath?: string;
        /**
         * Chromebook Os Version (Read-only)
         */
        osVersion?: string;
        /**
         * Chromebook platform version (Read-only)
         */
        platformVersion?: string;
        /**
         * List of recent device users, in descending order by last login time
         * (Read-only)
         */
        recentUsers?: Array<{
            email?: string;
            type?: string;
        }>;
        /**
         * Chromebook serial number (Read-only)
         */
        serialNumber?: string;
        /**
         * status of the device (Read-only)
         */
        status?: string;
        /**
         * Final date the device will be supported (Read-only)
         */
        supportEndDate?: string;
        /**
         * Reports of amounts of available RAM memory (Read-only)
         */
        systemRamFreeReports?: Array<{
            reportTime?: string;
            systemRamFreeInfo?: string[];
        }>;
        /**
         * Total RAM on the device [in bytes] (Read-only)
         */
        systemRamTotal?: string;
        /**
         * Trusted Platform Module (TPM) (Read-only)
         */
        tpmVersionInfo?: {
            family?: string;
            firmwareVersion?: string;
            manufacturer?: string;
            specLevel?: string;
            tpmModel?: string;
            vendorSpecific?: string;
        };
        /**
         * Will Chromebook auto renew after support end date (Read-only)
         */
        willAutoRenew?: boolean;
    }


/**
     * JSON request template for firing actions on ChromeOs Device in Directory
     * Devices API.
     */
interface Schema$ChromeOsDeviceAction {
        /**
         * Action to be taken on the ChromeOs Device
         */
        action?: string;
        deprovisionReason?: string;
    }


/**
     * JSON response template for List Chrome OS Devices operation in Directory
     * API.
     */
interface Schema$ChromeOsDevices {
        /**
         * List of Chrome OS Device objects.
         */
        chromeosdevices?: Schema$ChromeOsDevice[];
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * Token used to access next page of this result.
         */
        nextPageToken?: string;
    }


/**
     * JSON request template for moving ChromeOs Device to given OU in Directory
     * Devices API.
     */
interface Schema$ChromeOsMoveDevicesToOu {
        /**
         * ChromeOs Devices to be moved to OU
         */
        deviceIds?: string[];
    }


/**
     * JSON template for Customer Resource object in Directory API.
     */
interface Schema$Customer {
        /**
         * The customer's secondary contact email address. This email address
         * cannot be on the same domain as the customerDomain
         */
        alternateEmail?: string;
        /**
         * The customer's creation time (Readonly)
         */
        customerCreationTime?: string;
        /**
         * The customer's primary domain name string. Do not include the www
         * prefix when creating a new customer.
         */
        customerDomain?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * The unique ID for the customer's G Suite account. (Readonly)
         */
        id?: string;
        /**
         * Identifies the resource as a customer. Value: admin#directory#customer
         */
        kind?: string;
        /**
         * The customer's ISO 639-2 language code. The default value is en-US
         */
        language?: string;
        /**
         * The customer's contact phone number in E.164 format.
         */
        phoneNumber?: string;
        /**
         * The customer's postal address information.
         */
        postalAddress?: Schema$CustomerPostalAddress;
    }


/**
     * JSON template for postal address of a customer.
     */
interface Schema$CustomerPostalAddress {
        /**
         * A customer's physical address. The address can be composed of one to
         * three lines.
         */
        addressLine1?: string;
        /**
         * Address line 2 of the address.
         */
        addressLine2?: string;
        /**
         * Address line 3 of the address.
         */
        addressLine3?: string;
        /**
         * The customer contact's name.
         */
        contactName?: string;
        /**
         * This is a required property. For countryCode information see the ISO 3166
         * country code elements.
         */
        countryCode?: string;
        /**
         * Name of the locality. An example of a locality value is the city of San
         * Francisco.
         */
        locality?: string;
        /**
         * The company or company division name.
         */
        organizationName?: string;
        /**
         * The postal code. A postalCode example is a postal zip code such as 10009.
         * This is in accordance with -
         * http://portablecontacts.net/draft-spec.html#address_element.
         */
        postalCode?: string;
        /**
         * Name of the region. An example of a region value is NY for the state of
         * New York.
         */
        region?: string;
    }


/**
     * JSON template for Domain Alias object in Directory API.
     */
interface Schema$DomainAlias {
        /**
         * The creation time of the domain alias. (Read-only).
         */
        creationTime?: string;
        /**
         * The domain alias name.
         */
        domainAliasName?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * The parent domain name that the domain alias is associated with. This can
         * either be a primary or secondary domain name within a customer.
         */
        parentDomainName?: string;
        /**
         * Indicates the verification state of a domain alias. (Read-only)
         */
        verified?: boolean;
    }


/**
     * JSON response template to list domain aliases in Directory API.
     */
interface Schema$DomainAliases {
        /**
         * List of domain alias objects.
         */
        domainAliases?: Schema$DomainAlias[];
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
    }


/**
     * JSON template for Domain object in Directory API.
     */
interface Schema$Domains {
        /**
         * Creation time of the domain. (Read-only).
         */
        creationTime?: string;
        /**
         * List of domain alias objects. (Read-only)
         */
        domainAliases?: Schema$DomainAlias[];
        /**
         * The domain name of the customer.
         */
        domainName?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Indicates if the domain is a primary domain (Read-only).
         */
        isPrimary?: boolean;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * Indicates the verification state of a domain. (Read-only).
         */
        verified?: boolean;
    }


/**
     * JSON response template to list Domains in Directory API.
     */
interface Schema$Domains2 {
        /**
         * List of domain objects.
         */
        domains?: Schema$Domains[];
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
    }


/**
     * JSON template for Feature object in Directory API.
     */
interface Schema$Feature {
        /**
         * ETag of the resource.
         */
        etags?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * The name of the feature.
         */
        name?: string;
    }


/**
     * JSON template for a "feature instance".
     */
interface Schema$FeatureInstance {
        /**
         * The feature that this is an instance of. A calendar resource may have
         * multiple instances of a feature.
         */
        feature?: Schema$Feature;
    }


/**
     * JSON request template for renaming a feature.
     */
interface Schema$FeatureRename {
        /**
         * New name of the feature.
         */
        newName?: string;
    }


/**
     * JSON template for Feature List Response object in Directory API.
     */
interface Schema$Features {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * The Features in this page of results.
         */
        features?: Schema$Feature[];
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * The continuation token, used to page through large result sets. Provide
         * this value in a subsequent request to return the next page of results.
         */
        nextPageToken?: string;
    }


/**
     * JSON template for Group resource in Directory API.
     */
interface Schema$Group {
        /**
         * Is the group created by admin (Read-only) *
         */
        adminCreated?: boolean;
        /**
         * List of aliases (Read-only)
         */
        aliases?: string[];
        /**
         * Description of the group
         */
        description?: string;
        /**
         * Group direct members count
         */
        directMembersCount?: string;
        /**
         * Email of Group
         */
        email?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Unique identifier of Group (Read-only)
         */
        id?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * Group name
         */
        name?: string;
        /**
         * List of non editable aliases (Read-only)
         */
        nonEditableAliases?: string[];
    }


/**
     * JSON response template for List Groups operation in Directory API.
     */
interface Schema$Groups {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * List of group objects.
         */
        groups?: Schema$Group[];
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * Token used to access next page of this result.
         */
        nextPageToken?: string;
    }


/**
     * JSON template for Member resource in Directory API.
     */
interface Schema$Member {
        /**
         * Delivery settings of member
         */
        delivery_settings?: string;
        /**
         * Email of member (Read-only)
         */
        email?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Unique identifier of customer member (Read-only) Unique identifier of
         * group (Read-only) Unique identifier of member (Read-only)
         */
        id?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * Role of member
         */
        role?: string;
        /**
         * Status of member (Immutable)
         */
        status?: string;
        /**
         * Type of member (Immutable)
         */
        type?: string;
    }


/**
     * JSON response template for List Members operation in Directory API.
     */
interface Schema$Members {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * List of member objects.
         */
        members?: Schema$Member[];
        /**
         * Token used to access next page of this result.
         */
        nextPageToken?: string;
    }


/**
     * JSON template for Has Member response in Directory API.
     */
interface Schema$MembersHasMember {
        /**
         * Identifies whether the given user is a member of the group. Membership
         * can be direct or nested.
         */
        isMember?: boolean;
    }


/**
     * JSON template for Mobile Device resource in Directory API.
     */
interface Schema$MobileDevice {
        /**
         * Adb (USB debugging) enabled or disabled on device (Read-only)
         */
        adbStatus?: boolean;
        /**
         * List of applications installed on Mobile Device
         */
        applications?: Array<{
            displayName?: string;
            packageName?: string;
            permission?: string[];
            versionCode?: number;
            versionName?: string;
        }>;
        /**
         * Mobile Device Baseband version (Read-only)
         */
        basebandVersion?: string;
        /**
         * Mobile Device Bootloader version (Read-only)
         */
        bootloaderVersion?: string;
        /**
         * Mobile Device Brand (Read-only)
         */
        brand?: string;
        /**
         * Mobile Device Build number (Read-only)
         */
        buildNumber?: string;
        /**
         * The default locale used on the Mobile Device (Read-only)
         */
        defaultLanguage?: string;
        /**
         * Developer options enabled or disabled on device (Read-only)
         */
        developerOptionsStatus?: boolean;
        /**
         * Mobile Device compromised status (Read-only)
         */
        deviceCompromisedStatus?: string;
        /**
         * Mobile Device serial number (Read-only)
         */
        deviceId?: string;
        /**
         * DevicePasswordStatus (Read-only)
         */
        devicePasswordStatus?: string;
        /**
         * List of owner user's email addresses (Read-only)
         */
        email?: string[];
        /**
         * Mobile Device Encryption Status (Read-only)
         */
        encryptionStatus?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Date and time the device was first synchronized with the policy settings
         * in the G Suite administrator control panel (Read-only)
         */
        firstSync?: string;
        /**
         * Mobile Device Hardware (Read-only)
         */
        hardware?: string;
        /**
         * Mobile Device Hardware Id (Read-only)
         */
        hardwareId?: string;
        /**
         * Mobile Device IMEI number (Read-only)
         */
        imei?: string;
        /**
         * Mobile Device Kernel version (Read-only)
         */
        kernelVersion?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * Date and time the device was last synchronized with the policy settings
         * in the G Suite administrator control panel (Read-only)
         */
        lastSync?: string;
        /**
         * Boolean indicating if this account is on owner/primary profile or not
         * (Read-only)
         */
        managedAccountIsOnOwnerProfile?: boolean;
        /**
         * Mobile Device manufacturer (Read-only)
         */
        manufacturer?: string;
        /**
         * Mobile Device MEID number (Read-only)
         */
        meid?: string;
        /**
         * Name of the model of the device
         */
        model?: string;
        /**
         * List of owner user's names (Read-only)
         */
        name?: string[];
        /**
         * Mobile Device mobile or network operator (if available) (Read-only)
         */
        networkOperator?: string;
        /**
         * Name of the mobile operating system
         */
        os?: string;
        /**
         * List of accounts added on device (Read-only)
         */
        otherAccountsInfo?: string[];
        /**
         * DMAgentPermission (Read-only)
         */
        privilege?: string;
        /**
         * Mobile Device release version version (Read-only)
         */
        releaseVersion?: string;
        /**
         * Unique identifier of Mobile Device (Read-only)
         */
        resourceId?: string;
        /**
         * Mobile Device Security patch level (Read-only)
         */
        securityPatchLevel?: string;
        /**
         * Mobile Device SSN or Serial Number (Read-only)
         */
        serialNumber?: string;
        /**
         * Status of the device (Read-only)
         */
        status?: string;
        /**
         * Work profile supported on device (Read-only)
         */
        supportsWorkProfile?: boolean;
        /**
         * The type of device (Read-only)
         */
        type?: string;
        /**
         * Unknown sources enabled or disabled on device (Read-only)
         */
        unknownSourcesStatus?: boolean;
        /**
         * Mobile Device user agent
         */
        userAgent?: string;
        /**
         * Mobile Device WiFi MAC address (Read-only)
         */
        wifiMacAddress?: string;
    }


/**
     * JSON request template for firing commands on Mobile Device in Directory
     * Devices API.
     */
interface Schema$MobileDeviceAction {
        /**
         * Action to be taken on the Mobile Device
         */
        action?: string;
    }


/**
     * JSON response template for List Mobile Devices operation in Directory API.
     */
interface Schema$MobileDevices {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * List of Mobile Device objects.
         */
        mobiledevices?: Schema$MobileDevice[];
        /**
         * Token used to access next page of this result.
         */
        nextPageToken?: string;
    }


/**
     * Template for a notification resource.
     */
interface Schema$Notification {
        /**
         * Body of the notification (Read-only)
         */
        body?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Address from which the notification is received (Read-only)
         */
        fromAddress?: string;
        /**
         * Boolean indicating whether the notification is unread or not.
         */
        isUnread?: boolean;
        /**
         * The type of the resource.
         */
        kind?: string;
        notificationId?: string;
        /**
         * Time at which notification was sent (Read-only)
         */
        sendTime?: string;
        /**
         * Subject of the notification (Read-only)
         */
        subject?: string;
    }


/**
     * Template for notifications list response.
     */
interface Schema$Notifications {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * List of notifications in this page.
         */
        items?: Schema$Notification[];
        /**
         * The type of the resource.
         */
        kind?: string;
        /**
         * Token for fetching the next page of notifications.
         */
        nextPageToken?: string;
        /**
         * Number of unread notification for the domain.
         */
        unreadNotificationsCount?: number;
    }


/**
     * JSON template for Org Unit resource in Directory API.
     */
interface Schema$OrgUnit {
        /**
         * Should block inheritance
         */
        blockInheritance?: boolean;
        /**
         * Description of OrgUnit
         */
        description?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * Name of OrgUnit
         */
        name?: string;
        /**
         * Id of OrgUnit
         */
        orgUnitId?: string;
        /**
         * Path of OrgUnit
         */
        orgUnitPath?: string;
        /**
         * Id of parent OrgUnit
         */
        parentOrgUnitId?: string;
        /**
         * Path of parent OrgUnit
         */
        parentOrgUnitPath?: string;
    }


/**
     * JSON response template for List Organization Units operation in Directory
     * API.
     */
interface Schema$OrgUnits {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * List of user objects.
         */
        organizationUnits?: Schema$OrgUnit[];
    }


/**
     * JSON template for privilege resource in Directory API.
     */
interface Schema$Privilege {
        /**
         * A list of child privileges. Privileges for a service form a tree. Each
         * privilege can have a list of child privileges; this list is empty for a
         * leaf privilege.
         */
        childPrivileges?: Schema$Privilege[];
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * If the privilege can be restricted to an organization unit.
         */
        isOuScopable?: boolean;
        /**
         * The type of the API resource. This is always admin#directory#privilege.
         */
        kind?: string;
        /**
         * The name of the privilege.
         */
        privilegeName?: string;
        /**
         * The obfuscated ID of the service this privilege is for.
         */
        serviceId?: string;
        /**
         * The name of the service this privilege is for.
         */
        serviceName?: string;
    }


/**
     * JSON response template for List privileges operation in Directory API.
     */
interface Schema$Privileges {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * A list of Privilege resources.
         */
        items?: Schema$Privilege[];
        /**
         * The type of the API resource. This is always admin#directory#privileges.
         */
        kind?: string;
    }


/**
     * JSON template for role resource in Directory API.
     */
interface Schema$Role {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Returns true if the role is a super admin role.
         */
        isSuperAdminRole?: boolean;
        /**
         * Returns true if this is a pre-defined system role.
         */
        isSystemRole?: boolean;
        /**
         * The type of the API resource. This is always admin#directory#role.
         */
        kind?: string;
        /**
         * A short description of the role.
         */
        roleDescription?: string;
        /**
         * ID of the role.
         */
        roleId?: string;
        /**
         * Name of the role.
         */
        roleName?: string;
        /**
         * The set of privileges that are granted to this role.
         */
        rolePrivileges?: Array<{
            privilegeName?: string;
            serviceId?: string;
        }>;
    }


/**
     * JSON template for roleAssignment resource in Directory API.
     */
interface Schema$RoleAssignment {
        /**
         * The unique ID of the user this role is assigned to.
         */
        assignedTo?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * The type of the API resource. This is always
         * admin#directory#roleAssignment.
         */
        kind?: string;
        /**
         * If the role is restricted to an organization unit, this contains the ID
         * for the organization unit the exercise of this role is restricted to.
         */
        orgUnitId?: string;
        /**
         * ID of this roleAssignment.
         */
        roleAssignmentId?: string;
        /**
         * The ID of the role that is assigned.
         */
        roleId?: string;
        /**
         * The scope in which this role is assigned. Possible values are:  -
         * CUSTOMER - ORG_UNIT
         */
        scopeType?: string;
    }


/**
     * JSON response template for List roleAssignments operation in Directory API.
     */
interface Schema$RoleAssignments {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * A list of RoleAssignment resources.
         */
        items?: Schema$RoleAssignment[];
        /**
         * The type of the API resource. This is always
         * admin#directory#roleAssignments.
         */
        kind?: string;
        nextPageToken?: string;
    }


/**
     * JSON response template for List roles operation in Directory API.
     */
interface Schema$Roles {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * A list of Role resources.
         */
        items?: Schema$Role[];
        /**
         * The type of the API resource. This is always admin#directory#roles.
         */
        kind?: string;
        nextPageToken?: string;
    }


/**
     * JSON template for Schema resource in Directory API.
     */
interface Schema$Schema {
        /**
         * Display name for the schema.
         */
        displayName?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Fields of Schema
         */
        fields?: Schema$SchemaFieldSpec[];
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * Unique identifier of Schema (Read-only)
         */
        schemaId?: string;
        /**
         * Schema name
         */
        schemaName?: string;
    }


/**
     * JSON template for FieldSpec resource for Schemas in Directory API.
     */
interface Schema$SchemaFieldSpec {
        /**
         * Display Name of the field.
         */
        displayName?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Unique identifier of Field (Read-only)
         */
        fieldId?: string;
        /**
         * Name of the field.
         */
        fieldName?: string;
        /**
         * Type of the field.
         */
        fieldType?: string;
        /**
         * Boolean specifying whether the field is indexed or not.
         */
        indexed?: boolean;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * Boolean specifying whether this is a multi-valued field or not.
         */
        multiValued?: boolean;
        /**
         * Indexing spec for a numeric field. By default, only exact match queries
         * will be supported for numeric fields. Setting the numericIndexingSpec
         * allows range queries to be supported.
         */
        numericIndexingSpec?: {
            maxValue?: number;
            minValue?: number;
        };
        /**
         * Read ACLs on the field specifying who can view values of this field.
         * Valid values are "ALL_DOMAIN_USERS" and
         * "ADMINS_AND_SELF".
         */
        readAccessType?: string;
    }


/**
     * JSON response template for List Schema operation in Directory API.
     */
interface Schema$Schemas {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * List of UserSchema objects.
         */
        schemas?: Schema$Schema[];
    }


/**
     * JSON template for token resource in Directory API.
     */
interface Schema$Token {
        /**
         * Whether the application is registered with Google. The value is true if
         * the application has an anonymous Client ID.
         */
        anonymous?: boolean;
        /**
         * The Client ID of the application the token is issued to.
         */
        clientId?: string;
        /**
         * The displayable name of the application the token is issued to.
         */
        displayText?: string;
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * The type of the API resource. This is always admin#directory#token.
         */
        kind?: string;
        /**
         * Whether the token is issued to an installed application. The value is
         * true if the application is installed to a desktop or mobile device.
         */
        nativeApp?: boolean;
        /**
         * A list of authorization scopes the application is granted.
         */
        scopes?: string[];
        /**
         * The unique ID of the user that issued the token.
         */
        userKey?: string;
    }


/**
     * JSON response template for List tokens operation in Directory API.
     */
interface Schema$Tokens {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * A list of Token resources.
         */
        items?: Schema$Token[];
        /**
         * The type of the API resource. This is always admin#directory#tokenList.
         */
        kind?: string;
    }


/**
     * JSON template for Trusted App Ids Resource object in Directory API.
     */
interface Schema$TrustedAppId {
        /**
         * Android package name.
         */
        androidPackageName?: string;
        /**
         * SHA1 signature of the app certificate.
         */
        certificateHashSHA1?: string;
        /**
         * SHA256 signature of the app certificate.
         */
        certificateHashSHA256?: string;
        etag?: string;
        /**
         * Identifies the resource as a trusted AppId.
         */
        kind?: string;
    }


/**
     * JSON template for Trusted Apps response object of a user in Directory API.
     */
interface Schema$TrustedApps {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Identifies the resource as trusted apps response.
         */
        kind?: string;
        nextPageToken?: string;
        /**
         * Trusted Apps list.
         */
        trustedApps?: Schema$TrustedAppId[];
    }


/**
     * JSON template for User object in Directory API.
     */
interface Schema$User {
        addresses?: any;
        /**
         * Indicates if user has agreed to terms (Read-only)
         */
        agreedToTerms?: boolean;
        /**
         * List of aliases (Read-only)
         */
        aliases?: string[];
        /**
         * Indicates if user is archived.
         */
        archived?: boolean;
        /**
         * Boolean indicating if the user should change password in next login
         */
        changePasswordAtNextLogin?: boolean;
        /**
         * User's G Suite account creation time. (Read-only)
         */
        creationTime?: string;
        /**
         * CustomerId of User (Read-only)
         */
        customerId?: string;
        /**
         * Custom fields of the user.
         */
        customSchemas?: {
            [key: string]: Schema$UserCustomProperties;
        };
        deletionTime?: string;
        emails?: any;
        /**
         * ETag of the resource.
         */
        etag?: string;
        externalIds?: any;
        gender?: any;
        /**
         * Hash function name for password. Supported are MD5, SHA-1 and crypt
         */
        hashFunction?: string;
        /**
         * Unique identifier of User (Read-only)
         */
        id?: string;
        ims?: any;
        /**
         * Boolean indicating if user is included in Global Address List
         */
        includeInGlobalAddressList?: boolean;
        /**
         * Boolean indicating if ip is whitelisted
         */
        ipWhitelisted?: boolean;
        /**
         * Boolean indicating if the user is admin (Read-only)
         */
        isAdmin?: boolean;
        /**
         * Boolean indicating if the user is delegated admin (Read-only)
         */
        isDelegatedAdmin?: boolean;
        /**
         * Is 2-step verification enforced (Read-only)
         */
        isEnforcedIn2Sv?: boolean;
        /**
         * Is enrolled in 2-step verification (Read-only)
         */
        isEnrolledIn2Sv?: boolean;
        /**
         * Is mailbox setup (Read-only)
         */
        isMailboxSetup?: boolean;
        keywords?: any;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        languages?: any;
        /**
         * User's last login time. (Read-only)
         */
        lastLoginTime?: string;
        locations?: any;
        /**
         * User's name
         */
        name?: Schema$UserName;
        /**
         * List of non editable aliases (Read-only)
         */
        nonEditableAliases?: string[];
        notes?: any;
        organizations?: any;
        /**
         * OrgUnit of User
         */
        orgUnitPath?: string;
        /**
         * User's password
         */
        password?: string;
        phones?: any;
        posixAccounts?: any;
        /**
         * username of User
         */
        primaryEmail?: string;
        relations?: any;
        sshPublicKeys?: any;
        /**
         * Indicates if user is suspended.
         */
        suspended?: boolean;
        /**
         * Suspension reason if user is suspended (Read-only)
         */
        suspensionReason?: string;
        /**
         * ETag of the user's photo (Read-only)
         */
        thumbnailPhotoEtag?: string;
        /**
         * Photo Url of the user (Read-only)
         */
        thumbnailPhotoUrl?: string;
        websites?: any;
    }


/**
     * JSON template for About (notes) of a user in Directory API.
     */
interface Schema$UserAbout {
        /**
         * About entry can have a type which indicates the content type. It can
         * either be plain or html. By default, notes contents are assumed to
         * contain plain text.
         */
        contentType?: string;
        /**
         * Actual value of notes.
         */
        value?: string;
    }


/**
     * JSON template for address.
     */
interface Schema$UserAddress {
        /**
         * Country.
         */
        country?: string;
        /**
         * Country code.
         */
        countryCode?: string;
        /**
         * Custom type.
         */
        customType?: string;
        /**
         * Extended Address.
         */
        extendedAddress?: string;
        /**
         * Formatted address.
         */
        formatted?: string;
        /**
         * Locality.
         */
        locality?: string;
        /**
         * Other parts of address.
         */
        poBox?: string;
        /**
         * Postal code.
         */
        postalCode?: string;
        /**
         * If this is user's primary address. Only one entry could be marked as
         * primary.
         */
        primary?: boolean;
        /**
         * Region.
         */
        region?: string;
        /**
         * User supplied address was structured. Structured addresses are NOT
         * supported at this time. You might be able to write structured addresses,
         * but any values will eventually be clobbered.
         */
        sourceIsStructured?: boolean;
        /**
         * Street.
         */
        streetAddress?: string;
        /**
         * Each entry can have a type which indicates standard values of that entry.
         * For example address could be of home, work etc. In addition to the
         * standard type, an entry can have a custom type and can take any value.
         * Such type should have the CUSTOM value as type and also have a customType
         * value.
         */
        type?: string;
    }


/**
     * JSON template for a set of custom properties (i.e. all fields in a
     * particular schema)
     */
interface Schema$UserCustomProperties {
    }


/**
     * JSON template for an email.
     */
interface Schema$UserEmail {
        /**
         * Email id of the user.
         */
        address?: string;
        /**
         * Custom Type.
         */
        customType?: string;
        /**
         * If this is user's primary email. Only one entry could be marked as
         * primary.
         */
        primary?: boolean;
        /**
         * Each entry can have a type which indicates standard types of that entry.
         * For example email could be of home, work etc. In addition to the standard
         * type, an entry can have a custom type and can take any value Such types
         * should have the CUSTOM value as type and also have a customType value.
         */
        type?: string;
    }


/**
     * JSON template for an externalId entry.
     */
interface Schema$UserExternalId {
        /**
         * Custom type.
         */
        customType?: string;
        /**
         * The type of the Id.
         */
        type?: string;
        /**
         * The value of the id.
         */
        value?: string;
    }


interface Schema$UserGender {
        /**
         * AddressMeAs. A human-readable string containing the proper way to refer
         * to the profile owner by humans, for example "he/him/his" or
         * "they/them/their".
         */
        addressMeAs?: string;
        /**
         * Custom gender.
         */
        customGender?: string;
        /**
         * Gender.
         */
        type?: string;
    }


/**
     * JSON template for instant messenger of an user.
     */
interface Schema$UserIm {
        /**
         * Custom protocol.
         */
        customProtocol?: string;
        /**
         * Custom type.
         */
        customType?: string;
        /**
         * Instant messenger id.
         */
        im?: string;
        /**
         * If this is user's primary im. Only one entry could be marked as
         * primary.
         */
        primary?: boolean;
        /**
         * Protocol used in the instant messenger. It should be one of the values
         * from ImProtocolTypes map. Similar to type, it can take a CUSTOM value and
         * specify the custom name in customProtocol field.
         */
        protocol?: string;
        /**
         * Each entry can have a type which indicates standard types of that entry.
         * For example instant messengers could be of home, work etc. In addition to
         * the standard type, an entry can have a custom type and can take any
         * value. Such types should have the CUSTOM value as type and also have a
         * customType value.
         */
        type?: string;
    }


/**
     * JSON template for a keyword entry.
     */
interface Schema$UserKeyword {
        /**
         * Custom Type.
         */
        customType?: string;
        /**
         * Each entry can have a type which indicates standard type of that entry.
         * For example, keyword could be of type occupation or outlook. In addition
         * to the standard type, an entry can have a custom type and can give it any
         * name. Such types should have the CUSTOM value as type and also have a
         * customType value.
         */
        type?: string;
        /**
         * Keyword.
         */
        value?: string;
    }


/**
     * JSON template for a language entry.
     */
interface Schema$UserLanguage {
        /**
         * Other language. User can provide own language name if there is no
         * corresponding Google III language code. If this is set LanguageCode
         * can't be set
         */
        customLanguage?: string;
        /**
         * Language Code. Should be used for storing Google III LanguageCode string
         * representation for language. Illegal values cause SchemaException.
         */
        languageCode?: string;
    }


/**
     * JSON template for a location entry.
     */
interface Schema$UserLocation {
        /**
         * Textual location. This is most useful for display purposes to concisely
         * describe the location. For example, "Mountain View, CA",
         * "Near Seattle", "US-NYC-9TH 9A209A".
         */
        area?: string;
        /**
         * Building Identifier.
         */
        buildingId?: string;
        /**
         * Custom Type.
         */
        customType?: string;
        /**
         * Most specific textual code of individual desk location.
         */
        deskCode?: string;
        /**
         * Floor name/number.
         */
        floorName?: string;
        /**
         * Floor section. More specific location within the floor. For example, if a
         * floor is divided into sections "A", "B", and
         * "C", this field would identify one of those values.
         */
        floorSection?: string;
        /**
         * Each entry can have a type which indicates standard types of that entry.
         * For example location could be of types default and desk. In addition to
         * standard type, an entry can have a custom type and can give it any name.
         * Such types should have "custom" as type and also have a
         * customType value.
         */
        type?: string;
    }


/**
     * JSON request template for setting/revoking admin status of a user in
     * Directory API.
     */
interface Schema$UserMakeAdmin {
        /**
         * Boolean indicating new admin status of the user
         */
        status?: boolean;
    }


/**
     * JSON template for name of a user in Directory API.
     */
interface Schema$UserName {
        /**
         * Last Name
         */
        familyName?: string;
        /**
         * Full Name
         */
        fullName?: string;
        /**
         * First Name
         */
        givenName?: string;
    }


/**
     * JSON template for an organization entry.
     */
interface Schema$UserOrganization {
        /**
         * The cost center of the users department.
         */
        costCenter?: string;
        /**
         * Custom type.
         */
        customType?: string;
        /**
         * Department within the organization.
         */
        department?: string;
        /**
         * Description of the organization.
         */
        description?: string;
        /**
         * The domain to which the organization belongs to.
         */
        domain?: string;
        /**
         * The full-time equivalent percent within the organization (100000 = 100%).
         */
        fullTimeEquivalent?: number;
        /**
         * Location of the organization. This need not be fully qualified address.
         */
        location?: string;
        /**
         * Name of the organization
         */
        name?: string;
        /**
         * If it user's primary organization.
         */
        primary?: boolean;
        /**
         * Symbol of the organization.
         */
        symbol?: string;
        /**
         * Title (designation) of the user in the organization.
         */
        title?: string;
        /**
         * Each entry can have a type which indicates standard types of that entry.
         * For example organization could be of school, work etc. In addition to the
         * standard type, an entry can have a custom type and can give it any name.
         * Such types should have the CUSTOM value as type and also have a
         * CustomType value.
         */
        type?: string;
    }


/**
     * JSON template for a phone entry.
     */
interface Schema$UserPhone {
        /**
         * Custom Type.
         */
        customType?: string;
        /**
         * If this is user's primary phone or not.
         */
        primary?: boolean;
        /**
         * Each entry can have a type which indicates standard types of that entry.
         * For example phone could be of home_fax, work, mobile etc. In addition to
         * the standard type, an entry can have a custom type and can give it any
         * name. Such types should have the CUSTOM value as type and also have a
         * customType value.
         */
        type?: string;
        /**
         * Phone number.
         */
        value?: string;
    }


/**
     * JSON template for Photo object in Directory API.
     */
interface Schema$UserPhoto {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Height in pixels of the photo
         */
        height?: number;
        /**
         * Unique identifier of User (Read-only)
         */
        id?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * Mime Type of the photo
         */
        mimeType?: string;
        /**
         * Base64 encoded photo data
         */
        photoData?: string;
        /**
         * Primary email of User (Read-only)
         */
        primaryEmail?: string;
        /**
         * Width in pixels of the photo
         */
        width?: number;
    }


/**
     * JSON template for a POSIX account entry. Description of the field family:
     * go/fbs-posix.
     */
interface Schema$UserPosixAccount {
        /**
         * A POSIX account field identifier.
         */
        accountId?: string;
        /**
         * The GECOS (user information) for this account.
         */
        gecos?: string;
        /**
         * The default group ID.
         */
        gid?: string;
        /**
         * The path to the home directory for this account.
         */
        homeDirectory?: string;
        /**
         * The operating system type for this account.
         */
        operatingSystemType?: string;
        /**
         * If this is user's primary account within the SystemId.
         */
        primary?: boolean;
        /**
         * The path to the login shell for this account.
         */
        shell?: string;
        /**
         * System identifier for which account Username or Uid apply to.
         */
        systemId?: string;
        /**
         * The POSIX compliant user ID.
         */
        uid?: string;
        /**
         * The username of the account.
         */
        username?: string;
    }


/**
     * JSON template for a relation entry.
     */
interface Schema$UserRelation {
        /**
         * Custom Type.
         */
        customType?: string;
        /**
         * The relation of the user. Some of the possible values are mother, father,
         * sister, brother, manager, assistant, partner.
         */
        type?: string;
        /**
         * The name of the relation.
         */
        value?: string;
    }


/**
     * JSON response template for List Users operation in Apps Directory API.
     */
interface Schema$Users {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * Kind of resource this is.
         */
        kind?: string;
        /**
         * Token used to access next page of this result.
         */
        nextPageToken?: string;
        /**
         * Event that triggered this response (only used in case of Push Response)
         */
        trigger_event?: string;
        /**
         * List of user objects.
         */
        users?: Schema$User[];
    }


/**
     * JSON template for a POSIX account entry.
     */
interface Schema$UserSshPublicKey {
        /**
         * An expiration time in microseconds since epoch.
         */
        expirationTimeUsec?: string;
        /**
         * A SHA-256 fingerprint of the SSH public key. (Read-only)
         */
        fingerprint?: string;
        /**
         * An SSH public key.
         */
        key?: string;
    }


/**
     * JSON request template to undelete a user in Directory API.
     */
interface Schema$UserUndelete {
        /**
         * OrgUnit of User
         */
        orgUnitPath?: string;
    }


/**
     * JSON template for a website entry.
     */
interface Schema$UserWebsite {
        /**
         * Custom Type.
         */
        customType?: string;
        /**
         * If this is user's primary website or not.
         */
        primary?: boolean;
        /**
         * Each entry can have a type which indicates standard types of that entry.
         * For example website could be of home, work, blog etc. In addition to the
         * standard type, an entry can have a custom type and can give it any name.
         * Such types should have the CUSTOM value as type and also have a
         * customType value.
         */
        type?: string;
        /**
         * Website.
         */
        value?: string;
    }


/**
     * JSON template for verification codes in Directory API.
     */
interface Schema$VerificationCode {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * The type of the resource. This is always
         * admin#directory#verificationCode.
         */
        kind?: string;
        /**
         * The obfuscated unique ID of the user.
         */
        userId?: string;
        /**
         * A current verification code for the user. Invalidated or used
         * verification codes are not returned as part of the result.
         */
        verificationCode?: string;
    }


/**
     * JSON response template for List verification codes operation in Directory
     * API.
     */
interface Schema$VerificationCodes {
        /**
         * ETag of the resource.
         */
        etag?: string;
        /**
         * A list of verification code resources.
         */
        items?: Schema$VerificationCode[];
        /**
         * The type of the resource. This is always
         * admin#directory#verificationCodesList.
         */
        kind?: string;
    }


interface Params$Resource$Asps$Delete extends StandardParameters {
        /**
         * Auth client or API Key for the request
         */
        auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
        /**
         * The unique ID of the ASP to be deleted.
         */
        codeId?: number;
        /**
         * Identifies the user in the API request. The value can be the user's
         * primary email address, alias email address, or unique user ID.
         */
        userKey?: string;
    }


interface Params$Resource$Asps$Get extends StandardParameters {
        /**
         * Auth client or API Key for the request
         */
        auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
        /**
         * The unique ID of the ASP.
         */
        codeId?: number;
        /**
         * Identifies the user in the API request. The value can be the user's
         * primary email address, alias email address, or unique user ID.
         */
        userKey?: string;
    }


interface Params$Resource$Asps$List extends StandardParameters {
        /**
         * Auth client or API Key for the request
         */
        auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
        /**
         * Identifies the user in the API request. The value can be the user's
         * primary email address, alias email address, or unique user ID.
         */
        userKey?: string;
    }


interface Params$Resource$Channels$Stop extends StandardParameters {
        /**
         * Auth client or API Key for the request
         */
        auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
        /**
         * Request body metadata
         */
        requestBody?: Schema$Channel;
    }


interface Params$Resource$Chromeosdevices$Action extends StandardParameters {
        /**
         * Auth client or API Key for the request
         */
        auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
        /**
         * Immutable ID of the G Suite account
         */
        customerId?: string;
        /**
         * Immutable ID of Chrome OS Device
         */
        resourceId?: string;
        /**
         * Request body metadata
         */
        requestBody?: Schema$ChromeOsDeviceAction;
    }


interface Params$Resource$Chromeosdevices$Get extends StandardParameters {
        /**
         * Auth client or API Key for the request
         */
        auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
        /**
         * Immutable ID of the G Suite account
         */
        customerId?: string;
        /**
         * Immutable ID of Chrome OS Device
         */
        deviceId?: string;
        /**
         * Restrict information returned to a set of selected fields.
         */
        projection?: string;
    }


interface Params$Resource$Chromeosdevices$List extends StandardParameters {
        /**
         * Auth client or API Key for the request
         */
        auth?: string | OAuth2Client | JWT | Compute | UserRefreshClient;
        /**
         * Immutable ID of the G Suite account
         */
        customerId?: string;
        /**
         * Maximum number of results to return. Default is 100
         */
        maxResults?: number;
        /**
         * Column to use for sorting results
         */
        orderBy?: string;
        /**
         * Full path of the organizational unit or its ID
         */
        orgUnitPath?: string;
        /**
         * Token to specify next page in the list
         */
        pageToken?: string;
        /**
         * Restrict information returned to a set of selected fields.
         */
        projection?: string;
        /**
         * Search string in the format given at
         * http://support.google.com/chromeos/a/bin/answer.py?answer=1698333
         */
        query?: string;
        /**
         * Whether to return results in ascending or descending order. Only of use
         * when orderBy is also used
         */
        sortOrder?: string;
    }