auth0 6.4.0 → 7.1.0

package/dist/esm/auth/oauth.mjs

@@ -1,276 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { JSONApiResponse, VoidApiResponse, validateRequiredRequestParams } from "../lib/runtime.mjs";
-import { BaseAuthAPI, grant } from "./base-auth-api.mjs";
-import { IDTokenValidator } from "./id-token-validator.mjs";
-import { mtlsPrefix } from "../utils.mjs";
-export var SUBJECT_TOKEN_TYPES;
-(function (SUBJECT_TOKEN_TYPES) {
-    /**
-     * Constant representing the subject type for a refresh token.
-     * This is used in OAuth 2.0 token exchange to specify that the token being exchanged is a refresh token.
-     *
-     * @see {@link https://tools.ietf.org/html/rfc8693#section-3.1 RFC 8693 Section 3.1}
-     */
-    SUBJECT_TOKEN_TYPES["REFRESH_TOKEN"] = "urn:ietf:params:oauth:token-type:refresh_token";
-    /**
-     * Constant representing the subject type for a access token.
-     * This is used in OAuth 2.0 token exchange to specify that the token being exchanged is an access token.
-     *
-     * @see {@link https://tools.ietf.org/html/rfc8693#section-3.1 RFC 8693 Section 3.1}
-     */
-    SUBJECT_TOKEN_TYPES["ACCESS_TOKEN"] = "urn:ietf:params:oauth:token-type:access_token";
-})(SUBJECT_TOKEN_TYPES || (SUBJECT_TOKEN_TYPES = {}));
-export const TOKEN_FOR_CONNECTION_GRANT_TYPE = "urn:auth0:params:oauth:grant-type:token-exchange:federated-connection-access-token";
-/**
- * @deprecated Use {@link SUBJECT_TOKEN_TYPES.REFRESH_TOKEN} instead.
- */
-export const TOKEN_FOR_CONNECTION_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:refresh_token";
-export const TOKEN_FOR_CONNECTION_REQUESTED_TOKEN_TYPE = "http://auth0.com/oauth/token-type/federated-connection-access-token";
-export const TOKEN_URL = "/oauth/token";
-/**
- *  OAuth 2.0 flows.
- */
-export class OAuth extends BaseAuthAPI {
-    constructor(options) {
-        super(Object.assign(Object.assign({}, options), { domain: options.useMTLS ? `${mtlsPrefix}.${options.domain}` : options.domain }));
-        this.idTokenValidator = new IDTokenValidator(options);
-    }
-    /**
-     * This is the flow that regular web apps use to access an API.
-     *
-     * Use this endpoint to exchange an Authorization Code for a Token.
-     *
-     * See: https://auth0.com/docs/api/authentication#authorization-code-flow44
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId',
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.oauth.authorizationCodeGrant({ code: 'mycode' });
-     * ```
-     */
-    authorizationCodeGrant(bodyParameters_1) {
-        return __awaiter(this, arguments, void 0, function* (bodyParameters, options = {}) {
-            validateRequiredRequestParams(bodyParameters, ["code"]);
-            return grant("authorization_code", yield this.addClientAuthentication(bodyParameters), options, this.clientId, this.idTokenValidator, this.request.bind(this));
-        });
-    }
-    /**
-     * PKCE was originally designed to protect the authorization code flow in mobile apps,
-     * but its ability to prevent authorization code injection makes it useful for every type of OAuth client,
-     * even web apps that use client authentication.
-     *
-     * See: https://auth0.com/docs/api/authentication#authorization-code-flow-with-pkce45
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId',
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.oauth.authorizationCodeGrantWithPKCE({
-     *   code: 'mycode',
-     *   code_verifier: 'mycodeverifier'
-     * });
-     * ```
-     */
-    authorizationCodeGrantWithPKCE(bodyParameters_1) {
-        return __awaiter(this, arguments, void 0, function* (bodyParameters, options = {}) {
-            validateRequiredRequestParams(bodyParameters, ["code", "code_verifier"]);
-            return grant("authorization_code", yield this.addClientAuthentication(bodyParameters), options, this.clientId, this.idTokenValidator, this.request.bind(this));
-        });
-    }
-    /**
-     * This is the OAuth 2.0 grant that server processes use to access an API.
-     *
-     * Use this endpoint to directly request an Access Token by using the Client's credentials
-     * (a Client ID and a Client Secret or a Client Assertion).
-     *
-     * See: https://auth0.com/docs/api/authentication#client-credentials-flow
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId',
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.oauth.clientCredentialsGrant({ audience: 'myaudience' });
-     * ```
-     */
-    clientCredentialsGrant(bodyParameters_1) {
-        return __awaiter(this, arguments, void 0, function* (bodyParameters, options = {}) {
-            validateRequiredRequestParams(bodyParameters, ["audience"]);
-            return grant("client_credentials", yield this.addClientAuthentication(bodyParameters), options, this.clientId, this.idTokenValidator, this.request.bind(this));
-        });
-    }
-    /**
-     * This is the OAuth 2.0 extension that allows to initiate an OAuth flow from the backchannel instead of by building a URL.
-     *
-     *
-     * See: https://www.rfc-editor.org/rfc/rfc9126.html
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId',
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.oauth.pushedAuthorization({ response_type: 'id_token', redirect_uri: 'http://localhost' });
-     * ```
-     */
-    pushedAuthorization(bodyParameters_1) {
-        return __awaiter(this, arguments, void 0, function* (bodyParameters, options = {}) {
-            validateRequiredRequestParams(bodyParameters, ["client_id", "response_type", "redirect_uri"]);
-            const bodyParametersWithClientAuthentication = yield this.addClientAuthentication(bodyParameters);
-            const response = yield this.request({
-                path: "/oauth/par",
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/x-www-form-urlencoded",
-                },
-                body: new URLSearchParams(Object.assign({ client_id: this.clientId }, bodyParametersWithClientAuthentication)),
-            }, options.initOverrides);
-            return JSONApiResponse.fromResponse(response);
-        });
-    }
-    /**
-     * This information is typically received from a highly trusted public client like a SPA*.
-     * (<strong>*Note:</string> For single-page applications and native/mobile apps, we recommend using web flows instead.)
-     *
-     * See: https://auth0.com/docs/api/authentication#resource-owner-password
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId'
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.oauth.passwordGrant({
-     *     username: 'myusername@example.com',
-     *     password: 'mypassword'
-     *   },
-     *   { initOverrides: { headers: { 'auth0-forwarded-for': 'END.USER.IP.123' } } }
-     * );
-     * ```
-     *
-     * Set the'auth0-forwarded-for' header to the end-user IP as a string value if you want
-     * brute-force protection to work in server-side scenarios.
-     *
-     * See https://auth0.com/docs/get-started/authentication-and-authorization-flow/avoid-common-issues-with-resource-owner-password-flow-and-attack-protection
-     *
-     */
-    passwordGrant(bodyParameters_1) {
-        return __awaiter(this, arguments, void 0, function* (bodyParameters, options = {}) {
-            validateRequiredRequestParams(bodyParameters, ["username", "password"]);
-            return grant(bodyParameters.realm ? "http://auth0.com/oauth/grant-type/password-realm" : "password", yield this.addClientAuthentication(bodyParameters), options, this.clientId, this.idTokenValidator, this.request.bind(this));
-        });
-    }
-    /**
-     * Use this endpoint to refresh an Access Token using the Refresh Token you got during authorization.
-     *
-     * See: https://auth0.com/docs/api/authentication#refresh-token
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId'
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.oauth.refreshTokenGrant({ refresh_token: 'myrefreshtoken' })
-     * ```
-     */
-    refreshTokenGrant(bodyParameters_1) {
-        return __awaiter(this, arguments, void 0, function* (bodyParameters, options = {}) {
-            validateRequiredRequestParams(bodyParameters, ["refresh_token"]);
-            return grant("refresh_token", yield this.addClientAuthentication(bodyParameters), options, this.clientId, this.idTokenValidator, this.request.bind(this));
-        });
-    }
-    /**
-     * Use this endpoint to invalidate a Refresh Token if it has been compromised.
-     *
-     * The behaviour of this endpoint depends on the state of the <a href="https://auth0.com/docs/secure/tokens/refresh-tokens/revoke-refresh-tokens#refresh-tokens-and-grants">Refresh Token Revocation Deletes Grant</a> toggle.
-     * If this toggle is enabled, then each revocation request invalidates not only the specific token, but all other tokens based on the same authorization grant.
-     * This means that all Refresh Tokens that have been issued for the same user, application, and audience will be revoked.
-     * If this toggle is disabled, then only the refresh token is revoked, while the grant is left intact.
-     *
-     * See: https://auth0.com/docs/api/authentication#revoke-refresh-token
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId'
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.oauth.revokeRefreshToken({ token: 'myrefreshtoken' })
-     * ```
-     */
-    revokeRefreshToken(bodyParameters_1) {
-        return __awaiter(this, arguments, void 0, function* (bodyParameters, options = {}) {
-            validateRequiredRequestParams(bodyParameters, ["token"]);
-            const response = yield this.request({
-                path: "/oauth/revoke",
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                },
-                body: yield this.addClientAuthentication(Object.assign({ client_id: this.clientId }, bodyParameters)),
-            }, options.initOverrides);
-            return VoidApiResponse.fromResponse(response);
-        });
-    }
-    /**
-     * Exchanges a subject token for an access token for the connection.
-     *
-     * The request body includes:
-     * - client_id (and client_secret/client_assertion via addClientAuthentication)
-     * - grant_type set to `urn:auth0:params:oauth:grant-type:token-exchange:federated-connection-access-token`
-     * - subject_token: the token to exchange
-     * - subject_token_type: the type of token being exchanged. Defaults to refresh tokens (`urn:ietf:params:oauth:token-type:refresh_token`).
-     * - requested_token_type (`http://auth0.com/oauth/token-type/federated-connection-access-token`) indicating that a federated connection access token is desired
-     * - connection name and an optional `login_hint` if provided
-     *
-     * @param bodyParameters - The options to retrieve a token for a connection.
-     * @returns A promise with the token response data.
-     * @throws An error if the exchange fails.
-     */
-    tokenForConnection(bodyParameters_1) {
-        return __awaiter(this, arguments, void 0, function* (bodyParameters, options = {}) {
-            validateRequiredRequestParams(bodyParameters, ["connection", "subject_token"]);
-            const body = Object.assign(Object.assign({ subject_token_type: SUBJECT_TOKEN_TYPES.REFRESH_TOKEN }, bodyParameters), { grant_type: TOKEN_FOR_CONNECTION_GRANT_TYPE, requested_token_type: TOKEN_FOR_CONNECTION_REQUESTED_TOKEN_TYPE });
-            yield this.addClientAuthentication(body);
-            const response = yield this.request({
-                path: TOKEN_URL,
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/x-www-form-urlencoded",
-                },
-                body: new URLSearchParams(body),
-            }, options.initOverrides);
-            return JSONApiResponse.fromResponse(response);
-        });
-    }
-}

package/dist/esm/auth/passwordless.d.mts

@@ -1,165 +0,0 @@
-import { InitOverride, JSONApiResponse, VoidApiResponse } from "../lib/runtime.mjs";
-import { BaseAuthAPI, AuthenticationClientOptions } from "./base-auth-api.mjs";
-import { ClientCredentials, GrantOptions, TokenSet } from "./oauth.mjs";
-export interface SendEmailLinkRequest {
-    /**
-     * The user's email address
-     */
-    email: string;
-    /**
-     * Use `link` to send a link or `code` to send a verification code.
-     * If omitted, a `link` will be sent.
-     */
-    send?: "link";
-    /**
-     * Append or override the link parameters (like `scope`, `redirect_uri`, `protocol`, `response_type`),
-     * when you send a link using email.
-     */
-    authParams?: Record<string, unknown>;
-}
-export interface SendEmailCodeRequest {
-    /**
-     * The user's email address
-     */
-    email: string;
-    /**
-     * Use `link` to send a link or `code` to send a verification code.
-     * If omitted, a `link` will be sent.
-     */
-    send?: "code";
-}
-export type SendEmailRequest = SendEmailLinkRequest | SendEmailCodeRequest;
-export interface SendSmsRequest {
-    /**
-     * The users phone number.
-     */
-    phone_number: string;
-}
-export interface LoginWithEmailRequest extends ClientCredentials {
-    /**
-     * The user's email address.
-     */
-    email: string;
-    /**
-     * The user's verification code.
-     */
-    code: string;
-    /**
-     * API Identifier of the API for which you want to get an Access Token.
-     */
-    audience?: string;
-    /**
-     * Use openid to get an ID Token, or openid profile email to also include user profile information in the ID Token.
-     */
-    scope?: string;
-}
-export interface LoginWithSMSRequest extends Omit<LoginWithEmailRequest, "email"> {
-    /**
-     * The user's phone number.
-     */
-    phone_number: string;
-}
-/**
- * Handles passwordless flows using Email and SMS.
- */
-export declare class Passwordless extends BaseAuthAPI {
-    private idTokenValidator;
-    constructor(configuration: AuthenticationClientOptions);
-    /**
-     * Start passwordless flow sending an email.
-     *
-     * Given the user `email` address, it will send an email with:
-     *
-     * <ul>
-     *   <li>A link (default, `send:"link"`). You can then authenticate with this
-     *     user opening the link and he will be automatically logged in to the
-     *     application. Optionally, you can append/override parameters to the link
-     *     (like `scope`, `redirect_uri`, `protocol`, `response_type`, etc.) using
-     *     `authParams` object.
-     *   </li>
-     *   <li>
-     *     A verification code (`send:"code"`). You can then authenticate with
-     *     this user using the `/oauth/token` endpoint specifying `email` as
-     *     `username` and `code` as `password`.
-     *   </li>
-     * </ul>
-     *
-     * See: https://auth0.com/docs/api/authentication#get-code-or-link
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId',
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.passwordless.sendEmail({
-     *   email: '{EMAIL}',
-     *   send: 'link',
-     *   authParams: {} // Optional auth params.
-     * });
-     * ```
-     */
-    sendEmail(bodyParameters: SendEmailRequest, initOverrides?: InitOverride): Promise<VoidApiResponse>;
-    /**
-     * Start passwordless flow sending an SMS.
-     *
-     * Given the user `phone_number`, it will send a SMS message with a
-     * verification code. You can then authenticate with this user using the
-     * `/oauth/token` endpoint specifying `phone_number` as `username` and `code` as
-     * `password`:
-     *
-     * See: https://auth0.com/docs/api/authentication#get-code-or-link
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId',
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.passwordless.sendSMS({
-     *   phone_number: '{PHONE}'
-     * });
-     * ```
-     */
-    sendSMS(bodyParameters: SendSmsRequest, initOverrides?: InitOverride): Promise<VoidApiResponse>;
-    /**
-     * Once you have a verification code, use this endpoint to login the user with their email and verification code.
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId',
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.passwordless.loginWithEmail({
-     *   email: 'foo@example.com',
-     *   code: 'ABC123'
-     * });
-     * ```
-     */
-    loginWithEmail(bodyParameters: LoginWithEmailRequest, options?: GrantOptions): Promise<JSONApiResponse<TokenSet>>;
-    /**
-     * Once you have a verification code, use this endpoint to login the user with their phone number and verification code.
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId',
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.passwordless.loginWithSMS({
-     *   phone_number: '0777777777',
-     *   code: 'ABC123'
-     * });
-     * ```
-     */
-    loginWithSMS(bodyParameters: LoginWithSMSRequest, options?: GrantOptions): Promise<JSONApiResponse<TokenSet>>;
-}

package/dist/esm/auth/passwordless.mjs

@@ -1,169 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { VoidApiResponse, validateRequiredRequestParams } from "../lib/runtime.mjs";
-import { BaseAuthAPI, grant } from "./base-auth-api.mjs";
-import { IDTokenValidator } from "./id-token-validator.mjs";
-/**
- * Handles passwordless flows using Email and SMS.
- */
-export class Passwordless extends BaseAuthAPI {
-    constructor(configuration) {
-        super(configuration);
-        this.idTokenValidator = new IDTokenValidator(configuration);
-    }
-    /**
-     * Start passwordless flow sending an email.
-     *
-     * Given the user `email` address, it will send an email with:
-     *
-     * <ul>
-     *   <li>A link (default, `send:"link"`). You can then authenticate with this
-     *     user opening the link and he will be automatically logged in to the
-     *     application. Optionally, you can append/override parameters to the link
-     *     (like `scope`, `redirect_uri`, `protocol`, `response_type`, etc.) using
-     *     `authParams` object.
-     *   </li>
-     *   <li>
-     *     A verification code (`send:"code"`). You can then authenticate with
-     *     this user using the `/oauth/token` endpoint specifying `email` as
-     *     `username` and `code` as `password`.
-     *   </li>
-     * </ul>
-     *
-     * See: https://auth0.com/docs/api/authentication#get-code-or-link
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId',
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.passwordless.sendEmail({
-     *   email: '{EMAIL}',
-     *   send: 'link',
-     *   authParams: {} // Optional auth params.
-     * });
-     * ```
-     */
-    sendEmail(bodyParameters, initOverrides) {
-        return __awaiter(this, void 0, void 0, function* () {
-            validateRequiredRequestParams(bodyParameters, ["email"]);
-            const response = yield this.request({
-                path: "/passwordless/start",
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                },
-                body: yield this.addClientAuthentication(Object.assign({ client_id: this.clientId, connection: "email" }, bodyParameters)),
-            }, initOverrides);
-            return VoidApiResponse.fromResponse(response);
-        });
-    }
-    /**
-     * Start passwordless flow sending an SMS.
-     *
-     * Given the user `phone_number`, it will send a SMS message with a
-     * verification code. You can then authenticate with this user using the
-     * `/oauth/token` endpoint specifying `phone_number` as `username` and `code` as
-     * `password`:
-     *
-     * See: https://auth0.com/docs/api/authentication#get-code-or-link
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId',
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.passwordless.sendSMS({
-     *   phone_number: '{PHONE}'
-     * });
-     * ```
-     */
-    sendSMS(bodyParameters, initOverrides) {
-        return __awaiter(this, void 0, void 0, function* () {
-            validateRequiredRequestParams(bodyParameters, ["phone_number"]);
-            const response = yield this.request({
-                path: "/passwordless/start",
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                },
-                body: yield this.addClientAuthentication(Object.assign({ client_id: this.clientId, connection: "sms" }, bodyParameters)),
-            }, initOverrides);
-            return VoidApiResponse.fromResponse(response);
-        });
-    }
-    /**
-     * Once you have a verification code, use this endpoint to login the user with their email and verification code.
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId',
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.passwordless.loginWithEmail({
-     *   email: 'foo@example.com',
-     *   code: 'ABC123'
-     * });
-     * ```
-     */
-    loginWithEmail(bodyParameters_1) {
-        return __awaiter(this, arguments, void 0, function* (bodyParameters, options = {}) {
-            validateRequiredRequestParams(bodyParameters, ["email", "code"]);
-            const { email: username, code: otp } = bodyParameters, otherParams = __rest(bodyParameters, ["email", "code"]);
-            return grant("http://auth0.com/oauth/grant-type/passwordless/otp", yield this.addClientAuthentication(Object.assign({ username,
-                otp, realm: "email" }, otherParams)), options, this.clientId, this.idTokenValidator, this.request.bind(this));
-        });
-    }
-    /**
-     * Once you have a verification code, use this endpoint to login the user with their phone number and verification code.
-     *
-     * @example
-     * ```js
-     * const auth0 = new AuthenticationApi({
-     *    domain: 'my-domain.auth0.com',
-     *    clientId: 'myClientId',
-     *    clientSecret: 'myClientSecret'
-     * });
-     *
-     * await auth0.passwordless.loginWithSMS({
-     *   phone_number: '0777777777',
-     *   code: 'ABC123'
-     * });
-     * ```
-     */
-    loginWithSMS(bodyParameters_1) {
-        return __awaiter(this, arguments, void 0, function* (bodyParameters, options = {}) {
-            validateRequiredRequestParams(bodyParameters, ["phone_number", "code"]);
-            const { phone_number: username, code: otp } = bodyParameters, otherParams = __rest(bodyParameters, ["phone_number", "code"]);
-            return grant("http://auth0.com/oauth/grant-type/passwordless/otp", yield this.addClientAuthentication(Object.assign({ username,
-                otp, realm: "sms" }, otherParams)), options, this.clientId, this.idTokenValidator, this.request.bind(this));
-        });
-    }
-}