File

src/apis/oauth2/v2.ts

Index

Properties
Methods

Constructor

constructor(context: APIRequestContext)
Parameters :
Name Type Optional
context APIRequestContext No

Properties

context
Type : APIRequestContext
v2
Type : Resource$Userinfo$V2

Methods

get
get(params: Params$Resource$Userinfo$Get, options: StreamMethodOptions)
// Before running the sample:
// - Enable the API at:
//   https://console.developers.google.com/apis/api/oauth2.googleapis.com
// - Login into gcloud by running:
//   `$ gcloud auth application-default login`
// - Install the npm module by running:
//   `$ npm install googleapis`

const {google} = require('googleapis');
const oauth2 = google.oauth2('v2');

async function main() {
  const auth = new google.auth.GoogleAuth({
    // Scopes can be specified either as an array or as a single, space-delimited string.
    scopes: [
      'openid',
      'https://www.googleapis.com/auth/userinfo.email',
      'https://www.googleapis.com/auth/userinfo.profile',
    ],
  });

  // Acquire an auth client, and bind it to all future calls
  const authClient = await auth.getClient();
  google.options({auth: authClient});

  // Do the magic
  const res = await oauth2.userinfo.get({});
  console.log(res.data);

  // Example response
  // {
  //   "email": "my_email",
  //   "family_name": "my_family_name",
  //   "gender": "my_gender",
  //   "given_name": "my_given_name",
  //   "hd": "my_hd",
  //   "id": "my_id",
  //   "link": "my_link",
  //   "locale": "my_locale",
  //   "name": "my_name",
  //   "picture": "my_picture",
  //   "verified_email": false
  // }
}

main().catch(e => {
  console.error(e);
  throw e;
});
Parameters :
Name Type Optional Description
params Params$Resource$Userinfo$Get No
  • Parameters for request
options StreamMethodOptions No
  • Optionally override request options, such as url, method, and encoding.
Example :
<pre><code class="language-js">// Before running the sample:
// - Enable the API at:
//   https://console.developers.google.com/apis/api/oauth2.googleapis.com
// - Login into gcloud by running:
//   `$ gcloud auth application-default login`
// - Install the npm module by running:
//   `$ npm install googleapis`

const {google} = require(&#39;googleapis&#39;);
const oauth2 = google.oauth2(&#39;v2&#39;);

async function main() {
  const auth = new google.auth.GoogleAuth({
    // Scopes can be specified either as an array or as a single, space-delimited string.
    scopes: [
      &#39;openid&#39;,
      &#39;https://www.googleapis.com/auth/userinfo.email&#39;,
      &#39;https://www.googleapis.com/auth/userinfo.profile&#39;,
    ],
  });

  // Acquire an auth client, and bind it to all future calls
  const authClient = await auth.getClient();
  google.options({auth: authClient});

  // Do the magic
  const res = await oauth2.userinfo.get({});
  console.log(res.data);

  // Example response
  // {
  //   &quot;email&quot;: &quot;my_email&quot;,
  //   &quot;family_name&quot;: &quot;my_family_name&quot;,
  //   &quot;gender&quot;: &quot;my_gender&quot;,
  //   &quot;given_name&quot;: &quot;my_given_name&quot;,
  //   &quot;hd&quot;: &quot;my_hd&quot;,
  //   &quot;id&quot;: &quot;my_id&quot;,
  //   &quot;link&quot;: &quot;my_link&quot;,
  //   &quot;locale&quot;: &quot;my_locale&quot;,
  //   &quot;name&quot;: &quot;my_name&quot;,
  //   &quot;picture&quot;: &quot;my_picture&quot;,
  //   &quot;verified_email&quot;: false
  // }
}

main().catch(e =&gt; {
  console.error(e);
  throw e;
});
</code></pre>
Returns : GaxiosPromise<Readable>

A promise if used with async/await, or void if used with a callback.

get
get(params?: Params$Resource$Userinfo$Get, options?: MethodOptions)
Parameters :
Name Type Optional
params Params$Resource$Userinfo$Get Yes
options MethodOptions Yes
get
get(params: Params$Resource$Userinfo$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback)
Parameters :
Name Type Optional
params Params$Resource$Userinfo$Get No
options StreamMethodOptions | BodyResponseCallback<Readable> No
callback BodyResponseCallback<Readable> No
Returns : void
get
get(params: Params$Resource$Userinfo$Get, options: MethodOptions | BodyResponseCallback, callback: BodyResponseCallback<Schema$Userinfo>)
Parameters :
Name Type Optional
params Params$Resource$Userinfo$Get No
options MethodOptions | BodyResponseCallback<Schema$Userinfo> No
callback BodyResponseCallback<Schema$Userinfo> No
Returns : void
get
get(params: Params$Resource$Userinfo$Get, callback: BodyResponseCallback<Schema$Userinfo>)
Parameters :
Name Type Optional
params Params$Resource$Userinfo$Get No
callback BodyResponseCallback<Schema$Userinfo> No
Returns : void
get
get(callback: BodyResponseCallback<Schema$Userinfo>)
Parameters :
Name Type Optional
callback BodyResponseCallback<Schema$Userinfo> No
Returns : void
get
get(paramsOrCallback?: Params$Resource$Userinfo$Get | BodyResponseCallback<Schema$Userinfo> | BodyResponseCallback<Readable>, optionsOrCallback?: MethodOptions | StreamMethodOptions | BodyResponseCallback | BodyResponseCallback, callback?: BodyResponseCallback<Schema$Userinfo> | BodyResponseCallback<Readable>)
Parameters :
Name Type Optional
paramsOrCallback Params$Resource$Userinfo$Get | BodyResponseCallback<Schema$Userinfo> | BodyResponseCallback<Readable> Yes
optionsOrCallback MethodOptions | StreamMethodOptions | BodyResponseCallback<Schema$Userinfo> | BodyResponseCallback<Readable> Yes
callback BodyResponseCallback<Schema$Userinfo> | BodyResponseCallback<Readable> Yes
Returns : void | GaxiosPromise | GaxiosPromise
import {
  OAuth2Client,
  JWT,
  Compute,
  UserRefreshClient,
  BaseExternalAccountClient,
  GaxiosPromise,
  GoogleConfigurable,
  createAPIRequest,
  MethodOptions,
  StreamMethodOptions,
  GlobalOptions,
  GoogleAuth,
  BodyResponseCallback,
  APIRequestContext,
} from 'googleapis-common';
import {Readable} from 'stream';

export namespace oauth2_v2 {
  export interface Options extends GlobalOptions {
    version: 'v2';
  }

  interface StandardParameters {
    /**
     * Auth client or API Key for the request
     */
    auth?:
      | string
      | OAuth2Client
      | JWT
      | Compute
      | UserRefreshClient
      | BaseExternalAccountClient
      | GoogleAuth;

    /**
     * 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;
  }

  /**
   * Google OAuth2 API
   *
   * Obtains end-user authorization grants for use with other Google APIs.
   *
   * @example
   * ```js
   * const {google} = require('googleapis');
   * const oauth2 = google.oauth2('v2');
   * ```
   */
  export class Oauth2 {
    context: APIRequestContext;
    userinfo: Resource$Userinfo;

    constructor(options: GlobalOptions, google?: GoogleConfigurable) {
      this.context = {
        _options: options || {},
        google,
      };

      this.userinfo = new Resource$Userinfo(this.context);
    }

    /**
     * @example
     * ```js
     * // Before running the sample:
     * // - Enable the API at:
     * //   https://console.developers.google.com/apis/api/oauth2.googleapis.com
     * // - Login into gcloud by running:
     * //   `$ gcloud auth application-default login`
     * // - Install the npm module by running:
     * //   `$ npm install googleapis`
     *
     * const {google} = require('googleapis');
     * const oauth2 = google.oauth2('v2');
     *
     * async function main() {
     *   const auth = new google.auth.GoogleAuth({
     *     // Scopes can be specified either as an array or as a single, space-delimited string.
     *     scopes: [],
     *   });
     *
     *   // Acquire an auth client, and bind it to all future calls
     *   const authClient = await auth.getClient();
     *   google.options({auth: authClient});
     *
     *   // Do the magic
     *   const res = await oauth2.tokeninfo({
     *     access_token: 'placeholder-value',
     *
     *     id_token: 'placeholder-value',
     *   });
     *   console.log(res.data);
     *
     *   // Example response
     *   // {
     *   //   "audience": "my_audience",
     *   //   "email": "my_email",
     *   //   "expires_in": 0,
     *   //   "issued_to": "my_issued_to",
     *   //   "scope": "my_scope",
     *   //   "user_id": "my_user_id",
     *   //   "verified_email": false
     *   // }
     * }
     *
     * main().catch(e => {
     *   console.error(e);
     *   throw e;
     * });
     *
     * ```
     *
     * @param params - Parameters for request
     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param callback - Optional callback that handles the response.
     * @returns A promise if used with async/await, or void if used with a callback.
     */
    tokeninfo(
      params: Params$$Tokeninfo,
      options: StreamMethodOptions
    ): GaxiosPromise<Readable>;
    tokeninfo(
      params?: Params$$Tokeninfo,
      options?: MethodOptions
    ): GaxiosPromise<Schema$Tokeninfo>;
    tokeninfo(
      params: Params$$Tokeninfo,
      options: StreamMethodOptions | BodyResponseCallback<Readable>,
      callback: BodyResponseCallback<Readable>
    ): void;
    tokeninfo(
      params: Params$$Tokeninfo,
      options: MethodOptions | BodyResponseCallback<Schema$Tokeninfo>,
      callback: BodyResponseCallback<Schema$Tokeninfo>
    ): void;
    tokeninfo(
      params: Params$$Tokeninfo,
      callback: BodyResponseCallback<Schema$Tokeninfo>
    ): void;
    tokeninfo(callback: BodyResponseCallback<Schema$Tokeninfo>): void;
    tokeninfo(
      paramsOrCallback?:
        | Params$$Tokeninfo
        | BodyResponseCallback<Schema$Tokeninfo>
        | BodyResponseCallback<Readable>,
      optionsOrCallback?:
        | MethodOptions
        | StreamMethodOptions
        | BodyResponseCallback<Schema$Tokeninfo>
        | BodyResponseCallback<Readable>,
      callback?:
        | BodyResponseCallback<Schema$Tokeninfo>
        | BodyResponseCallback<Readable>
    ): void | GaxiosPromise<Schema$Tokeninfo> | GaxiosPromise<Readable> {
      let params = (paramsOrCallback || {}) as Params$$Tokeninfo;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$$Tokeninfo;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
          {
            url: (rootUrl + '/oauth2/v2/tokeninfo').replace(
              /([^:]\/)\/+/g,
              '$1'
            ),
            method: 'POST',
          },
          options
        ),
        params,
        requiredParams: [],
        pathParams: [],
        context: this.context,
      };
      if (callback) {
        createAPIRequest<Schema$Tokeninfo>(
          parameters,
          callback as BodyResponseCallback<unknown>
        );
      } else {
        return createAPIRequest<Schema$Tokeninfo>(parameters);
      }
    }
  }

  export interface Schema$Tokeninfo {
    /**
     * Who is the intended audience for this token. In general the same as issued_to.
     */
    audience?: string | null;
    /**
     * The email address of the user. Present only if the email scope is present in the request.
     */
    email?: string | null;
    /**
     * The expiry time of the token, as number of seconds left until expiry.
     */
    expires_in?: number | null;
    /**
     * To whom was the token issued to. In general the same as audience.
     */
    issued_to?: string | null;
    /**
     * The space separated list of scopes granted to this token.
     */
    scope?: string | null;
    /**
     * The obfuscated user id.
     */
    user_id?: string | null;
    /**
     * Boolean flag which is true if the email address is verified. Present only if the email scope is present in the request.
     */
    verified_email?: boolean | null;
  }
  export interface Schema$Userinfo {
    /**
     * The user's email address.
     */
    email?: string | null;
    /**
     * The user's last name.
     */
    family_name?: string | null;
    /**
     * The user's gender.
     */
    gender?: string | null;
    /**
     * The user's first name.
     */
    given_name?: string | null;
    /**
     * The hosted domain e.g. example.com if the user is Google apps user.
     */
    hd?: string | null;
    /**
     * The obfuscated ID of the user.
     */
    id?: string | null;
    /**
     * URL of the profile page.
     */
    link?: string | null;
    /**
     * The user's preferred locale.
     */
    locale?: string | null;
    /**
     * The user's full name.
     */
    name?: string | null;
    /**
     * URL of the user's picture image.
     */
    picture?: string | null;
    /**
     * Boolean flag which is true if the email address is verified. Always verified because we only return the user's primary email address.
     */
    verified_email?: boolean | null;
  }

  export interface Params$$Tokeninfo extends StandardParameters {
    /**
     *
     */
    access_token?: string;
    /**
     *
     */
    id_token?: string;
  }

  export class Resource$Userinfo {
    context: APIRequestContext;
    v2: Resource$Userinfo$V2;
    constructor(context: APIRequestContext) {
      this.context = context;
      this.v2 = new Resource$Userinfo$V2(this.context);
    }

    /**
     * @example
     * ```js
     * // Before running the sample:
     * // - Enable the API at:
     * //   https://console.developers.google.com/apis/api/oauth2.googleapis.com
     * // - Login into gcloud by running:
     * //   `$ gcloud auth application-default login`
     * // - Install the npm module by running:
     * //   `$ npm install googleapis`
     *
     * const {google} = require('googleapis');
     * const oauth2 = google.oauth2('v2');
     *
     * async function main() {
     *   const auth = new google.auth.GoogleAuth({
     *     // Scopes can be specified either as an array or as a single, space-delimited string.
     *     scopes: [
     *       'openid',
     *       'https://www.googleapis.com/auth/userinfo.email',
     *       'https://www.googleapis.com/auth/userinfo.profile',
     *     ],
     *   });
     *
     *   // Acquire an auth client, and bind it to all future calls
     *   const authClient = await auth.getClient();
     *   google.options({auth: authClient});
     *
     *   // Do the magic
     *   const res = await oauth2.userinfo.get({});
     *   console.log(res.data);
     *
     *   // Example response
     *   // {
     *   //   "email": "my_email",
     *   //   "family_name": "my_family_name",
     *   //   "gender": "my_gender",
     *   //   "given_name": "my_given_name",
     *   //   "hd": "my_hd",
     *   //   "id": "my_id",
     *   //   "link": "my_link",
     *   //   "locale": "my_locale",
     *   //   "name": "my_name",
     *   //   "picture": "my_picture",
     *   //   "verified_email": false
     *   // }
     * }
     *
     * main().catch(e => {
     *   console.error(e);
     *   throw e;
     * });
     *
     * ```
     *
     * @param params - Parameters for request
     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param callback - Optional callback that handles the response.
     * @returns A promise if used with async/await, or void if used with a callback.
     */
    get(
      params: Params$Resource$Userinfo$Get,
      options: StreamMethodOptions
    ): GaxiosPromise<Readable>;
    get(
      params?: Params$Resource$Userinfo$Get,
      options?: MethodOptions
    ): GaxiosPromise<Schema$Userinfo>;
    get(
      params: Params$Resource$Userinfo$Get,
      options: StreamMethodOptions | BodyResponseCallback<Readable>,
      callback: BodyResponseCallback<Readable>
    ): void;
    get(
      params: Params$Resource$Userinfo$Get,
      options: MethodOptions | BodyResponseCallback<Schema$Userinfo>,
      callback: BodyResponseCallback<Schema$Userinfo>
    ): void;
    get(
      params: Params$Resource$Userinfo$Get,
      callback: BodyResponseCallback<Schema$Userinfo>
    ): void;
    get(callback: BodyResponseCallback<Schema$Userinfo>): void;
    get(
      paramsOrCallback?:
        | Params$Resource$Userinfo$Get
        | BodyResponseCallback<Schema$Userinfo>
        | BodyResponseCallback<Readable>,
      optionsOrCallback?:
        | MethodOptions
        | StreamMethodOptions
        | BodyResponseCallback<Schema$Userinfo>
        | BodyResponseCallback<Readable>,
      callback?:
        | BodyResponseCallback<Schema$Userinfo>
        | BodyResponseCallback<Readable>
    ): void | GaxiosPromise<Schema$Userinfo> | GaxiosPromise<Readable> {
      let params = (paramsOrCallback || {}) as Params$Resource$Userinfo$Get;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Userinfo$Get;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
          {
            url: (rootUrl + '/oauth2/v2/userinfo').replace(
              /([^:]\/)\/+/g,
              '$1'
            ),
            method: 'GET',
          },
          options
        ),
        params,
        requiredParams: [],
        pathParams: [],
        context: this.context,
      };
      if (callback) {
        createAPIRequest<Schema$Userinfo>(
          parameters,
          callback as BodyResponseCallback<unknown>
        );
      } else {
        return createAPIRequest<Schema$Userinfo>(parameters);
      }
    }
  }

  export interface Params$Resource$Userinfo$Get extends StandardParameters {}

  export class Resource$Userinfo$V2 {
    context: APIRequestContext;
    me: Resource$Userinfo$V2$Me;
    constructor(context: APIRequestContext) {
      this.context = context;
      this.me = new Resource$Userinfo$V2$Me(this.context);
    }
  }

  export class Resource$Userinfo$V2$Me {
    context: APIRequestContext;
    constructor(context: APIRequestContext) {
      this.context = context;
    }

    /**
     * @example
     * ```js
     * // Before running the sample:
     * // - Enable the API at:
     * //   https://console.developers.google.com/apis/api/oauth2.googleapis.com
     * // - Login into gcloud by running:
     * //   `$ gcloud auth application-default login`
     * // - Install the npm module by running:
     * //   `$ npm install googleapis`
     *
     * const {google} = require('googleapis');
     * const oauth2 = google.oauth2('v2');
     *
     * async function main() {
     *   const auth = new google.auth.GoogleAuth({
     *     // Scopes can be specified either as an array or as a single, space-delimited string.
     *     scopes: [
     *       'openid',
     *       'https://www.googleapis.com/auth/userinfo.email',
     *       'https://www.googleapis.com/auth/userinfo.profile',
     *     ],
     *   });
     *
     *   // Acquire an auth client, and bind it to all future calls
     *   const authClient = await auth.getClient();
     *   google.options({auth: authClient});
     *
     *   // Do the magic
     *   const res = await oauth2.userinfo.v2.me.get({});
     *   console.log(res.data);
     *
     *   // Example response
     *   // {
     *   //   "email": "my_email",
     *   //   "family_name": "my_family_name",
     *   //   "gender": "my_gender",
     *   //   "given_name": "my_given_name",
     *   //   "hd": "my_hd",
     *   //   "id": "my_id",
     *   //   "link": "my_link",
     *   //   "locale": "my_locale",
     *   //   "name": "my_name",
     *   //   "picture": "my_picture",
     *   //   "verified_email": false
     *   // }
     * }
     *
     * main().catch(e => {
     *   console.error(e);
     *   throw e;
     * });
     *
     * ```
     *
     * @param params - Parameters for request
     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
     * @param callback - Optional callback that handles the response.
     * @returns A promise if used with async/await, or void if used with a callback.
     */
    get(
      params: Params$Resource$Userinfo$V2$Me$Get,
      options: StreamMethodOptions
    ): GaxiosPromise<Readable>;
    get(
      params?: Params$Resource$Userinfo$V2$Me$Get,
      options?: MethodOptions
    ): GaxiosPromise<Schema$Userinfo>;
    get(
      params: Params$Resource$Userinfo$V2$Me$Get,
      options: StreamMethodOptions | BodyResponseCallback<Readable>,
      callback: BodyResponseCallback<Readable>
    ): void;
    get(
      params: Params$Resource$Userinfo$V2$Me$Get,
      options: MethodOptions | BodyResponseCallback<Schema$Userinfo>,
      callback: BodyResponseCallback<Schema$Userinfo>
    ): void;
    get(
      params: Params$Resource$Userinfo$V2$Me$Get,
      callback: BodyResponseCallback<Schema$Userinfo>
    ): void;
    get(callback: BodyResponseCallback<Schema$Userinfo>): void;
    get(
      paramsOrCallback?:
        | Params$Resource$Userinfo$V2$Me$Get
        | BodyResponseCallback<Schema$Userinfo>
        | BodyResponseCallback<Readable>,
      optionsOrCallback?:
        | MethodOptions
        | StreamMethodOptions
        | BodyResponseCallback<Schema$Userinfo>
        | BodyResponseCallback<Readable>,
      callback?:
        | BodyResponseCallback<Schema$Userinfo>
        | BodyResponseCallback<Readable>
    ): void | GaxiosPromise<Schema$Userinfo> | GaxiosPromise<Readable> {
      let params = (paramsOrCallback ||
        {}) as Params$Resource$Userinfo$V2$Me$Get;
      let options = (optionsOrCallback || {}) as MethodOptions;

      if (typeof paramsOrCallback === 'function') {
        callback = paramsOrCallback;
        params = {} as Params$Resource$Userinfo$V2$Me$Get;
        options = {};
      }

      if (typeof optionsOrCallback === 'function') {
        callback = optionsOrCallback;
        options = {};
      }

      const rootUrl = options.rootUrl || 'https://www.googleapis.com/';
      const parameters = {
        options: Object.assign(
          {
            url: (rootUrl + '/userinfo/v2/me').replace(/([^:]\/)\/+/g, '$1'),
            method: 'GET',
          },
          options
        ),
        params,
        requiredParams: [],
        pathParams: [],
        context: this.context,
      };
      if (callback) {
        createAPIRequest<Schema$Userinfo>(
          parameters,
          callback as BodyResponseCallback<unknown>
        );
      } else {
        return createAPIRequest<Schema$Userinfo>(parameters);
      }
    }
  }

  export interface Params$Resource$Userinfo$V2$Me$Get
    extends StandardParameters {}
}

result-matching ""

    No results matching ""