@clerk/backend
Version:
Clerk Backend SDK - REST Client for Backend API & JWT verification utilities
1,714 lines (1,676 loc) • 203 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __typeError = (msg) => {
throw TypeError(msg);
};
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
// ../../node_modules/.pnpm/cookie@1.0.2/node_modules/cookie/dist/index.js
var require_dist = __commonJS({
"../../node_modules/.pnpm/cookie@1.0.2/node_modules/cookie/dist/index.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.parse = parse3;
exports2.serialize = serialize;
var cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
var cookieValueRegExp = /^[\u0021-\u003A\u003C-\u007E]*$/;
var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
var pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
var __toString = Object.prototype.toString;
var NullObject = /* @__PURE__ */ (() => {
const C = function() {
};
C.prototype = /* @__PURE__ */ Object.create(null);
return C;
})();
function parse3(str, options) {
const obj = new NullObject();
const len = str.length;
if (len < 2)
return obj;
const dec = options?.decode || decode;
let index = 0;
do {
const eqIdx = str.indexOf("=", index);
if (eqIdx === -1)
break;
const colonIdx = str.indexOf(";", index);
const endIdx = colonIdx === -1 ? len : colonIdx;
if (eqIdx > endIdx) {
index = str.lastIndexOf(";", eqIdx - 1) + 1;
continue;
}
const keyStartIdx = startIndex(str, index, eqIdx);
const keyEndIdx = endIndex(str, eqIdx, keyStartIdx);
const key = str.slice(keyStartIdx, keyEndIdx);
if (obj[key] === void 0) {
let valStartIdx = startIndex(str, eqIdx + 1, endIdx);
let valEndIdx = endIndex(str, endIdx, valStartIdx);
const value = dec(str.slice(valStartIdx, valEndIdx));
obj[key] = value;
}
index = endIdx + 1;
} while (index < len);
return obj;
}
function startIndex(str, index, max) {
do {
const code = str.charCodeAt(index);
if (code !== 32 && code !== 9)
return index;
} while (++index < max);
return max;
}
function endIndex(str, index, min) {
while (index > min) {
const code = str.charCodeAt(--index);
if (code !== 32 && code !== 9)
return index + 1;
}
return min;
}
function serialize(name, val, options) {
const enc = options?.encode || encodeURIComponent;
if (!cookieNameRegExp.test(name)) {
throw new TypeError(`argument name is invalid: ${name}`);
}
const value = enc(val);
if (!cookieValueRegExp.test(value)) {
throw new TypeError(`argument val is invalid: ${val}`);
}
let str = name + "=" + value;
if (!options)
return str;
if (options.maxAge !== void 0) {
if (!Number.isInteger(options.maxAge)) {
throw new TypeError(`option maxAge is invalid: ${options.maxAge}`);
}
str += "; Max-Age=" + options.maxAge;
}
if (options.domain) {
if (!domainValueRegExp.test(options.domain)) {
throw new TypeError(`option domain is invalid: ${options.domain}`);
}
str += "; Domain=" + options.domain;
}
if (options.path) {
if (!pathValueRegExp.test(options.path)) {
throw new TypeError(`option path is invalid: ${options.path}`);
}
str += "; Path=" + options.path;
}
if (options.expires) {
if (!isDate(options.expires) || !Number.isFinite(options.expires.valueOf())) {
throw new TypeError(`option expires is invalid: ${options.expires}`);
}
str += "; Expires=" + options.expires.toUTCString();
}
if (options.httpOnly) {
str += "; HttpOnly";
}
if (options.secure) {
str += "; Secure";
}
if (options.partitioned) {
str += "; Partitioned";
}
if (options.priority) {
const priority = typeof options.priority === "string" ? options.priority.toLowerCase() : void 0;
switch (priority) {
case "low":
str += "; Priority=Low";
break;
case "medium":
str += "; Priority=Medium";
break;
case "high":
str += "; Priority=High";
break;
default:
throw new TypeError(`option priority is invalid: ${options.priority}`);
}
}
if (options.sameSite) {
const sameSite = typeof options.sameSite === "string" ? options.sameSite.toLowerCase() : options.sameSite;
switch (sameSite) {
case true:
case "strict":
str += "; SameSite=Strict";
break;
case "lax":
str += "; SameSite=Lax";
break;
case "none":
str += "; SameSite=None";
break;
default:
throw new TypeError(`option sameSite is invalid: ${options.sameSite}`);
}
}
return str;
}
function decode(str) {
if (str.indexOf("%") === -1)
return str;
try {
return decodeURIComponent(str);
} catch (e) {
return str;
}
}
function isDate(val) {
return __toString.call(val) === "[object Date]";
}
}
});
// src/index.ts
var index_exports = {};
__export(index_exports, {
createClerkClient: () => createClerkClient,
verifyToken: () => verifyToken2
});
module.exports = __toCommonJS(index_exports);
var import_telemetry = require("@clerk/shared/telemetry");
// src/util/path.ts
var SEPARATOR = "/";
var MULTIPLE_SEPARATOR_REGEX = new RegExp("(?<!:)" + SEPARATOR + "{1,}", "g");
function joinPaths(...args) {
return args.filter((p) => p).join(SEPARATOR).replace(MULTIPLE_SEPARATOR_REGEX, SEPARATOR);
}
// src/api/endpoints/AbstractApi.ts
var AbstractAPI = class {
constructor(request) {
this.request = request;
}
requireId(id) {
if (!id) {
throw new Error("A valid resource ID is required.");
}
}
};
// src/api/endpoints/ActorTokenApi.ts
var basePath = "/actor_tokens";
var ActorTokenAPI = class extends AbstractAPI {
async create(params) {
return this.request({
method: "POST",
path: basePath,
bodyParams: params
});
}
async revoke(actorTokenId) {
this.requireId(actorTokenId);
return this.request({
method: "POST",
path: joinPaths(basePath, actorTokenId, "revoke")
});
}
};
// src/api/endpoints/AccountlessApplicationsAPI.ts
var basePath2 = "/accountless_applications";
var AccountlessApplicationAPI = class extends AbstractAPI {
async createAccountlessApplication(params) {
const headerParams = params?.requestHeaders ? Object.fromEntries(params.requestHeaders.entries()) : void 0;
return this.request({
method: "POST",
path: basePath2,
headerParams
});
}
async completeAccountlessApplicationOnboarding(params) {
const headerParams = params?.requestHeaders ? Object.fromEntries(params.requestHeaders.entries()) : void 0;
return this.request({
method: "POST",
path: joinPaths(basePath2, "complete"),
headerParams
});
}
};
// src/api/endpoints/AllowlistIdentifierApi.ts
var basePath3 = "/allowlist_identifiers";
var AllowlistIdentifierAPI = class extends AbstractAPI {
async getAllowlistIdentifierList(params = {}) {
return this.request({
method: "GET",
path: basePath3,
queryParams: { ...params, paginated: true }
});
}
async createAllowlistIdentifier(params) {
return this.request({
method: "POST",
path: basePath3,
bodyParams: params
});
}
async deleteAllowlistIdentifier(allowlistIdentifierId) {
this.requireId(allowlistIdentifierId);
return this.request({
method: "DELETE",
path: joinPaths(basePath3, allowlistIdentifierId)
});
}
};
// src/util/shared.ts
var import_deprecated = require("@clerk/shared/deprecated");
var import_keys = require("@clerk/shared/keys");
var import_retry = require("@clerk/shared/retry");
var import_url = require("@clerk/shared/url");
var import_error = require("@clerk/shared/error");
var import_keys2 = require("@clerk/shared/keys");
var errorThrower = (0, import_error.buildErrorThrower)({ packageName: "@clerk/backend" });
var { isDevOrStagingUrl } = (0, import_keys2.createDevOrStagingUrlCache)();
// src/api/endpoints/APIKeysApi.ts
var basePath4 = "/api_keys";
var APIKeysAPI = class extends AbstractAPI {
async list(queryParams) {
return this.request({
method: "GET",
path: basePath4,
queryParams
});
}
async create(params) {
return this.request({
method: "POST",
path: basePath4,
bodyParams: params
});
}
async get(apiKeyId) {
this.requireId(apiKeyId);
return this.request({
method: "GET",
path: joinPaths(basePath4, apiKeyId)
});
}
async update(params) {
const { apiKeyId, ...bodyParams } = params;
this.requireId(apiKeyId);
return this.request({
method: "PATCH",
path: joinPaths(basePath4, apiKeyId),
bodyParams
});
}
async delete(apiKeyId) {
this.requireId(apiKeyId);
return this.request({
method: "DELETE",
path: joinPaths(basePath4, apiKeyId)
});
}
async revoke(params) {
const { apiKeyId, revocationReason = null } = params;
this.requireId(apiKeyId);
return this.request({
method: "POST",
path: joinPaths(basePath4, apiKeyId, "revoke"),
bodyParams: { revocationReason }
});
}
async getSecret(apiKeyId) {
this.requireId(apiKeyId);
return this.request({
method: "GET",
path: joinPaths(basePath4, apiKeyId, "secret")
});
}
async verify(secret) {
return this.request({
method: "POST",
path: joinPaths(basePath4, "verify"),
bodyParams: { secret }
});
}
/**
* @deprecated Use `verify()` instead. This method will be removed in the next major release.
*/
async verifySecret(secret) {
(0, import_deprecated.deprecated)("apiKeys.verifySecret()", "Use `apiKeys.verify()` instead.");
return this.verify(secret);
}
};
// src/api/endpoints/BetaFeaturesApi.ts
var basePath5 = "/beta_features";
var BetaFeaturesAPI = class extends AbstractAPI {
/**
* Change the domain of a production instance.
*
* Changing the domain requires updating the DNS records accordingly, deploying new SSL certificates,
* updating your Social Connection's redirect URLs and setting the new keys in your code.
*
* @remarks
* WARNING: Changing your domain will invalidate all current user sessions (i.e. users will be logged out).
* Also, while your application is being deployed, a small downtime is expected to occur.
*/
async changeDomain(params) {
return this.request({
method: "POST",
path: joinPaths(basePath5, "change_domain"),
bodyParams: params
});
}
};
// src/api/endpoints/BlocklistIdentifierApi.ts
var basePath6 = "/blocklist_identifiers";
var BlocklistIdentifierAPI = class extends AbstractAPI {
async getBlocklistIdentifierList(params = {}) {
return this.request({
method: "GET",
path: basePath6,
queryParams: params
});
}
async createBlocklistIdentifier(params) {
return this.request({
method: "POST",
path: basePath6,
bodyParams: params
});
}
async deleteBlocklistIdentifier(blocklistIdentifierId) {
this.requireId(blocklistIdentifierId);
return this.request({
method: "DELETE",
path: joinPaths(basePath6, blocklistIdentifierId)
});
}
};
// src/api/endpoints/ClientApi.ts
var basePath7 = "/clients";
var ClientAPI = class extends AbstractAPI {
async getClientList(params = {}) {
return this.request({
method: "GET",
path: basePath7,
queryParams: { ...params, paginated: true }
});
}
async getClient(clientId) {
this.requireId(clientId);
return this.request({
method: "GET",
path: joinPaths(basePath7, clientId)
});
}
verifyClient(token) {
return this.request({
method: "POST",
path: joinPaths(basePath7, "verify"),
bodyParams: { token }
});
}
async getHandshakePayload(queryParams) {
return this.request({
method: "GET",
path: joinPaths(basePath7, "handshake_payload"),
queryParams
});
}
};
// src/api/endpoints/DomainApi.ts
var basePath8 = "/domains";
var DomainAPI = class extends AbstractAPI {
async list() {
return this.request({
method: "GET",
path: basePath8
});
}
async add(params) {
return this.request({
method: "POST",
path: basePath8,
bodyParams: params
});
}
async update(params) {
const { domainId, ...bodyParams } = params;
this.requireId(domainId);
return this.request({
method: "PATCH",
path: joinPaths(basePath8, domainId),
bodyParams
});
}
/**
* Deletes a satellite domain for the instance.
* It is currently not possible to delete the instance's primary domain.
*/
async delete(satelliteDomainId) {
return this.deleteDomain(satelliteDomainId);
}
/**
* @deprecated Use `delete` instead
*/
async deleteDomain(satelliteDomainId) {
this.requireId(satelliteDomainId);
return this.request({
method: "DELETE",
path: joinPaths(basePath8, satelliteDomainId)
});
}
};
// src/api/endpoints/EmailAddressApi.ts
var basePath9 = "/email_addresses";
var EmailAddressAPI = class extends AbstractAPI {
async getEmailAddress(emailAddressId) {
this.requireId(emailAddressId);
return this.request({
method: "GET",
path: joinPaths(basePath9, emailAddressId)
});
}
async createEmailAddress(params) {
return this.request({
method: "POST",
path: basePath9,
bodyParams: params
});
}
async updateEmailAddress(emailAddressId, params = {}) {
this.requireId(emailAddressId);
return this.request({
method: "PATCH",
path: joinPaths(basePath9, emailAddressId),
bodyParams: params
});
}
async deleteEmailAddress(emailAddressId) {
this.requireId(emailAddressId);
return this.request({
method: "DELETE",
path: joinPaths(basePath9, emailAddressId)
});
}
};
// src/api/endpoints/IdPOAuthAccessTokenApi.ts
var basePath10 = "/oauth_applications/access_tokens";
var IdPOAuthAccessTokenApi = class extends AbstractAPI {
async verify(accessToken) {
return this.request({
method: "POST",
path: joinPaths(basePath10, "verify"),
bodyParams: { access_token: accessToken }
});
}
/**
* @deprecated Use `verify()` instead. This method will be removed in the next major release.
*/
async verifyAccessToken(accessToken) {
(0, import_deprecated.deprecated)("idPOAuthAccessToken.verifyAccessToken()", "Use `idPOAuthAccessToken.verify()` instead.");
return this.verify(accessToken);
}
};
// src/api/endpoints/InstanceApi.ts
var basePath11 = "/instance";
var InstanceAPI = class extends AbstractAPI {
async get() {
return this.request({
method: "GET",
path: basePath11
});
}
async update(params) {
return this.request({
method: "PATCH",
path: basePath11,
bodyParams: params
});
}
async updateRestrictions(params) {
return this.request({
method: "PATCH",
path: joinPaths(basePath11, "restrictions"),
bodyParams: params
});
}
async updateOrganizationSettings(params) {
return this.request({
method: "PATCH",
path: joinPaths(basePath11, "organization_settings"),
bodyParams: params
});
}
};
// src/api/endpoints/InvitationApi.ts
var basePath12 = "/invitations";
var InvitationAPI = class extends AbstractAPI {
async getInvitationList(params = {}) {
return this.request({
method: "GET",
path: basePath12,
queryParams: { ...params, paginated: true }
});
}
async createInvitation(params) {
return this.request({
method: "POST",
path: basePath12,
bodyParams: params
});
}
async createInvitationBulk(params) {
return this.request({
method: "POST",
path: joinPaths(basePath12, "bulk"),
bodyParams: params
});
}
async revokeInvitation(invitationId) {
this.requireId(invitationId);
return this.request({
method: "POST",
path: joinPaths(basePath12, invitationId, "revoke")
});
}
};
// src/api/endpoints/MachineApi.ts
var basePath13 = "/machines";
var MachineApi = class extends AbstractAPI {
async get(machineId) {
this.requireId(machineId);
return this.request({
method: "GET",
path: joinPaths(basePath13, machineId)
});
}
async list(queryParams = {}) {
return this.request({
method: "GET",
path: basePath13,
queryParams
});
}
async create(bodyParams) {
return this.request({
method: "POST",
path: basePath13,
bodyParams
});
}
async update(params) {
const { machineId, ...bodyParams } = params;
this.requireId(machineId);
return this.request({
method: "PATCH",
path: joinPaths(basePath13, machineId),
bodyParams
});
}
async delete(machineId) {
this.requireId(machineId);
return this.request({
method: "DELETE",
path: joinPaths(basePath13, machineId)
});
}
async getSecretKey(machineId) {
this.requireId(machineId);
return this.request({
method: "GET",
path: joinPaths(basePath13, machineId, "secret_key")
});
}
async rotateSecretKey(params) {
const { machineId, previousTokenTtl } = params;
this.requireId(machineId);
return this.request({
method: "POST",
path: joinPaths(basePath13, machineId, "secret_key", "rotate"),
bodyParams: {
previousTokenTtl
}
});
}
/**
* Creates a new machine scope, allowing the specified machine to access another machine.
*
* @param machineId - The ID of the machine that will have access to another machine.
* @param toMachineId - The ID of the machine that will be scoped to the current machine.
*/
async createScope(machineId, toMachineId) {
this.requireId(machineId);
return this.request({
method: "POST",
path: joinPaths(basePath13, machineId, "scopes"),
bodyParams: {
toMachineId
}
});
}
/**
* Deletes a machine scope, removing access from one machine to another.
*
* @param machineId - The ID of the machine that has access to another machine.
* @param otherMachineId - The ID of the machine that is being accessed.
*/
async deleteScope(machineId, otherMachineId) {
this.requireId(machineId);
return this.request({
method: "DELETE",
path: joinPaths(basePath13, machineId, "scopes", otherMachineId)
});
}
};
// src/api/endpoints/M2MTokenApi.ts
var basePath14 = "/m2m_tokens";
var _M2MTokenApi_instances, createRequestOptions_fn;
var M2MTokenApi = class extends AbstractAPI {
constructor() {
super(...arguments);
__privateAdd(this, _M2MTokenApi_instances);
}
async createToken(params) {
const { claims = null, machineSecretKey, secondsUntilExpiration = null } = params || {};
const requestOptions = __privateMethod(this, _M2MTokenApi_instances, createRequestOptions_fn).call(this, {
method: "POST",
path: basePath14,
bodyParams: {
secondsUntilExpiration,
claims
}
}, machineSecretKey);
return this.request(requestOptions);
}
async revokeToken(params) {
const { m2mTokenId, revocationReason = null, machineSecretKey } = params;
this.requireId(m2mTokenId);
const requestOptions = __privateMethod(this, _M2MTokenApi_instances, createRequestOptions_fn).call(this, {
method: "POST",
path: joinPaths(basePath14, m2mTokenId, "revoke"),
bodyParams: {
revocationReason
}
}, machineSecretKey);
return this.request(requestOptions);
}
async verify(params) {
const { token, machineSecretKey } = params;
const requestOptions = __privateMethod(this, _M2MTokenApi_instances, createRequestOptions_fn).call(this, {
method: "POST",
path: joinPaths(basePath14, "verify"),
bodyParams: { token }
}, machineSecretKey);
return this.request(requestOptions);
}
/**
* @deprecated Use `verify()` instead. This method will be removed in the next major release.
*/
async verifyToken(params) {
(0, import_deprecated.deprecated)("m2m.verifyToken()", "Use `m2m.verify()` instead.");
return this.verify(params);
}
};
_M2MTokenApi_instances = new WeakSet();
createRequestOptions_fn = function(options, machineSecretKey) {
if (machineSecretKey) {
return {
...options,
headerParams: {
...options.headerParams,
Authorization: `Bearer ${machineSecretKey}`
}
};
}
return options;
};
// src/api/endpoints/JwksApi.ts
var basePath15 = "/jwks";
var JwksAPI = class extends AbstractAPI {
async getJwks() {
return this.request({
method: "GET",
path: basePath15
});
}
};
// src/api/endpoints/JwtTemplatesApi.ts
var basePath16 = "/jwt_templates";
var JwtTemplatesApi = class extends AbstractAPI {
async list(params = {}) {
return this.request({
method: "GET",
path: basePath16,
queryParams: { ...params, paginated: true }
});
}
async get(templateId) {
this.requireId(templateId);
return this.request({
method: "GET",
path: joinPaths(basePath16, templateId)
});
}
async create(params) {
return this.request({
method: "POST",
path: basePath16,
bodyParams: params
});
}
async update(params) {
const { templateId, ...bodyParams } = params;
this.requireId(templateId);
return this.request({
method: "PATCH",
path: joinPaths(basePath16, templateId),
bodyParams
});
}
async delete(templateId) {
this.requireId(templateId);
return this.request({
method: "DELETE",
path: joinPaths(basePath16, templateId)
});
}
};
// src/runtime.ts
var import_crypto = require("#crypto");
var globalFetch = fetch.bind(globalThis);
var runtime = {
crypto: import_crypto.webcrypto,
get fetch() {
return process.env.NODE_ENV === "test" ? fetch : globalFetch;
},
AbortController: globalThis.AbortController,
Blob: globalThis.Blob,
FormData: globalThis.FormData,
Headers: globalThis.Headers,
Request: globalThis.Request,
Response: globalThis.Response
};
// src/api/endpoints/OrganizationApi.ts
var basePath17 = "/organizations";
var OrganizationAPI = class extends AbstractAPI {
async getOrganizationList(params) {
return this.request({
method: "GET",
path: basePath17,
queryParams: params
});
}
async createOrganization(params) {
return this.request({
method: "POST",
path: basePath17,
bodyParams: params
});
}
async getOrganization(params) {
const { includeMembersCount } = params;
const organizationIdOrSlug = "organizationId" in params ? params.organizationId : params.slug;
this.requireId(organizationIdOrSlug);
return this.request({
method: "GET",
path: joinPaths(basePath17, organizationIdOrSlug),
queryParams: {
includeMembersCount
}
});
}
async updateOrganization(organizationId, params) {
this.requireId(organizationId);
return this.request({
method: "PATCH",
path: joinPaths(basePath17, organizationId),
bodyParams: params
});
}
async updateOrganizationLogo(organizationId, params) {
this.requireId(organizationId);
const formData = new runtime.FormData();
formData.append("file", params?.file);
if (params?.uploaderUserId) {
formData.append("uploader_user_id", params?.uploaderUserId);
}
return this.request({
method: "PUT",
path: joinPaths(basePath17, organizationId, "logo"),
formData
});
}
async deleteOrganizationLogo(organizationId) {
this.requireId(organizationId);
return this.request({
method: "DELETE",
path: joinPaths(basePath17, organizationId, "logo")
});
}
async updateOrganizationMetadata(organizationId, params) {
this.requireId(organizationId);
return this.request({
method: "PATCH",
path: joinPaths(basePath17, organizationId, "metadata"),
bodyParams: params
});
}
async deleteOrganization(organizationId) {
return this.request({
method: "DELETE",
path: joinPaths(basePath17, organizationId)
});
}
async getOrganizationMembershipList(params) {
const { organizationId, ...queryParams } = params;
this.requireId(organizationId);
return this.request({
method: "GET",
path: joinPaths(basePath17, organizationId, "memberships"),
queryParams
});
}
async getInstanceOrganizationMembershipList(params) {
return this.request({
method: "GET",
path: "/organization_memberships",
queryParams: params
});
}
async createOrganizationMembership(params) {
const { organizationId, ...bodyParams } = params;
this.requireId(organizationId);
return this.request({
method: "POST",
path: joinPaths(basePath17, organizationId, "memberships"),
bodyParams
});
}
async updateOrganizationMembership(params) {
const { organizationId, userId, ...bodyParams } = params;
this.requireId(organizationId);
return this.request({
method: "PATCH",
path: joinPaths(basePath17, organizationId, "memberships", userId),
bodyParams
});
}
async updateOrganizationMembershipMetadata(params) {
const { organizationId, userId, ...bodyParams } = params;
return this.request({
method: "PATCH",
path: joinPaths(basePath17, organizationId, "memberships", userId, "metadata"),
bodyParams
});
}
async deleteOrganizationMembership(params) {
const { organizationId, userId } = params;
this.requireId(organizationId);
return this.request({
method: "DELETE",
path: joinPaths(basePath17, organizationId, "memberships", userId)
});
}
async getOrganizationInvitationList(params) {
const { organizationId, ...queryParams } = params;
this.requireId(organizationId);
return this.request({
method: "GET",
path: joinPaths(basePath17, organizationId, "invitations"),
queryParams
});
}
async createOrganizationInvitation(params) {
const { organizationId, ...bodyParams } = params;
this.requireId(organizationId);
return this.request({
method: "POST",
path: joinPaths(basePath17, organizationId, "invitations"),
bodyParams
});
}
async createOrganizationInvitationBulk(organizationId, params) {
this.requireId(organizationId);
return this.request({
method: "POST",
path: joinPaths(basePath17, organizationId, "invitations", "bulk"),
bodyParams: params
});
}
async getOrganizationInvitation(params) {
const { organizationId, invitationId } = params;
this.requireId(organizationId);
this.requireId(invitationId);
return this.request({
method: "GET",
path: joinPaths(basePath17, organizationId, "invitations", invitationId)
});
}
async revokeOrganizationInvitation(params) {
const { organizationId, invitationId, ...bodyParams } = params;
this.requireId(organizationId);
return this.request({
method: "POST",
path: joinPaths(basePath17, organizationId, "invitations", invitationId, "revoke"),
bodyParams
});
}
async getOrganizationDomainList(params) {
const { organizationId, ...queryParams } = params;
this.requireId(organizationId);
return this.request({
method: "GET",
path: joinPaths(basePath17, organizationId, "domains"),
queryParams
});
}
async createOrganizationDomain(params) {
const { organizationId, ...bodyParams } = params;
this.requireId(organizationId);
return this.request({
method: "POST",
path: joinPaths(basePath17, organizationId, "domains"),
bodyParams: {
...bodyParams,
verified: bodyParams.verified ?? true
}
});
}
async updateOrganizationDomain(params) {
const { organizationId, domainId, ...bodyParams } = params;
this.requireId(organizationId);
this.requireId(domainId);
return this.request({
method: "PATCH",
path: joinPaths(basePath17, organizationId, "domains", domainId),
bodyParams
});
}
async deleteOrganizationDomain(params) {
const { organizationId, domainId } = params;
this.requireId(organizationId);
this.requireId(domainId);
return this.request({
method: "DELETE",
path: joinPaths(basePath17, organizationId, "domains", domainId)
});
}
};
// src/api/endpoints/OAuthApplicationsApi.ts
var basePath18 = "/oauth_applications";
var OAuthApplicationsApi = class extends AbstractAPI {
async list(params = {}) {
return this.request({
method: "GET",
path: basePath18,
queryParams: params
});
}
async get(oauthApplicationId) {
this.requireId(oauthApplicationId);
return this.request({
method: "GET",
path: joinPaths(basePath18, oauthApplicationId)
});
}
async create(params) {
return this.request({
method: "POST",
path: basePath18,
bodyParams: params
});
}
async update(params) {
const { oauthApplicationId, ...bodyParams } = params;
this.requireId(oauthApplicationId);
return this.request({
method: "PATCH",
path: joinPaths(basePath18, oauthApplicationId),
bodyParams
});
}
async delete(oauthApplicationId) {
this.requireId(oauthApplicationId);
return this.request({
method: "DELETE",
path: joinPaths(basePath18, oauthApplicationId)
});
}
async rotateSecret(oauthApplicationId) {
this.requireId(oauthApplicationId);
return this.request({
method: "POST",
path: joinPaths(basePath18, oauthApplicationId, "rotate_secret")
});
}
};
// src/api/endpoints/PhoneNumberApi.ts
var basePath19 = "/phone_numbers";
var PhoneNumberAPI = class extends AbstractAPI {
async getPhoneNumber(phoneNumberId) {
this.requireId(phoneNumberId);
return this.request({
method: "GET",
path: joinPaths(basePath19, phoneNumberId)
});
}
async createPhoneNumber(params) {
return this.request({
method: "POST",
path: basePath19,
bodyParams: params
});
}
async updatePhoneNumber(phoneNumberId, params = {}) {
this.requireId(phoneNumberId);
return this.request({
method: "PATCH",
path: joinPaths(basePath19, phoneNumberId),
bodyParams: params
});
}
async deletePhoneNumber(phoneNumberId) {
this.requireId(phoneNumberId);
return this.request({
method: "DELETE",
path: joinPaths(basePath19, phoneNumberId)
});
}
};
// src/api/endpoints/ProxyCheckApi.ts
var basePath20 = "/proxy_checks";
var ProxyCheckAPI = class extends AbstractAPI {
async verify(params) {
return this.request({
method: "POST",
path: basePath20,
bodyParams: params
});
}
};
// src/api/endpoints/RedirectUrlApi.ts
var basePath21 = "/redirect_urls";
var RedirectUrlAPI = class extends AbstractAPI {
async getRedirectUrlList() {
return this.request({
method: "GET",
path: basePath21,
queryParams: { paginated: true }
});
}
async getRedirectUrl(redirectUrlId) {
this.requireId(redirectUrlId);
return this.request({
method: "GET",
path: joinPaths(basePath21, redirectUrlId)
});
}
async createRedirectUrl(params) {
return this.request({
method: "POST",
path: basePath21,
bodyParams: params
});
}
async deleteRedirectUrl(redirectUrlId) {
this.requireId(redirectUrlId);
return this.request({
method: "DELETE",
path: joinPaths(basePath21, redirectUrlId)
});
}
};
// src/api/endpoints/SamlConnectionApi.ts
var basePath22 = "/saml_connections";
var SamlConnectionAPI = class extends AbstractAPI {
async getSamlConnectionList(params = {}) {
return this.request({
method: "GET",
path: basePath22,
queryParams: params
});
}
async createSamlConnection(params) {
return this.request({
method: "POST",
path: basePath22,
bodyParams: params,
options: {
deepSnakecaseBodyParamKeys: true
}
});
}
async getSamlConnection(samlConnectionId) {
this.requireId(samlConnectionId);
return this.request({
method: "GET",
path: joinPaths(basePath22, samlConnectionId)
});
}
async updateSamlConnection(samlConnectionId, params = {}) {
this.requireId(samlConnectionId);
return this.request({
method: "PATCH",
path: joinPaths(basePath22, samlConnectionId),
bodyParams: params,
options: {
deepSnakecaseBodyParamKeys: true
}
});
}
async deleteSamlConnection(samlConnectionId) {
this.requireId(samlConnectionId);
return this.request({
method: "DELETE",
path: joinPaths(basePath22, samlConnectionId)
});
}
};
// src/api/endpoints/SessionApi.ts
var basePath23 = "/sessions";
var SessionAPI = class extends AbstractAPI {
async getSessionList(params = {}) {
return this.request({
method: "GET",
path: basePath23,
queryParams: { ...params, paginated: true }
});
}
async getSession(sessionId) {
this.requireId(sessionId);
return this.request({
method: "GET",
path: joinPaths(basePath23, sessionId)
});
}
async createSession(params) {
return this.request({
method: "POST",
path: basePath23,
bodyParams: params
});
}
async revokeSession(sessionId) {
this.requireId(sessionId);
return this.request({
method: "POST",
path: joinPaths(basePath23, sessionId, "revoke")
});
}
async verifySession(sessionId, token) {
this.requireId(sessionId);
return this.request({
method: "POST",
path: joinPaths(basePath23, sessionId, "verify"),
bodyParams: { token }
});
}
/**
* Retrieves a session token or generates a JWT using a specified template.
*
* @param sessionId - The ID of the session for which to generate the token
* @param template - Optional name of the JWT template configured in the Clerk Dashboard.
* @param expiresInSeconds - Optional expiration time for the token in seconds.
* If not provided, uses the default expiration.
*
* @returns A promise that resolves to the generated token
*
* @throws {Error} When sessionId is invalid or empty
*/
async getToken(sessionId, template, expiresInSeconds) {
this.requireId(sessionId);
const path = template ? joinPaths(basePath23, sessionId, "tokens", template) : joinPaths(basePath23, sessionId, "tokens");
const requestOptions = {
method: "POST",
path
};
if (expiresInSeconds !== void 0) {
requestOptions.bodyParams = { expires_in_seconds: expiresInSeconds };
}
return this.request(requestOptions);
}
async refreshSession(sessionId, params) {
this.requireId(sessionId);
const { suffixed_cookies, ...restParams } = params;
return this.request({
method: "POST",
path: joinPaths(basePath23, sessionId, "refresh"),
bodyParams: restParams,
queryParams: { suffixed_cookies }
});
}
};
// src/api/endpoints/SignInTokenApi.ts
var basePath24 = "/sign_in_tokens";
var SignInTokenAPI = class extends AbstractAPI {
async createSignInToken(params) {
return this.request({
method: "POST",
path: basePath24,
bodyParams: params
});
}
async revokeSignInToken(signInTokenId) {
this.requireId(signInTokenId);
return this.request({
method: "POST",
path: joinPaths(basePath24, signInTokenId, "revoke")
});
}
};
// src/api/endpoints/SignUpApi.ts
var basePath25 = "/sign_ups";
var SignUpAPI = class extends AbstractAPI {
async get(signUpAttemptId) {
this.requireId(signUpAttemptId);
return this.request({
method: "GET",
path: joinPaths(basePath25, signUpAttemptId)
});
}
async update(params) {
const { signUpAttemptId, ...bodyParams } = params;
return this.request({
method: "PATCH",
path: joinPaths(basePath25, signUpAttemptId),
bodyParams
});
}
};
// src/api/endpoints/TestingTokenApi.ts
var basePath26 = "/testing_tokens";
var TestingTokenAPI = class extends AbstractAPI {
async createTestingToken() {
return this.request({
method: "POST",
path: basePath26
});
}
};
// src/api/endpoints/UserApi.ts
var basePath27 = "/users";
var UserAPI = class extends AbstractAPI {
async getUserList(params = {}) {
const { limit, offset, orderBy, ...userCountParams } = params;
const [data, totalCount] = await Promise.all([
this.request({
method: "GET",
path: basePath27,
queryParams: params
}),
this.getCount(userCountParams)
]);
return { data, totalCount };
}
async getUser(userId) {
this.requireId(userId);
return this.request({
method: "GET",
path: joinPaths(basePath27, userId)
});
}
async createUser(params) {
return this.request({
method: "POST",
path: basePath27,
bodyParams: params
});
}
async updateUser(userId, params = {}) {
this.requireId(userId);
return this.request({
method: "PATCH",
path: joinPaths(basePath27, userId),
bodyParams: params
});
}
async updateUserProfileImage(userId, params) {
this.requireId(userId);
const formData = new runtime.FormData();
formData.append("file", params?.file);
return this.request({
method: "POST",
path: joinPaths(basePath27, userId, "profile_image"),
formData
});
}
async updateUserMetadata(userId, params) {
this.requireId(userId);
return this.request({
method: "PATCH",
path: joinPaths(basePath27, userId, "metadata"),
bodyParams: params
});
}
async deleteUser(userId) {
this.requireId(userId);
return this.request({
method: "DELETE",
path: joinPaths(basePath27, userId)
});
}
async getCount(params = {}) {
return this.request({
method: "GET",
path: joinPaths(basePath27, "count"),
queryParams: params
});
}
async getUserOauthAccessToken(userId, provider) {
this.requireId(userId);
const hasPrefix = provider.startsWith("oauth_");
const _provider = hasPrefix ? provider : `oauth_${provider}`;
if (hasPrefix) {
(0, import_deprecated.deprecated)(
"getUserOauthAccessToken(userId, provider)",
"Remove the `oauth_` prefix from the `provider` argument."
);
}
return this.request({
method: "GET",
path: joinPaths(basePath27, userId, "oauth_access_tokens", _provider),
queryParams: { paginated: true }
});
}
async disableUserMFA(userId) {
this.requireId(userId);
return this.request({
method: "DELETE",
path: joinPaths(basePath27, userId, "mfa")
});
}
async getOrganizationMembershipList(params) {
const { userId, limit, offset } = params;
this.requireId(userId);
return this.request({
method: "GET",
path: joinPaths(basePath27, userId, "organization_memberships"),
queryParams: { limit, offset }
});
}
async getOrganizationInvitationList(params) {
const { userId, ...queryParams } = params;
this.requireId(userId);
return this.request({
method: "GET",
path: joinPaths(basePath27, userId, "organization_invitations"),
queryParams
});
}
async verifyPassword(params) {
const { userId, password } = params;
this.requireId(userId);
return this.request({
method: "POST",
path: joinPaths(basePath27, userId, "verify_password"),
bodyParams: { password }
});
}
async verifyTOTP(params) {
const { userId, code } = params;
this.requireId(userId);
return this.request({
method: "POST",
path: joinPaths(basePath27, userId, "verify_totp"),
bodyParams: { code }
});
}
async banUser(userId) {
this.requireId(userId);
return this.request({
method: "POST",
path: joinPaths(basePath27, userId, "ban")
});
}
async unbanUser(userId) {
this.requireId(userId);
return this.request({
method: "POST",
path: joinPaths(basePath27, userId, "unban")
});
}
async lockUser(userId) {
this.requireId(userId);
return this.request({
method: "POST",
path: joinPaths(basePath27, userId, "lock")
});
}
async unlockUser(userId) {
this.requireId(userId);
return this.request({
method: "POST",
path: joinPaths(basePath27, userId, "unlock")
});
}
async deleteUserProfileImage(userId) {
this.requireId(userId);
return this.request({
method: "DELETE",
path: joinPaths(basePath27, userId, "profile_image")
});
}
async deleteUserPasskey(params) {
this.requireId(params.userId);
this.requireId(params.passkeyIdentificationId);
return this.request({
method: "DELETE",
path: joinPaths(basePath27, params.userId, "passkeys", params.passkeyIdentificationId)
});
}
async deleteUserWeb3Wallet(params) {
this.requireId(params.userId);
this.requireId(params.web3WalletIdentificationId);
return this.request({
method: "DELETE",
path: joinPaths(basePath27, params.userId, "web3_wallets", params.web3WalletIdentificationId)
});
}
async deleteUserExternalAccount(params) {
this.requireId(params.userId);
this.requireId(params.externalAccountId);
return this.request({
method: "DELETE",
path: joinPaths(basePath27, params.userId, "external_accounts", params.externalAccountId)
});
}
async deleteUserBackupCodes(userId) {
this.requireId(userId);
return this.request({
method: "DELETE",
path: joinPaths(basePath27, userId, "backup_code")
});
}
async deleteUserTOTP(userId) {
this.requireId(userId);
return this.request({
method: "DELETE",
path: joinPaths(basePath27, userId, "totp")
});
}
async setPasswordCompromised(userId, params = {
revokeAllSessions: false
}) {
this.requireId(userId);
return this.request({
method: "POST",
path: joinPaths(basePath27, userId, "password", "set_compromised"),
bodyParams: params
});
}
async unsetPasswordCompromised(userId) {
this.requireId(userId);
return this.request({
method: "POST",
path: joinPaths(basePath27, userId, "password", "unset_compromised")
});
}
};
// src/api/endpoints/WaitlistEntryApi.ts
var basePath28 = "/waitlist_entries";
var WaitlistEntryAPI = class extends AbstractAPI {
/**
* List waitlist entries.
* @param params Optional parameters (e.g., `query`, `status`, `orderBy`).
*/
async list(params = {}) {
return this.request({
method: "GET",
path: basePath28,
queryParams: params
});
}
/**
* Create a waitlist entry.
* @param params The parameters for creating a waitlist entry.
*/
async create(params) {
return this.request({
method: "POST",
path: basePath28,
bodyParams: params
});
}
/**
* Invite a waitlist entry.
* @param id The waitlist entry ID.
* @param params Optional parameters (e.g., `ignoreExisting`).
*/
async invite(id, params = {}) {
this.requireId(id);
return this.request({
method: "POST",
path: joinPaths(basePath28, id, "invite"),
bodyParams: params
});
}
/**
* Reject a waitlist entry.
* @param id The waitlist entry ID.
*/
async reject(id) {
this.requireId(id);
return this.request({
method: "POST",
path: joinPaths(basePath28, id, "reject")
});
}
/**
* Delete a waitlist entry.
* @param id The waitlist entry ID.
*/
async delete(id) {
this.requireId(id);
return this.request({
method: "DELETE",
path: joinPaths(basePath28, id)
});
}
};
// src/api/endpoints/WebhookApi.ts
var basePath29 = "/webhooks";
var WebhookAPI = class extends AbstractAPI {
async createSvixApp() {
return this.request({
method: "POST",
path: joinPaths(basePath29, "svix")
});
}
async generateSvixAuthURL() {
return this.request({
method: "POST",
path: joinPaths(basePath29, "svix_url")
});
}
async deleteSvixApp() {
return this.request({
method: "DELETE",
path: joinPaths(basePath29, "svix")
});
}
};
// src/api/endpoints/BillingApi.ts
var basePath30 = "/billing";
var organizationBasePath = "/organizations";
var userBasePath = "/users";
var BillingAPI = class extends AbstractAPI {
/**
* @experimental This is an experimental API for the Billing feature that is available under a public beta, and the API is subject to change. It is advised to [pin](https://clerk.com/docs/pinning) the SDK version and the clerk-js version to avoid breaking changes.
*/
async getPlanList(params) {
return this.request({
method: "GET",
path: joinPaths(basePath30, "plans"),
queryParams: params
});
}
/**
* @experimental This is an experimental API for the Billing feature that is available under a public beta, and the API is subject to change. It is advised to [pin](https://clerk.com/docs/pinning) the SDK version and the clerk-js version to avoid breaking changes.
*/
async cancelSubscriptionItem(subscriptionItemId, params) {
this.requireId(subscriptionItemId);
return this.request({
method: "DELETE",
path: joinPaths(basePath30, "subscription_items", subscriptionItemId),
queryParams: params
});
}
/**
* @experimental This is an experimental API for the Billing feature that is available under a public beta, and the API is subject to change. It is advised to [pin](https://clerk.com/docs/pinning) the SDK version and the clerk-js version to avoid breaking changes.
*/
async extendSubscriptionItemFreeTrial(subscriptionItemId, params) {
this.requireId(subscriptionItemId);
return this.request({
method: "POST",
path: joinPaths("/billing", "subscription_items", subscriptionItemId, "extend_free_trial"),
bodyParams: params
});
}
/**
* @experimental This is an experimental API for the Billing feature that is available under a public beta, and the API is subject to change. It is advised to [pin](https://clerk.com/docs/pinning) the SDK version and the clerk-js version to avoid breaking changes.
*/
async getOrganizationBillingSubscription(organizationId) {
this.requireId(organizationId);
return this.request({
method: "GET",
path: joinPaths(organizationBasePath, organizationId, "billing", "subscription")
});
}
/**
* @experimental This is an experimental API for the Billing feature that is available under a public beta, and the API is subject to change. It is advised to [pin](https://clerk.com/docs/pinning) the SDK version and the clerk-js version to avoid breaking changes.
*/
async getUserBillingSubscription(userId) {
this.requireId(userId);
return this.request({
method: "GET",
path: joinPaths(userBasePath, userId, "billing", "subscription")
});
}
};
// src/api/request.ts
var import_error2 = require("@clerk/shared/error");
// ../../node_modules/.pnpm/map-obj@5.0.2/node_modules/map-obj/index.js
var isObject = (value) => typeof value === "object" && value !== null;
var isObjectCustom = (value) => isObject(value) && !(value instanceof RegExp) && !(value insta