playwright-smart-test 0.0.0-stage → 1.0.2

package/node_modules/google-auth-library/build/src/auth/iam.d.ts

@@ -0,0 +1,23 @@
+export interface RequestMetadata {
+    'x-goog-iam-authority-selector': string;
+    'x-goog-iam-authorization-token': string;
+}
+export declare class IAMAuth {
+    selector: string;
+    token: string;
+    /**
+     * IAM credentials.
+     *
+     * @param selector the iam authority selector
+     * @param token the token
+     * @constructor
+     */
+    constructor(selector: string, token: string);
+    /**
+     * Acquire the HTTP headers required to make an authenticated request.
+     */
+    getRequestHeaders(): {
+        'x-goog-iam-authority-selector': string;
+        'x-goog-iam-authorization-token': string;
+    };
+}

package/node_modules/google-auth-library/build/src/auth/iam.js

@@ -0,0 +1,41 @@
+"use strict";
+// Copyright 2014 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IAMAuth = void 0;
+class IAMAuth {
+    /**
+     * IAM credentials.
+     *
+     * @param selector the iam authority selector
+     * @param token the token
+     * @constructor
+     */
+    constructor(selector, token) {
+        this.selector = selector;
+        this.token = token;
+        this.selector = selector;
+        this.token = token;
+    }
+    /**
+     * Acquire the HTTP headers required to make an authenticated request.
+     */
+    getRequestHeaders() {
+        return {
+            'x-goog-iam-authority-selector': this.selector,
+            'x-goog-iam-authorization-token': this.token,
+        };
+    }
+}
+exports.IAMAuth = IAMAuth;

package/node_modules/google-auth-library/build/src/auth/identitypoolclient.d.ts

@@ -0,0 +1,102 @@
+import { BaseExternalAccountClient, BaseExternalAccountClientOptions, ExternalAccountSupplierContext } from './baseexternalclient';
+import { AuthClientOptions } from './authclient';
+import { SnakeToCamelObject } from '../util';
+export type SubjectTokenFormatType = 'json' | 'text';
+export interface SubjectTokenJsonResponse {
+    [key: string]: string;
+}
+/**
+ * Supplier interface for subject tokens. This can be implemented to
+ * return a subject token which can then be exchanged for a GCP token by an
+ * {@link IdentityPoolClient}.
+ */
+export interface SubjectTokenSupplier {
+    /**
+     * Gets a valid subject token for the requested external account identity.
+     * Note that these are not cached by the calling {@link IdentityPoolClient},
+     * so caching should be including in the implementation.
+     * @param context {@link ExternalAccountSupplierContext} from the calling
+     *   {@link IdentityPoolClient}, contains the requested audience and subject token type
+     *   for the external account identity as well as the transport from the
+     *   calling client to use for requests.
+     * @return A promise that resolves with the requested subject token string.
+     */
+    getSubjectToken: (context: ExternalAccountSupplierContext) => Promise<string>;
+}
+/**
+ * Url-sourced/file-sourced credentials json interface.
+ * This is used for K8s and Azure workloads.
+ */
+export interface IdentityPoolClientOptions extends BaseExternalAccountClientOptions {
+    /**
+     * Object containing options to retrieve identity pool credentials. A valid credential
+     * source or a subject token supplier must be specified.
+     */
+    credential_source?: {
+        /**
+         * The file location to read the subject token from. Either this or a URL
+         * should be specified.
+         */
+        file?: string;
+        /**
+         * The URL to call to retrieve the subject token. Either this or a file
+         * location should be specified.
+         */
+        url?: string;
+        /**
+         * Optional headers to send on the request to the specified URL.
+         */
+        headers?: {
+            [key: string]: string;
+        };
+        /**
+         * The format that the subject token is in the file or the URL response.
+         * If not provided, will default to reading the text string directly.
+         */
+        format?: {
+            /**
+             * The format type. Can either be 'text' or 'json'.
+             */
+            type: SubjectTokenFormatType;
+            /**
+             * The field name containing the subject token value if the type is 'json'.
+             */
+            subject_token_field_name?: string;
+        };
+    };
+    /**
+     * The subject token supplier to call to retrieve the subject token to exchange
+     * for a GCP access token. Either this or a valid credential source should
+     * be specified.
+     */
+    subject_token_supplier?: SubjectTokenSupplier;
+}
+/**
+ * Defines the Url-sourced and file-sourced external account clients mainly
+ * used for K8s and Azure workloads.
+ */
+export declare class IdentityPoolClient extends BaseExternalAccountClient {
+    private readonly subjectTokenSupplier;
+    /**
+     * Instantiate an IdentityPoolClient instance using the provided JSON
+     * object loaded from an external account credentials file.
+     * An error is thrown if the credential is not a valid file-sourced or
+     * url-sourced credential or a workforce pool user project is provided
+     * with a non workforce audience.
+     * @param options The external account options object typically loaded
+     *   from the external account JSON credential file. The camelCased options
+     *   are aliases for the snake_cased options.
+     * @param additionalOptions **DEPRECATED, all options are available in the
+     *   `options` parameter.** Optional additional behavior customization options.
+     *   These currently customize expiration threshold time and whether to retry
+     *   on 401/403 API request errors.
+     */
+    constructor(options: IdentityPoolClientOptions | SnakeToCamelObject<IdentityPoolClientOptions>, additionalOptions?: AuthClientOptions);
+    /**
+     * Triggered when a external subject token is needed to be exchanged for a GCP
+     * access token via GCP STS endpoint. Gets a subject token by calling
+     * the configured {@link SubjectTokenSupplier}
+     * @return A promise that resolves with the external subject token.
+     */
+    retrieveSubjectToken(): Promise<string>;
+}

package/node_modules/google-auth-library/build/src/auth/identitypoolclient.js

@@ -0,0 +1,107 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityPoolClient = void 0;
+const baseexternalclient_1 = require("./baseexternalclient");
+const util_1 = require("../util");
+const filesubjecttokensupplier_1 = require("./filesubjecttokensupplier");
+const urlsubjecttokensupplier_1 = require("./urlsubjecttokensupplier");
+/**
+ * Defines the Url-sourced and file-sourced external account clients mainly
+ * used for K8s and Azure workloads.
+ */
+class IdentityPoolClient extends baseexternalclient_1.BaseExternalAccountClient {
+    /**
+     * Instantiate an IdentityPoolClient instance using the provided JSON
+     * object loaded from an external account credentials file.
+     * An error is thrown if the credential is not a valid file-sourced or
+     * url-sourced credential or a workforce pool user project is provided
+     * with a non workforce audience.
+     * @param options The external account options object typically loaded
+     *   from the external account JSON credential file. The camelCased options
+     *   are aliases for the snake_cased options.
+     * @param additionalOptions **DEPRECATED, all options are available in the
+     *   `options` parameter.** Optional additional behavior customization options.
+     *   These currently customize expiration threshold time and whether to retry
+     *   on 401/403 API request errors.
+     */
+    constructor(options, additionalOptions) {
+        super(options, additionalOptions);
+        const opts = (0, util_1.originalOrCamelOptions)(options);
+        const credentialSource = opts.get('credential_source');
+        const subjectTokenSupplier = opts.get('subject_token_supplier');
+        // Validate credential sourcing configuration.
+        if (!credentialSource && !subjectTokenSupplier) {
+            throw new Error('A credential source or subject token supplier must be specified.');
+        }
+        if (credentialSource && subjectTokenSupplier) {
+            throw new Error('Only one of credential source or subject token supplier can be specified.');
+        }
+        if (subjectTokenSupplier) {
+            this.subjectTokenSupplier = subjectTokenSupplier;
+            this.credentialSourceType = 'programmatic';
+        }
+        else {
+            const credentialSourceOpts = (0, util_1.originalOrCamelOptions)(credentialSource);
+            const formatOpts = (0, util_1.originalOrCamelOptions)(credentialSourceOpts.get('format'));
+            // Text is the default format type.
+            const formatType = formatOpts.get('type') || 'text';
+            const formatSubjectTokenFieldName = formatOpts.get('subject_token_field_name');
+            if (formatType !== 'json' && formatType !== 'text') {
+                throw new Error(`Invalid credential_source format "${formatType}"`);
+            }
+            if (formatType === 'json' && !formatSubjectTokenFieldName) {
+                throw new Error('Missing subject_token_field_name for JSON credential_source format');
+            }
+            const file = credentialSourceOpts.get('file');
+            const url = credentialSourceOpts.get('url');
+            const headers = credentialSourceOpts.get('headers');
+            if (file && url) {
+                throw new Error('No valid Identity Pool "credential_source" provided, must be either file or url.');
+            }
+            else if (file && !url) {
+                this.credentialSourceType = 'file';
+                this.subjectTokenSupplier = new filesubjecttokensupplier_1.FileSubjectTokenSupplier({
+                    filePath: file,
+                    formatType: formatType,
+                    subjectTokenFieldName: formatSubjectTokenFieldName,
+                });
+            }
+            else if (!file && url) {
+                this.credentialSourceType = 'url';
+                this.subjectTokenSupplier = new urlsubjecttokensupplier_1.UrlSubjectTokenSupplier({
+                    url: url,
+                    formatType: formatType,
+                    subjectTokenFieldName: formatSubjectTokenFieldName,
+                    headers: headers,
+                    additionalGaxiosOptions: IdentityPoolClient.RETRY_CONFIG,
+                });
+            }
+            else {
+                throw new Error('No valid Identity Pool "credential_source" provided, must be either file or url.');
+            }
+        }
+    }
+    /**
+     * Triggered when a external subject token is needed to be exchanged for a GCP
+     * access token via GCP STS endpoint. Gets a subject token by calling
+     * the configured {@link SubjectTokenSupplier}
+     * @return A promise that resolves with the external subject token.
+     */
+    async retrieveSubjectToken() {
+        return this.subjectTokenSupplier.getSubjectToken(this.supplierContext);
+    }
+}
+exports.IdentityPoolClient = IdentityPoolClient;

package/node_modules/google-auth-library/build/src/auth/idtokenclient.d.ts

@@ -0,0 +1,27 @@
+import { OAuth2Client, OAuth2ClientOptions, RequestMetadataResponse } from './oauth2client';
+export interface IdTokenOptions extends OAuth2ClientOptions {
+    /**
+     * The client to make the request to fetch an ID token.
+     */
+    idTokenProvider: IdTokenProvider;
+    /**
+     * The audience to use when requesting an ID token.
+     */
+    targetAudience: string;
+}
+export interface IdTokenProvider {
+    fetchIdToken: (targetAudience: string) => Promise<string>;
+}
+export declare class IdTokenClient extends OAuth2Client {
+    targetAudience: string;
+    idTokenProvider: IdTokenProvider;
+    /**
+     * Google ID Token client
+     *
+     * Retrieve ID token from the metadata server.
+     * See: https://cloud.google.com/docs/authentication/get-id-token#metadata-server
+     */
+    constructor(options: IdTokenOptions);
+    protected getRequestMetadataAsync(url?: string | null): Promise<RequestMetadataResponse>;
+    private getIdTokenExpiryDate;
+}

package/node_modules/google-auth-library/build/src/auth/idtokenclient.js

@@ -0,0 +1,55 @@
+"use strict";
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdTokenClient = void 0;
+const oauth2client_1 = require("./oauth2client");
+class IdTokenClient extends oauth2client_1.OAuth2Client {
+    /**
+     * Google ID Token client
+     *
+     * Retrieve ID token from the metadata server.
+     * See: https://cloud.google.com/docs/authentication/get-id-token#metadata-server
+     */
+    constructor(options) {
+        super(options);
+        this.targetAudience = options.targetAudience;
+        this.idTokenProvider = options.idTokenProvider;
+    }
+    async getRequestMetadataAsync(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    url) {
+        if (!this.credentials.id_token ||
+            !this.credentials.expiry_date ||
+            this.isTokenExpiring()) {
+            const idToken = await this.idTokenProvider.fetchIdToken(this.targetAudience);
+            this.credentials = {
+                id_token: idToken,
+                expiry_date: this.getIdTokenExpiryDate(idToken),
+            };
+        }
+        const headers = {
+            Authorization: 'Bearer ' + this.credentials.id_token,
+        };
+        return { headers };
+    }
+    getIdTokenExpiryDate(idToken) {
+        const payloadB64 = idToken.split('.')[1];
+        if (payloadB64) {
+            const payload = JSON.parse(Buffer.from(payloadB64, 'base64').toString('ascii'));
+            return payload.exp * 1000;
+        }
+    }
+}
+exports.IdTokenClient = IdTokenClient;

package/node_modules/google-auth-library/build/src/auth/impersonated.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { GetTokenResponse, OAuth2Client, OAuth2ClientOptions } from './oauth2client';
+import { AuthClient } from './authclient';
+import { IdTokenProvider } from './idtokenclient';
+import { SignBlobResponse } from './googleauth';
+export interface ImpersonatedOptions extends OAuth2ClientOptions {
+    /**
+     * Client used to perform exchange for impersonated client.
+     */
+    sourceClient?: AuthClient;
+    /**
+     * The service account to impersonate.
+     */
+    targetPrincipal?: string;
+    /**
+     * Scopes to request during the authorization grant.
+     */
+    targetScopes?: string[];
+    /**
+     * The chained list of delegates required to grant the final access_token.
+     */
+    delegates?: string[];
+    /**
+     * Number of seconds the delegated credential should be valid.
+     */
+    lifetime?: number | 3600;
+    /**
+     * API endpoint to fetch token from.
+     */
+    endpoint?: string;
+}
+export declare const IMPERSONATED_ACCOUNT_TYPE = "impersonated_service_account";
+export interface TokenResponse {
+    accessToken: string;
+    expireTime: string;
+}
+export interface FetchIdTokenOptions {
+    /**
+     * Include the service account email in the token.
+     * If set to `true`, the token will contain `email` and `email_verified` claims.
+     */
+    includeEmail: boolean;
+}
+export interface FetchIdTokenResponse {
+    /** The OpenId Connect ID token. */
+    token: string;
+}
+export declare class Impersonated extends OAuth2Client implements IdTokenProvider {
+    private sourceClient;
+    private targetPrincipal;
+    private targetScopes;
+    private delegates;
+    private lifetime;
+    private endpoint;
+    /**
+     * Impersonated service account credentials.
+     *
+     * Create a new access token by impersonating another service account.
+     *
+     * Impersonated Credentials allowing credentials issued to a user or
+     * service account to impersonate another. The source project using
+     * Impersonated Credentials must enable the "IAMCredentials" API.
+     * Also, the target service account must grant the orginating principal
+     * the "Service Account Token Creator" IAM role.
+     *
+     * @param {object} options - The configuration object.
+     * @param {object} [options.sourceClient] the source credential used as to
+     * acquire the impersonated credentials.
+     * @param {string} [options.targetPrincipal] the service account to
+     * impersonate.
+     * @param {string[]} [options.delegates] the chained list of delegates
+     * required to grant the final access_token. If set, the sequence of
+     * identities must have "Service Account Token Creator" capability granted to
+     * the preceding identity. For example, if set to [serviceAccountB,
+     * serviceAccountC], the sourceCredential must have the Token Creator role on
+     * serviceAccountB. serviceAccountB must have the Token Creator on
+     * serviceAccountC. Finally, C must have Token Creator on target_principal.
+     * If left unset, sourceCredential must have that role on targetPrincipal.
+     * @param {string[]} [options.targetScopes] scopes to request during the
+     * authorization grant.
+     * @param {number} [options.lifetime] number of seconds the delegated
+     * credential should be valid for up to 3600 seconds by default, or 43,200
+     * seconds by extending the token's lifetime, see:
+     * https://cloud.google.com/iam/docs/creating-short-lived-service-account-credentials#sa-credentials-oauth
+     * @param {string} [options.endpoint] api endpoint override.
+     */
+    constructor(options?: ImpersonatedOptions);
+    /**
+     * Signs some bytes.
+     *
+     * {@link https://cloud.google.com/iam/docs/reference/credentials/rest/v1/projects.serviceAccounts/signBlob Reference Documentation}
+     * @param blobToSign String to sign.
+     *
+     * @returns A {@link SignBlobResponse} denoting the keyID and signedBlob in base64 string
+     */
+    sign(blobToSign: string): Promise<SignBlobResponse>;
+    /** The service account email to be impersonated. */
+    getTargetPrincipal(): string;
+    /**
+     * Refreshes the access token.
+     */
+    protected refreshToken(): Promise<GetTokenResponse>;
+    /**
+     * Generates an OpenID Connect ID token for a service account.
+     *
+     * {@link https://cloud.google.com/iam/docs/reference/credentials/rest/v1/projects.serviceAccounts/generateIdToken Reference Documentation}
+     *
+     * @param targetAudience the audience for the fetched ID token.
+     * @param options the for the request
+     * @return an OpenID Connect ID token
+     */
+    fetchIdToken(targetAudience: string, options?: FetchIdTokenOptions): Promise<string>;
+}

package/node_modules/google-auth-library/build/src/auth/impersonated.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Impersonated = exports.IMPERSONATED_ACCOUNT_TYPE = void 0;
+const oauth2client_1 = require("./oauth2client");
+const gaxios_1 = require("gaxios");
+const util_1 = require("../util");
+exports.IMPERSONATED_ACCOUNT_TYPE = 'impersonated_service_account';
+class Impersonated extends oauth2client_1.OAuth2Client {
+    /**
+     * Impersonated service account credentials.
+     *
+     * Create a new access token by impersonating another service account.
+     *
+     * Impersonated Credentials allowing credentials issued to a user or
+     * service account to impersonate another. The source project using
+     * Impersonated Credentials must enable the "IAMCredentials" API.
+     * Also, the target service account must grant the orginating principal
+     * the "Service Account Token Creator" IAM role.
+     *
+     * @param {object} options - The configuration object.
+     * @param {object} [options.sourceClient] the source credential used as to
+     * acquire the impersonated credentials.
+     * @param {string} [options.targetPrincipal] the service account to
+     * impersonate.
+     * @param {string[]} [options.delegates] the chained list of delegates
+     * required to grant the final access_token. If set, the sequence of
+     * identities must have "Service Account Token Creator" capability granted to
+     * the preceding identity. For example, if set to [serviceAccountB,
+     * serviceAccountC], the sourceCredential must have the Token Creator role on
+     * serviceAccountB. serviceAccountB must have the Token Creator on
+     * serviceAccountC. Finally, C must have Token Creator on target_principal.
+     * If left unset, sourceCredential must have that role on targetPrincipal.
+     * @param {string[]} [options.targetScopes] scopes to request during the
+     * authorization grant.
+     * @param {number} [options.lifetime] number of seconds the delegated
+     * credential should be valid for up to 3600 seconds by default, or 43,200
+     * seconds by extending the token's lifetime, see:
+     * https://cloud.google.com/iam/docs/creating-short-lived-service-account-credentials#sa-credentials-oauth
+     * @param {string} [options.endpoint] api endpoint override.
+     */
+    constructor(options = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        super(options);
+        // Start with an expired refresh token, which will automatically be
+        // refreshed before the first API call is made.
+        this.credentials = {
+            expiry_date: 1,
+            refresh_token: 'impersonated-placeholder',
+        };
+        this.sourceClient = (_a = options.sourceClient) !== null && _a !== void 0 ? _a : new oauth2client_1.OAuth2Client();
+        this.targetPrincipal = (_b = options.targetPrincipal) !== null && _b !== void 0 ? _b : '';
+        this.delegates = (_c = options.delegates) !== null && _c !== void 0 ? _c : [];
+        this.targetScopes = (_d = options.targetScopes) !== null && _d !== void 0 ? _d : [];
+        this.lifetime = (_e = options.lifetime) !== null && _e !== void 0 ? _e : 3600;
+        const usingExplicitUniverseDomain = !!(0, util_1.originalOrCamelOptions)(options).get('universe_domain');
+        if (!usingExplicitUniverseDomain) {
+            // override the default universe with the source's universe
+            this.universeDomain = this.sourceClient.universeDomain;
+        }
+        else if (this.sourceClient.universeDomain !== this.universeDomain) {
+            // non-default universe and is not matching the source - this could be a credential leak
+            throw new RangeError(`Universe domain ${this.sourceClient.universeDomain} in source credentials does not match ${this.universeDomain} universe domain set for impersonated credentials.`);
+        }
+        this.endpoint =
+            (_f = options.endpoint) !== null && _f !== void 0 ? _f : `https://iamcredentials.${this.universeDomain}`;
+    }
+    /**
+     * Signs some bytes.
+     *
+     * {@link https://cloud.google.com/iam/docs/reference/credentials/rest/v1/projects.serviceAccounts/signBlob Reference Documentation}
+     * @param blobToSign String to sign.
+     *
+     * @returns A {@link SignBlobResponse} denoting the keyID and signedBlob in base64 string
+     */
+    async sign(blobToSign) {
+        await this.sourceClient.getAccessToken();
+        const name = `projects/-/serviceAccounts/${this.targetPrincipal}`;
+        const u = `${this.endpoint}/v1/${name}:signBlob`;
+        const body = {
+            delegates: this.delegates,
+            payload: Buffer.from(blobToSign).toString('base64'),
+        };
+        const res = await this.sourceClient.request({
+            ...Impersonated.RETRY_CONFIG,
+            url: u,
+            data: body,
+            method: 'POST',
+        });
+        return res.data;
+    }
+    /** The service account email to be impersonated. */
+    getTargetPrincipal() {
+        return this.targetPrincipal;
+    }
+    /**
+     * Refreshes the access token.
+     */
+    async refreshToken() {
+        var _a, _b, _c, _d, _e, _f;
+        try {
+            await this.sourceClient.getAccessToken();
+            const name = 'projects/-/serviceAccounts/' + this.targetPrincipal;
+            const u = `${this.endpoint}/v1/${name}:generateAccessToken`;
+            const body = {
+                delegates: this.delegates,
+                scope: this.targetScopes,
+                lifetime: this.lifetime + 's',
+            };
+            const res = await this.sourceClient.request({
+                ...Impersonated.RETRY_CONFIG,
+                url: u,
+                data: body,
+                method: 'POST',
+            });
+            const tokenResponse = res.data;
+            this.credentials.access_token = tokenResponse.accessToken;
+            this.credentials.expiry_date = Date.parse(tokenResponse.expireTime);
+            return {
+                tokens: this.credentials,
+                res,
+            };
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+            let status = 0;
+            let message = '';
+            if (error instanceof gaxios_1.GaxiosError) {
+                status = (_c = (_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.status;
+                message = (_f = (_e = (_d = error === null || error === void 0 ? void 0 : error.response) === null || _d === void 0 ? void 0 : _d.data) === null || _e === void 0 ? void 0 : _e.error) === null || _f === void 0 ? void 0 : _f.message;
+            }
+            if (status && message) {
+                error.message = `${status}: unable to impersonate: ${message}`;
+                throw error;
+            }
+            else {
+                error.message = `unable to impersonate: ${error}`;
+                throw error;
+            }
+        }
+    }
+    /**
+     * Generates an OpenID Connect ID token for a service account.
+     *
+     * {@link https://cloud.google.com/iam/docs/reference/credentials/rest/v1/projects.serviceAccounts/generateIdToken Reference Documentation}
+     *
+     * @param targetAudience the audience for the fetched ID token.
+     * @param options the for the request
+     * @return an OpenID Connect ID token
+     */
+    async fetchIdToken(targetAudience, options) {
+        var _a, _b;
+        await this.sourceClient.getAccessToken();
+        const name = `projects/-/serviceAccounts/${this.targetPrincipal}`;
+        const u = `${this.endpoint}/v1/${name}:generateIdToken`;
+        const body = {
+            delegates: this.delegates,
+            audience: targetAudience,
+            includeEmail: (_a = options === null || options === void 0 ? void 0 : options.includeEmail) !== null && _a !== void 0 ? _a : true,
+            useEmailAzp: (_b = options === null || options === void 0 ? void 0 : options.includeEmail) !== null && _b !== void 0 ? _b : true,
+        };
+        const res = await this.sourceClient.request({
+            ...Impersonated.RETRY_CONFIG,
+            url: u,
+            data: body,
+            method: 'POST',
+        });
+        return res.data.token;
+    }
+}
+exports.Impersonated = Impersonated;