@hexclave/shared 1.0.0

package/dist/schema-fields.js

@@ -0,0 +1,1188 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('./chunk-BE-pF4vm.js');
+let __utils_objects_js = require("./utils/objects.js");
+let __known_errors_js = require("./known-errors.js");
+let __utils_errors_js = require("./utils/errors.js");
+let __utils_strings_js = require("./utils/strings.js");
+let yup = require("yup");
+yup = require_chunk.__toESM(yup);
+let __utils_bytes_js = require("./utils/bytes.js");
+let __utils_currency_constants_js = require("./utils/currency-constants.js");
+let __utils_env_js = require("./utils/env.js");
+let __utils_http_js = require("./utils/http.js");
+let __utils_oauth_js = require("./utils/oauth.js");
+let __utils_country_codes_js = require("./utils/country-codes.js");
+let __utils_urls_js = require("./utils/urls.js");
+let __utils_uuids_js = require("./utils/uuids.js");
+
+//#region src/schema-fields.ts
+const MAX_IMAGE_SIZE_BASE64_BYTES = 1e6;
+yup.addMethod(yup.string, "nonEmpty", function(message) {
+	return this.test("non-empty", message ?? (({ path }) => `${path} must not be empty`), (value) => {
+		return value !== "";
+	});
+});
+yup.addMethod(yup.Schema, "hasNested", function(path) {
+	if (!path.match(/^[a-zA-Z0-9_$:-]*$/)) throw new __utils_errors_js.HexclaveAssertionError(`yupSchema.hasNested can currently only be used with alphanumeric keys, underscores, dollar signs, colons, and hyphens. Fix this in the future. Provided key: ${JSON.stringify(path)}`);
+	const schemaInfo = this.meta()?.stackSchemaInfo;
+	if (schemaInfo?.type === "record") return schemaInfo.keySchema.isValidSync(path);
+	else if (schemaInfo?.type === "union") return schemaInfo.items.some((s) => s.hasNested(path));
+	else try {
+		yup.reach(this, path);
+		return true;
+	} catch (e) {
+		if (e instanceof Error && e.message.includes("The schema does not contain the path")) return false;
+		throw e;
+	}
+});
+yup.addMethod(yup.Schema, "getNested", function(path) {
+	if (!path.match(/^[a-zA-Z0-9_$:-]*$/)) throw new __utils_errors_js.HexclaveAssertionError(`yupSchema.getNested can currently only be used with alphanumeric keys, underscores, dollar signs, colons, and hyphens. Fix this in the future. Provided key: ${JSON.stringify(path)}`);
+	if (!this.hasNested(path)) throw new __utils_errors_js.HexclaveAssertionError(`Tried to call yupSchema.getNested, but key is not present in the schema. Provided key: ${path}`, {
+		path,
+		schema: this
+	});
+	const schemaInfo = this.meta()?.stackSchemaInfo;
+	if (schemaInfo?.type === "record") return schemaInfo.valueSchema;
+	else if (schemaInfo?.type === "union") return yupUnion(...schemaInfo.items.filter((s) => s.hasNested(path)).map((s) => s.getNested(path)));
+	else return yup.reach(this, path);
+});
+(void 0)?.test("hasNested", ({ expect }) => {
+	expect(yupObject({ a: yupString() }).hasNested("a")).toBe(true);
+	expect(yupObject({}).hasNested("a")).toBe(false);
+	expect(yupRecord(yupString(), yupString()).hasNested("a")).toBe(true);
+	expect(yupRecord(yupString().oneOf(["a"]), yupString()).hasNested("b")).toBe(false);
+	expect(yupUnion(yupString(), yupNumber()).hasNested("a")).toBe(false);
+	expect(yupUnion(yupString(), yupObject({ b: yupNumber() })).hasNested("a")).toBe(false);
+	expect(yupUnion(yupString(), yupObject({ a: yupNumber() })).hasNested("a")).toBe(true);
+});
+(void 0)?.test("getNested", ({ expect }) => {
+	expect(yupObject({ a: yupNumber() }).getNested("a").describe().type).toEqual("number");
+	expect(() => yupObject({}).getNested("a")).toThrow();
+	expect(() => yupObject({ a: yupObject({ b: yupString() }) }).getNested("a.b")).toThrow();
+	expect(yupRecord(yupString().oneOf(["a"]), yupNumber()).getNested("a").describe().type).toEqual("number");
+	expect(() => yupRecord(yupString().oneOf(["a"]), yupString()).getNested("b")).toThrow();
+	expect(yupUnion(yupString(), yupObject({ a: yupNumber() })).getNested("a").describe().type).toEqual("mixed");
+	expect(yupUnion(yupObject({ a: yupString() }), yupObject({ a: yupNumber() })).getNested("a").describe().type).toEqual("mixed");
+});
+async function yupValidate(schema, obj, options) {
+	try {
+		return await schema.validate(obj, {
+			...(0, __utils_objects_js.omit)(options ?? {}, ["currentUserId"]),
+			context: {
+				...options?.context,
+				stackAllowUserIdMe: options?.currentUserId !== void 0
+			}
+		});
+	} catch (error) {
+		if (error instanceof ReplaceFieldWithOwnUserId) {
+			const currentUserId = options?.currentUserId;
+			if (!currentUserId) throw new __known_errors_js.KnownErrors.CannotGetOwnUserWithoutUser();
+			let pathRemaining = error.path;
+			const fieldPath = [];
+			while (pathRemaining.length > 0) if (pathRemaining.startsWith("[")) {
+				const index = pathRemaining.indexOf("]");
+				if (index < 0) throw new __utils_errors_js.HexclaveAssertionError("Invalid path");
+				fieldPath.push(JSON.parse(pathRemaining.slice(1, index)));
+				pathRemaining = pathRemaining.slice(index + 1);
+			} else {
+				let dotIndex = pathRemaining.indexOf(".");
+				if (dotIndex === -1) dotIndex = pathRemaining.length;
+				fieldPath.push(pathRemaining.slice(0, dotIndex));
+				pathRemaining = pathRemaining.slice(dotIndex + 1);
+			}
+			const newObj = (0, __utils_objects_js.deepPlainClone)(obj);
+			let it = newObj;
+			for (const field of fieldPath.slice(0, -1)) {
+				if (!Object.prototype.hasOwnProperty.call(it, field)) throw new __utils_errors_js.HexclaveAssertionError(`Segment ${field} of path ${error.path} not found in object`);
+				it = it[field];
+			}
+			it[fieldPath[fieldPath.length - 1]] = currentUserId;
+			return await yupValidate(schema, newObj, options);
+		}
+		throw error;
+	}
+}
+const _idDescription = (identify) => `The unique identifier of the ${identify}`;
+const _displayNameDescription = (identify) => `Human-readable ${identify} display name. This is not a unique identifier.`;
+const _clientMetaDataDescription = (identify) => `Client metadata. Used as a data store, accessible from the client side. Do not store information that should not be exposed to the client.`;
+const _clientReadOnlyMetaDataDescription = (identify) => `Client read-only, server-writable metadata. Used as a data store, accessible from the client side. Do not store information that should not be exposed to the client. The client can read this data, but cannot modify it. This is useful for things like subscription status.`;
+const _profileImageUrlDescription = (identify) => `URL of the profile image for ${identify}. Can be a Base64 encoded image. Must be smaller than 100KB. Please compress and crop to a square before passing in.`;
+const _serverMetaDataDescription = (identify) => `Server metadata. Used as a data store, only accessible from the server side. You can store secret information related to the ${identify} here.`;
+const _atMillisDescription = (identify) => `(the number of milliseconds since epoch, January 1, 1970, UTC)`;
+const _createdAtMillisDescription = (identify) => `The time the ${identify} was created ${_atMillisDescription(identify)}`;
+const _signedUpAtMillisDescription = `The time the user signed up ${_atMillisDescription}`;
+const _lastActiveAtMillisDescription = `The time the user was last active ${_atMillisDescription}`;
+function yupString(...args) {
+	return yup.string(...args).meta({ stackSchemaInfo: { type: "string" } });
+}
+function yupNumber(...args) {
+	return yup.number(...args).meta({ stackSchemaInfo: { type: "number" } });
+}
+function yupBoolean(...args) {
+	return yup.boolean(...args).meta({ stackSchemaInfo: { type: "boolean" } });
+}
+/**
+* @deprecated, use number of milliseconds since epoch instead
+*/
+function yupDate(...args) {
+	return yup.date(...args).meta({ stackSchemaInfo: { type: "date" } });
+}
+function _yupMixedInternal(...args) {
+	return yup.mixed(...args);
+}
+function yupMixed(...args) {
+	return _yupMixedInternal(...args).meta({ stackSchemaInfo: { type: "mixed" } });
+}
+function yupArray(...args) {
+	return yup.array(...args).meta({ stackSchemaInfo: { type: "array" } });
+}
+function yupTuple(schemas) {
+	if (schemas.length === 0) throw new Error("yupTuple must have at least one schema");
+	return yup.tuple(schemas).meta({ stackSchemaInfo: {
+		type: "tuple",
+		items: schemas
+	} });
+}
+function yupObjectWithAutoDefault(...args) {
+	return yup.object(...args).test("no-unknown-object-properties", ({ path }) => `${path} contains unknown properties`, (value, context) => {
+		if (context.options.context?.noUnknownPathPrefixes?.some((prefix) => context.path.startsWith(prefix))) {
+			if (context.schema.spec.noUnknown !== false) {
+				const availableKeys = new Set(Object.keys(context.schema.fields));
+				const unknownKeys = Object.keys(value ?? {}).filter((key) => !availableKeys.has(key));
+				if (unknownKeys.length > 0) return context.createError({
+					message: `${context.path || "Object"} contains unknown properties: ${unknownKeys.join(", ")}`,
+					path: context.path,
+					params: {
+						unknownKeys,
+						availableKeys
+					}
+				});
+			}
+		}
+		return true;
+	}).meta({ stackSchemaInfo: { type: "object" } });
+}
+function yupObject(...args) {
+	return yupObjectWithAutoDefault(...args).default(void 0);
+}
+function yupNever() {
+	return _yupMixedInternal().meta({ stackSchemaInfo: { type: "never" } }).test("never", "This value should never be reached", () => false);
+}
+function yupUnion(...args) {
+	if (args.length === 0) throw new Error("yupUnion must have at least one schema");
+	return _yupMixedInternal().meta({ stackSchemaInfo: {
+		type: "union",
+		items: args
+	} }).test("is-one-of", "Invalid value", async (value, context) => {
+		if (value == null) return true;
+		const errors = [];
+		for (const schema of args) try {
+			await yupValidate(schema, value, context.options);
+			return true;
+		} catch (e) {
+			errors.push(e);
+		}
+		return context.createError({
+			message: __utils_strings_js.deindent`
+        ${context.path} is not matched by any of the provided schemas:
+          ${errors.map((e, i) => __utils_strings_js.deindent`
+            Schema ${i}:
+              ${e.errors.join("\n")}
+          `).join("\n")}`,
+			path: context.path
+		});
+	});
+}
+function yupRecord(keySchema, valueSchema) {
+	return yupObject().meta({ stackSchemaInfo: {
+		type: "record",
+		keySchema,
+		valueSchema
+	} }).unknown(true).test("record", "${path} must be a record of valid values", async function(value, context) {
+		if (value == null) return true;
+		const { path, createError } = this;
+		if (typeof value !== "object") return createError({ message: `${path} must be an object` });
+		for (const key of Object.keys(value)) {
+			await yupValidate(keySchema, key, context.options);
+			try {
+				await yupValidate(valueSchema, value[key], {
+					...context.options,
+					context: {
+						...context.options.context,
+						path: path ? `${path}.${key}` : key
+					}
+				});
+			} catch (e) {
+				return createError({
+					path: path ? `${path}.${key}` : key,
+					message: e.message
+				});
+			}
+		}
+		return true;
+	});
+}
+function ensureObjectSchema(schema) {
+	if (!(schema instanceof yup.ObjectSchema)) throw new __utils_errors_js.HexclaveAssertionError(`assertObjectSchema: schema is not an ObjectSchema: ${schema.describe().type}`);
+	return schema;
+}
+const adaptSchema = yupMixed();
+/**
+* Yup's URL schema does not recognize some URLs (including `http://localhost`) as a valid URL. This schema is a workaround for that.
+*/
+const urlSchema = yupString().test({
+	name: "no-spaces",
+	message: (params) => `${params.path} contains spaces`,
+	test: (value) => value == null || !value.includes(" ")
+}).test({
+	name: "url",
+	message: (params) => `${params.path} is not a valid URL`,
+	test: (value) => value == null || (0, __utils_urls_js.isValidUrl)(value)
+});
+/**
+* URL schema that supports wildcard patterns in hostnames (e.g., "https://*.example.com", "http://*:8080")
+*/
+const wildcardUrlSchema = yupString().test({
+	name: "no-spaces",
+	message: (params) => `${params.path} contains spaces`,
+	test: (value) => value == null || !value.includes(" ")
+}).test({
+	name: "wildcard-url",
+	message: (params) => `${params.path} is not a valid URL or wildcard URL pattern`,
+	test: (value) => {
+		if (value == null) return true;
+		if (!value.includes("*")) return (0, __utils_urls_js.isValidUrl)(value);
+		try {
+			const PLACEHOLDER = "wildcard-placeholder";
+			const normalizedUrl = value.replace(/\*/g, PLACEHOLDER);
+			const url = new URL(normalizedUrl);
+			if (url.username.includes(PLACEHOLDER) || url.password.includes(PLACEHOLDER) || url.pathname.includes(PLACEHOLDER) || url.search.includes(PLACEHOLDER) || url.hash.includes(PLACEHOLDER)) return false;
+			if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+			return (0, __utils_urls_js.isValidHostnameWithWildcards)(url.hostname.split(PLACEHOLDER).join("*"));
+		} catch (e) {
+			return false;
+		}
+	}
+});
+const wildcardProtocolAndDomainSchema = wildcardUrlSchema.test({
+	name: "is-protocol-and-domain",
+	message: (params) => `${params.path} must be a protocol and domain (with optional port) without any path, query parameters, or hash`,
+	test: (value) => {
+		if (value == null) return true;
+		try {
+			const normalized = value.replace(/\*/g, "wildcard-placeholder");
+			const url = new URL(normalized);
+			return url.protocol !== "" && url.hostname !== "" && url.pathname === "/" && url.search === "" && url.hash === "";
+		} catch (e) {
+			return false;
+		}
+	}
+});
+const jsonSchema = yupMixed().nullable().defined().transform((value) => JSON.parse(JSON.stringify(value)));
+const jsonStringSchema = yupString().test("json", (params) => `${params.path} is not valid JSON`, (value) => {
+	if (value == null) return true;
+	try {
+		JSON.parse(value);
+		return true;
+	} catch (error) {
+		return false;
+	}
+});
+const jsonStringOrEmptySchema = yupString().test("json", (params) => `${params.path} is not valid JSON`, (value) => {
+	if (!value) return true;
+	try {
+		JSON.parse(value);
+		return true;
+	} catch (error) {
+		return false;
+	}
+});
+const base64Schema = yupString().test("is-base64", (params) => `${params.path} is not valid base64`, (value) => {
+	if (value == null) return true;
+	return (0, __utils_bytes_js.isBase64)(value);
+});
+const passwordSchema = yupString().max(70);
+const countryCodeSchema = yupString().transform((value) => typeof value === "string" ? (0, __utils_country_codes_js.normalizeCountryCode)(value) : value).test({
+	name: "country-code",
+	message: (params) => `${params.path} must be a 2-letter country code`,
+	test: (value) => value == null || (0, __utils_country_codes_js.isValidCountryCode)(value)
+});
+(void 0)?.test("countryCodeSchema", async ({ expect }) => {
+	await expect(countryCodeSchema.validate(" us ")).resolves.toBe("US");
+	await expect(countryCodeSchema.validate("usa")).rejects.toThrow("must be a 2-letter country code");
+});
+const intervalSchema = yupTuple([yupNumber().min(0).integer().defined(), yupString().oneOf([
+	"millisecond",
+	"second",
+	"minute",
+	"hour",
+	"day",
+	"week",
+	"month",
+	"year"
+]).defined()]);
+const dayIntervalSchema = yupTuple([yupNumber().min(0).integer().defined(), yupString().oneOf([
+	"day",
+	"week",
+	"month",
+	"year"
+]).defined()]);
+const intervalOrNeverSchema = yupUnion(intervalSchema.defined(), yupString().oneOf(["never"]).defined());
+const dayIntervalOrNeverSchema = yupUnion(dayIntervalSchema.defined(), yupString().oneOf(["never"]).defined());
+/**
+* This schema is useful for fields where the user can specify the ID, such as price IDs. It is particularly common
+* for IDs in the config schema.
+*
+* Valid IDs:
+* - Must contain only letters, numbers, underscores, and hyphens
+* - Must not start with a hyphen
+* - Maximum length of 63 characters
+*/
+const USER_SPECIFIED_ID_PATTERN = /^[a-zA-Z0-9_][a-zA-Z0-9_-]*$/;
+const USER_SPECIFIED_ID_MAX_LENGTH = 63;
+/**
+* Checks if the given string is a valid user-specified ID.
+*/
+function isValidUserSpecifiedId(id) {
+	return id.length > 0 && id.length <= USER_SPECIFIED_ID_MAX_LENGTH && USER_SPECIFIED_ID_PATTERN.test(id);
+}
+/**
+* Gets the error message for an invalid user-specified ID.
+*/
+function getUserSpecifiedIdErrorMessage(idName) {
+	return `${idName} must contain only letters, numbers, underscores, and hyphens, and not start with a hyphen`;
+}
+/**
+* Sanitizes user input to create a valid user-specified ID.
+* Converts to lowercase and replaces invalid characters with hyphens.
+* Strips leading hyphens.
+*/
+function sanitizeUserSpecifiedId(input) {
+	return input.replace(/\s+/g, "-").replace(/[^a-zA-Z0-9_-]/g, "").replace(/^-+/, "");
+}
+const userSpecifiedIdSchema = (idName) => yupString().max(USER_SPECIFIED_ID_MAX_LENGTH).matches(USER_SPECIFIED_ID_PATTERN, getUserSpecifiedIdErrorMessage(idName));
+const moneyAmountSchema = (currency) => yupString().test("money-amount", "Invalid money amount", (value, context) => {
+	if (value == null) return true;
+	const match = value.match(/^([0-9]+)(\.([0-9]+))?$/);
+	if (!match) return context.createError({ message: "Money amount must be in the format of <number> or <number>.<number>" });
+	const whole = match[1];
+	const decimals = match[3];
+	if (decimals && decimals.length > currency.decimals) return context.createError({ message: `Too many decimals; ${currency.code} only has ${currency.decimals} decimals` });
+	if (whole !== "0" && whole.startsWith("0")) return context.createError({ message: "Money amount must not have leading zeros" });
+	return true;
+});
+/**
+* A stricter email schema that does some additional checks for UX input. (Some emails are allowed by the spec, for
+* example `test@localhost` or `abc@gmail`, but almost certainly a user input error.)
+*
+* Note that some users in the DB have an email that doesn't match this regex, so most of the time you should use
+* `emailSchema` instead until we do the DB migration.
+*/
+const strictEmailSchema = (message) => yupString().email(message).max(256).matches(/^[^.]+(\.[^.]+)*@.*\.[^.][^.]+$/, message);
+const emailSchema = yupString().email();
+(void 0)?.test("strictEmailSchema", ({ expect }) => {
+	for (const email of [
+		"a@example.com",
+		"abc@example.com",
+		"a.b@example.com",
+		"throwaway.mail+token@example.com",
+		"email-alt-dash@demo-mail.com",
+		"test-account@weird-domain.net",
+		"%!~&+{}=|`#@domain.test",
+		"admin@a.longtldexample"
+	]) expect(strictEmailSchema(void 0).validateSync(email)).toBe(email);
+	for (const email of [
+		"test@localhost",
+		"test@gmail",
+		"test@gmail.com.a",
+		"test@gmail.a",
+		"test.@example.com",
+		"test..test@example.com",
+		".test@example.com"
+	]) expect(() => strictEmailSchema(void 0).validateSync(email)).toThrow();
+});
+const clientOrHigherAuthTypeSchema = yupString().oneOf([
+	"client",
+	"server",
+	"admin"
+]).defined();
+const serverOrHigherAuthTypeSchema = yupString().oneOf(["server", "admin"]).defined();
+const adminAuthTypeSchema = yupString().oneOf(["admin"]).defined();
+const projectIdSchema = yupString().test((v) => v === void 0 || v === "internal" || (0, __utils_uuids_js.isUuid)(v)).meta({ openapiField: {
+	description: _idDescription("project"),
+	exampleValue: "e0b52f4d-dece-408c-af49-d23061bb0f8d"
+} });
+const projectBranchIdSchema = yupString().nonEmpty().max(255).meta({ openapiField: {
+	description: _idDescription("project branch"),
+	exampleValue: "main"
+} });
+const projectDisplayNameSchema = yupString().meta({ openapiField: {
+	description: _displayNameDescription("project"),
+	exampleValue: "MyMusic"
+} });
+const projectLogoUrlSchema = urlSchema.max(MAX_IMAGE_SIZE_BASE64_BYTES).meta({ openapiField: {
+	description: "URL of the logo for the project. This is usually a close to 1:1 image of the company logo.",
+	exampleValue: "https://example.com/logo.png"
+} });
+const projectLogoFullUrlSchema = urlSchema.max(MAX_IMAGE_SIZE_BASE64_BYTES).meta({ openapiField: {
+	description: "URL of the full logo for the project. This is usually a vertical image with the logo and the company name.",
+	exampleValue: "https://example.com/full-logo.png"
+} });
+const projectLogoDarkModeUrlSchema = urlSchema.max(MAX_IMAGE_SIZE_BASE64_BYTES).meta({ openapiField: {
+	description: "URL of the dark mode logo for the project. This is usually a close to 1:1 image of the company logo optimized for dark backgrounds.",
+	exampleValue: "https://example.com/logo-dark.png"
+} });
+const projectLogoFullDarkModeUrlSchema = urlSchema.max(MAX_IMAGE_SIZE_BASE64_BYTES).meta({ openapiField: {
+	description: "URL of the dark mode full logo for the project. This is usually a vertical image with the logo and the company name optimized for dark backgrounds.",
+	exampleValue: "https://example.com/full-logo-dark.png"
+} });
+const projectDescriptionSchema = yupString().nullable().meta({ openapiField: {
+	description: "A human readable description of the project",
+	exampleValue: "A music streaming service"
+} });
+const projectCreatedAtMillisSchema = yupNumber().meta({ openapiField: {
+	description: _createdAtMillisDescription("project"),
+	exampleValue: 163e10
+} });
+const projectIsProductionModeSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether the project is in production mode",
+	exampleValue: true
+} });
+const projectOnboardingStatusValues = [
+	"config_choice",
+	"apps_selection",
+	"auth_setup",
+	"domain_setup",
+	"email_theme_setup",
+	"payments_setup",
+	"welcome",
+	"completed"
+];
+const projectOnboardingStatusSchema = yupString().oneOf(projectOnboardingStatusValues).meta({ openapiField: {
+	description: "The current dashboard onboarding stage for this project.",
+	exampleValue: "config_choice"
+} });
+const projectConfigIdSchema = yupString().meta({ openapiField: {
+	description: _idDescription("project config"),
+	exampleValue: "d09201f0-54f5-40bd-89ff-6d1815ddad24"
+} });
+const projectAllowLocalhostSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether localhost is allowed as a domain for this project. Should only be allowed in development mode",
+	exampleValue: true
+} });
+const projectCreateTeamOnSignUpSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether a team should be created for each user that signs up",
+	exampleValue: true
+} });
+const projectMagicLinkEnabledSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether magic link authentication is enabled for this project",
+	exampleValue: true
+} });
+const projectPasskeyEnabledSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether passkey authentication is enabled for this project",
+	exampleValue: true
+} });
+const projectClientTeamCreationEnabledSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether client users can create teams",
+	exampleValue: true
+} });
+const projectClientUserDeletionEnabledSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether client users can delete their own account from the client",
+	exampleValue: true
+} });
+const projectSignUpEnabledSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether users can sign up new accounts, or whether they are only allowed to sign in to existing accounts. Regardless of this option, the server API can always create new users with the `POST /users` endpoint.",
+	exampleValue: true
+} });
+const projectCredentialEnabledSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether email password authentication is enabled for this project",
+	exampleValue: true
+} });
+const oauthIdSchema = yupString().oneOf(__utils_oauth_js.allProviders).meta({ openapiField: {
+	description: `OAuth provider ID, one of ${__utils_oauth_js.allProviders.map((x) => `\`${x}\``).join(", ")}`,
+	exampleValue: "google"
+} });
+const oauthEnabledSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether the OAuth provider is enabled. If an provider is first enabled, then disabled, it will be shown in the list but with enabled=false",
+	exampleValue: true
+} });
+const oauthTypeSchema = yupString().oneOf(["shared", "standard"]).meta({ openapiField: {
+	description: "OAuth provider type, one of shared, standard. \"shared\" uses Stack shared OAuth keys and it is only meant for development. \"standard\" uses your own OAuth keys and will show your logo and company name when signing in with the provider.",
+	exampleValue: "standard"
+} });
+const oauthClientIdSchema = yupString().meta({ openapiField: {
+	description: "OAuth client ID. Needs to be specified when using type=\"standard\"",
+	exampleValue: "google-oauth-client-id"
+} });
+const oauthClientSecretSchema = yupString().meta({ openapiField: {
+	description: "OAuth client secret. Needs to be specified when using type=\"standard\"",
+	exampleValue: "google-oauth-client-secret"
+} });
+const oauthFacebookConfigIdSchema = yupString().meta({ openapiField: { description: "The configuration id for Facebook business login (for things like ads and marketing). This is only required if you are using the standard OAuth with Facebook and you are using Facebook business login." } });
+const oauthMicrosoftTenantIdSchema = yupString().meta({ openapiField: { description: "The Microsoft tenant id for Microsoft directory. This is only required if you are using the standard OAuth with Microsoft and you have an Azure AD tenant." } });
+const oauthAppleBundleIdsSchema = yupArray(yupString().defined()).meta({ openapiField: {
+	description: "Apple Bundle IDs for native iOS/macOS apps. Required for native Sign In with Apple (in addition to web Apple OAuth which uses the Client ID/Services ID).",
+	exampleValue: ["com.example.ios", "com.example.macos"]
+} });
+const oauthAppleBundleIdSchema = yupString().defined().meta({ openapiField: {
+	description: "Apple Bundle ID for native iOS/macOS apps.",
+	exampleValue: "com.example.ios"
+} });
+const oauthAccountMergeStrategySchema = yupString().oneOf([
+	"link_method",
+	"raise_error",
+	"allow_duplicates"
+]).meta({ openapiField: {
+	description: "Determines how to handle OAuth logins that match an existing user by email. `link_method` adds the OAuth method to the existing user. `raise_error` rejects the login with an error. `allow_duplicates` creates a new user.",
+	exampleValue: "link_method"
+} });
+const emailTypeSchema = yupString().oneOf(["shared", "standard"]).meta({ openapiField: {
+	description: "Email provider type, one of shared, standard. \"shared\" uses Stack shared email provider and it is only meant for development. \"standard\" uses your own email server and will have your email address as the sender.",
+	exampleValue: "standard"
+} });
+const emailSenderNameSchema = yupString().meta({ openapiField: {
+	description: "Email sender name. Needs to be specified when using type=\"standard\"",
+	exampleValue: "Stack"
+} });
+const emailHostSchema = yupString().meta({ openapiField: {
+	description: "Email host. Needs to be specified when using type=\"standard\"",
+	exampleValue: "smtp.your-domain.com"
+} });
+const emailPortSchema = yupNumber().min(0).max(65535).meta({ openapiField: {
+	description: "Email port. Needs to be specified when using type=\"standard\"",
+	exampleValue: 587
+} });
+const emailUsernameSchema = yupString().meta({ openapiField: {
+	description: "Email username. Needs to be specified when using type=\"standard\"",
+	exampleValue: "smtp-email"
+} });
+const emailSenderEmailSchema = emailSchema.meta({ openapiField: {
+	description: "Email sender email. Needs to be specified when using type=\"standard\"",
+	exampleValue: "example@your-domain.com"
+} });
+const emailPasswordSchema = passwordSchema.meta({ openapiField: {
+	description: "Email password. Needs to be specified when using type=\"standard\"",
+	exampleValue: "your-email-password"
+} });
+const handlerPathSchema = yupString().test("is-handler-path", "Handler path must start with /", (value) => value?.startsWith("/")).meta({ openapiField: {
+	description: "Handler path. If you did not setup a custom handler path, it should be \"/handler\" by default. It needs to start with /",
+	exampleValue: "/handler"
+} });
+const emailThemeSchema = yupString().meta({ openapiField: { description: "Email theme id for the project. Determines the visual style of emails sent by the project." } });
+const emailThemeListSchema = yupRecord(yupString().uuid(), yupObject({
+	displayName: yupString().meta({ openapiField: {
+		description: "Email theme name",
+		exampleValue: "Default Light"
+	} }).defined(),
+	tsxSource: yupString().meta({ openapiField: { description: "Email theme source code tsx component" } }).defined()
+})).meta({ openapiField: { description: "Record of email theme IDs to their display name and source code" } });
+const templateThemeIdSchema = yupMixed().test((v) => v === void 0 || v === false || v === null || typeof v === "string" && (0, __utils_uuids_js.isUuid)(v)).meta({ openapiField: { description: "Email theme id for the template" } }).optional();
+const emailTemplateListSchema = yupRecord(yupString().uuid(), yupObject({
+	displayName: yupString().meta({ openapiField: {
+		description: "Email template name",
+		exampleValue: "Email Verification"
+	} }).defined(),
+	tsxSource: yupString().meta({ openapiField: { description: "Email template source code tsx component" } }).defined(),
+	themeId: templateThemeIdSchema
+})).meta({ openapiField: { description: "Record of email template IDs to their display name and source code" } });
+const customDashboardsSchema = yupRecord(yupString().uuid(), yupObject({
+	displayName: yupString().meta({ openapiField: {
+		description: "Custom dashboard name",
+		exampleValue: "User Growth Dashboard"
+	} }).defined(),
+	tsxSource: yupString().meta({ openapiField: { description: "Custom dashboard source code tsx component" } }).defined()
+})).meta({ openapiField: { description: "Record of custom dashboard IDs to their display name and source code" } });
+const customerTypeSchema = yupString().oneOf([
+	"user",
+	"team",
+	"custom"
+]);
+const validateHasAtLeastOneSupportedCurrency = (value, context) => {
+	if (!value) return true;
+	if (Object.keys(value).filter((key) => __utils_currency_constants_js.SUPPORTED_CURRENCIES.some((c) => c.code === key)).length === 0) return context.createError({ message: "At least one currency is required" });
+	return true;
+};
+const productPriceSchema = yupObject({
+	...(0, __utils_objects_js.typedFromEntries)(__utils_currency_constants_js.SUPPORTED_CURRENCIES.map((currency) => [currency.code, moneyAmountSchema(currency).optional()])),
+	interval: dayIntervalSchema.optional(),
+	serverOnly: yupBoolean(),
+	freeTrial: dayIntervalSchema.optional()
+}).test("at-least-one-currency", (value, context) => validateHasAtLeastOneSupportedCurrency(value, context));
+const pricesSchema = yupRecord(userSpecifiedIdSchema("priceId"), productPriceSchema);
+const productSchema = yupObject({
+	displayName: yupString(),
+	productLineId: userSpecifiedIdSchema("productLineId").optional().meta({ openapiField: {
+		description: "The ID of the product line this product belongs to. Within a product line, all products are mutually exclusive unless they are an add-on to another product in the product line.",
+		exampleValue: "product-line-id"
+	} }),
+	isAddOnTo: yupUnion(yupBoolean().isFalse(), yupRecord(userSpecifiedIdSchema("productId"), yupBoolean().isTrue().defined())).optional().meta({ openapiField: {
+		description: "The products that this product is an add-on to. If this is set, the customer must already have one of the products in the record to be able to purchase this product.",
+		exampleValue: { "product-id": true }
+	} }),
+	customerType: customerTypeSchema.defined(),
+	freeTrial: dayIntervalSchema.optional(),
+	serverOnly: yupBoolean(),
+	stackable: yupBoolean(),
+	prices: pricesSchema.defined(),
+	includedItems: yupRecord(userSpecifiedIdSchema("itemId"), yupObject({
+		quantity: yupNumber().defined(),
+		repeat: dayIntervalOrNeverSchema.optional(),
+		expires: yupString().oneOf([
+			"never",
+			"when-purchase-expires",
+			"when-repeated"
+		]).optional()
+	}))
+});
+const productMetadataExample = {
+	featureFlag: true,
+	source: "marketing-campaign"
+};
+const productClientMetadataSchema = jsonSchema.meta({ openapiField: {
+	description: _clientMetaDataDescription("product"),
+	exampleValue: productMetadataExample
+} });
+const productClientReadOnlyMetadataSchema = jsonSchema.meta({ openapiField: {
+	description: _clientReadOnlyMetaDataDescription("product"),
+	exampleValue: productMetadataExample
+} });
+const productServerMetadataSchema = jsonSchema.meta({ openapiField: {
+	description: _serverMetaDataDescription("product"),
+	exampleValue: productMetadataExample
+} });
+const productSchemaWithMetadata = productSchema.concat(yupObject({
+	clientMetadata: productClientMetadataSchema.optional(),
+	clientReadOnlyMetadata: productClientReadOnlyMetadataSchema.optional(),
+	serverMetadata: productServerMetadataSchema.optional()
+}));
+const inlineProductSchema = yupObject({
+	display_name: yupString().defined(),
+	customer_type: customerTypeSchema.defined(),
+	free_trial: dayIntervalSchema.optional(),
+	server_only: yupBoolean().default(true),
+	stackable: yupBoolean().default(false),
+	prices: yupRecord(userSpecifiedIdSchema("priceId"), yupObject({
+		...(0, __utils_objects_js.typedFromEntries)(__utils_currency_constants_js.SUPPORTED_CURRENCIES.map((currency) => [currency.code, moneyAmountSchema(currency).optional()])),
+		interval: dayIntervalSchema.optional(),
+		free_trial: dayIntervalSchema.optional()
+	}).test("at-least-one-currency", (value, context) => validateHasAtLeastOneSupportedCurrency(value, context))),
+	included_items: yupRecord(userSpecifiedIdSchema("itemId"), yupObject({
+		quantity: yupNumber(),
+		repeat: dayIntervalOrNeverSchema.optional(),
+		expires: yupString().oneOf([
+			"never",
+			"when-purchase-expires",
+			"when-repeated"
+		]).optional()
+	})),
+	client_metadata: productClientMetadataSchema.optional(),
+	client_read_only_metadata: productClientReadOnlyMetadataSchema.optional(),
+	server_metadata: productServerMetadataSchema.optional()
+});
+var ReplaceFieldWithOwnUserId = class extends Error {
+	constructor(path) {
+		super(`This error should be caught by whoever validated the schema, and the field in the path '${path}' should be replaced with the current user's id. This is a workaround to yup not providing access to the context inside the transform function.`);
+		this.path = path;
+	}
+};
+const userIdMeSentinelUuid = "cad564fd-f81b-43f4-b390-98abf3fcc17e";
+const userIdOrMeSchema = yupString().uuid().transform((v) => {
+	if (v === "me") return userIdMeSentinelUuid;
+	else return v;
+}).test((v, context) => {
+	if (!("stackAllowUserIdMe" in (context.options.context ?? {}))) throw new __utils_errors_js.HexclaveAssertionError("userIdOrMeSchema is not allowed in this context. Make sure you're using yupValidate from schema-fields.ts to validate, instead of schema.validate(...).");
+	if (!context.options.context?.stackAllowUserIdMe) throw new __utils_errors_js.HexclaveAssertionError("userIdOrMeSchema is not allowed in this context. Make sure you're passing in the currentUserId option in yupValidate.");
+	if (v === userIdMeSentinelUuid) throw new ReplaceFieldWithOwnUserId(context.path);
+	return true;
+}).meta({ openapiField: {
+	description: "The ID of the user, or the special value `me` for the currently authenticated user",
+	exampleValue: "3241a285-8329-4d69-8f3d-316e08cf140c"
+} });
+const userIdSchema = yupString().uuid().meta({ openapiField: {
+	description: _idDescription("user"),
+	exampleValue: "3241a285-8329-4d69-8f3d-316e08cf140c"
+} });
+const primaryEmailSchema = emailSchema.meta({ openapiField: {
+	description: "Primary email",
+	exampleValue: "johndoe@example.com"
+} });
+const primaryEmailAuthEnabledSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether the primary email is used for authentication. If this is set to `false`, the user will not be able to sign in with the primary email with password or OTP",
+	exampleValue: true
+} });
+const primaryEmailVerifiedSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether the primary email has been verified to belong to this user",
+	exampleValue: true
+} });
+const userDisplayNameSchema = yupString().nullable().max(256).meta({ openapiField: {
+	description: _displayNameDescription("user"),
+	exampleValue: "John Doe"
+} });
+const selectedTeamIdSchema = yupString().uuid().meta({ openapiField: {
+	description: "ID of the team currently selected by the user",
+	exampleValue: "team-id"
+} });
+const profileImageUrlSchema = urlSchema.max(MAX_IMAGE_SIZE_BASE64_BYTES).meta({ openapiField: {
+	description: _profileImageUrlDescription("user"),
+	exampleValue: "https://example.com/image.jpg"
+} });
+const signedUpAtMillisSchema = yupNumber().meta({ openapiField: {
+	description: _signedUpAtMillisDescription,
+	exampleValue: 163e10
+} });
+const userClientMetadataSchema = jsonSchema.meta({ openapiField: {
+	description: _clientMetaDataDescription("user"),
+	exampleValue: { key: "value" }
+} });
+const userClientReadOnlyMetadataSchema = jsonSchema.meta({ openapiField: {
+	description: _clientReadOnlyMetaDataDescription("user"),
+	exampleValue: { key: "value" }
+} });
+const userServerMetadataSchema = jsonSchema.meta({ openapiField: {
+	description: _serverMetaDataDescription("user"),
+	exampleValue: { key: "value" }
+} });
+const userOAuthProviderSchema = yupObject({
+	id: yupString().defined(),
+	type: yupString().oneOf(__utils_oauth_js.allProviders).defined(),
+	provider_user_id: yupString().defined()
+});
+const userLastActiveAtMillisSchema = yupNumber().nullable().meta({ openapiField: {
+	description: _lastActiveAtMillisDescription,
+	exampleValue: 163e10
+} });
+const userPasskeyAuthEnabledSchema = yupBoolean().meta({ openapiField: {
+	hidden: true,
+	description: "Whether the user has passkeys enabled",
+	exampleValue: false
+} });
+const userOtpAuthEnabledSchema = yupBoolean().meta({ openapiField: {
+	hidden: true,
+	description: "Whether the user has OTP/magic link enabled. ",
+	exampleValue: true
+} });
+const userOtpAuthEnabledMutationSchema = yupBoolean().meta({ openapiField: {
+	hidden: true,
+	description: "Whether the user has OTP/magic link enabled. Note that only accounts with verified emails can sign-in with OTP.",
+	exampleValue: true
+} });
+const userHasPasswordSchema = yupBoolean().meta({ openapiField: {
+	hidden: true,
+	description: "Whether the user has a password set. If the user does not have a password set, they will not be able to sign in with email/password.",
+	exampleValue: true
+} });
+const userPasswordMutationSchema = passwordSchema.nullable().meta({ openapiField: {
+	description: "Sets the user's password. Doing so revokes all current sessions.",
+	exampleValue: "my-new-password"
+} }).max(70);
+const userPasswordHashMutationSchema = yupString().nonEmpty().meta({ openapiField: { description: "If `password` is not given, sets the user's password hash to the given string in Modular Crypt Format (ex.: `$2a$10$VIhIOofSMqGdGlL4wzE//e.77dAQGqNtF/1dT7bqCrVtQuInWy2qi`). Doing so revokes all current sessions." } });
+const userTotpSecretMutationSchema = base64Schema.nullable().meta({ openapiField: {
+	description: "Enables 2FA and sets a TOTP secret for the user. Set to null to disable 2FA.",
+	exampleValue: "dG90cC1zZWNyZXQ="
+} });
+const restrictedReasonTypes = [
+	"anonymous",
+	"email_not_verified",
+	"restricted_by_administrator"
+];
+const restrictedReasonSchema = yupObject({ type: yupString().oneOf(restrictedReasonTypes).defined() });
+const accessTokenPayloadSchema = yupObject({
+	sub: yupString().defined(),
+	exp: yupNumber().optional(),
+	iat: yupNumber().defined(),
+	iss: yupString().defined(),
+	aud: yupString().defined(),
+	project_id: yupString().defined(),
+	branch_id: yupString().defined(),
+	refresh_token_id: yupString().defined(),
+	role: yupString().oneOf(["authenticated"]).defined(),
+	name: yupString().defined().nullable(),
+	email: yupString().defined().nullable(),
+	email_verified: yupBoolean().defined(),
+	selected_team_id: yupString().defined().nullable(),
+	signed_up_at: yupNumber().defined(),
+	is_anonymous: yupBoolean().defined(),
+	is_restricted: yupBoolean().defined(),
+	restricted_reason: restrictedReasonSchema.defined().nullable(),
+	requires_totp_mfa: yupBoolean().defined()
+});
+const signInEmailSchema = strictEmailSchema(void 0).meta({ openapiField: {
+	description: "The email to sign in with.",
+	exampleValue: "johndoe@example.com"
+} });
+const emailOtpSignInCallbackUrlSchema = urlSchema.meta({ openapiField: {
+	description: "The base callback URL to construct the magic link from. A query parameter `code` with the verification code will be appended to it. The page should then make a request to the `/auth/otp/sign-in` endpoint.",
+	exampleValue: "https://example.com/handler/magic-link-callback"
+} });
+const emailVerificationCallbackUrlSchema = urlSchema.meta({ openapiField: {
+	description: "The base callback URL to construct a verification link for the verification e-mail. A query parameter `code` with the verification code will be appended to it. The page should then make a request to the `/contact-channels/verify` endpoint.",
+	exampleValue: "https://example.com/handler/email-verification"
+} });
+const accessTokenResponseSchema = yupString().meta({ openapiField: {
+	description: "Short-lived access token that can be used to authenticate the user",
+	exampleValue: "eyJhmMiJB2TO...diI4QT"
+} });
+const refreshTokenResponseSchema = yupString().meta({ openapiField: {
+	description: "Long-lived refresh token that can be used to obtain a new access token",
+	exampleValue: "i8ns3aq2...14y"
+} });
+const signInResponseSchema = yupObject({
+	refresh_token: refreshTokenResponseSchema.defined(),
+	access_token: accessTokenResponseSchema.defined(),
+	is_new_user: yupBoolean().meta({ openapiField: {
+		description: "Whether the user is a new user",
+		exampleValue: true
+	} }).defined(),
+	user_id: userIdSchema.defined()
+});
+const teamSystemPermissions = [
+	"$update_team",
+	"$delete_team",
+	"$read_members",
+	"$remove_members",
+	"$invite_members",
+	"$manage_api_keys"
+];
+const permissionDefinitionIdSchema = yupString().matches(/^\$?[a-z0-9_:]+$/, "Only lowercase letters, numbers, \":\", \"_\" and optional \"$\" at the beginning are allowed").test("is-system-permission", "System permissions must start with a dollar sign", (value, ctx) => {
+	if (!value) return true;
+	if (value.startsWith("$") && !teamSystemPermissions.includes(value)) return ctx.createError({ message: "Invalid system permission" });
+	return true;
+}).meta({ openapiField: {
+	description: `The permission ID used to uniquely identify a permission. Can either be a custom permission with lowercase letters, numbers, \`:\`, and \`_\` characters, or one of the system permissions: ${teamSystemPermissions.map((x) => `\`${x}\``).join(", ")}`,
+	exampleValue: "read_secret_info"
+} });
+const customPermissionDefinitionIdSchema = yupString().matches(/^[a-z0-9_:]+$/, "Only lowercase letters, numbers, \":\", \"_\" are allowed").meta({ openapiField: {
+	description: "The permission ID used to uniquely identify a permission. Can only contain lowercase letters, numbers, \":\", and \"_\" characters",
+	exampleValue: "read_secret_info"
+} });
+const teamPermissionDescriptionSchema = yupString().meta({ openapiField: {
+	description: "A human-readable description of the permission",
+	exampleValue: "Read secret information"
+} });
+const containedPermissionIdsSchema = yupArray(permissionDefinitionIdSchema.defined()).meta({ openapiField: {
+	description: "The IDs of the permissions that are contained in this permission",
+	exampleValue: ["read_public_info"]
+} });
+const teamIdSchema = yupString().uuid().meta({ openapiField: {
+	description: _idDescription("team"),
+	exampleValue: "ad962777-8244-496a-b6a2-e0c6a449c79e"
+} });
+const teamDisplayNameSchema = yupString().meta({ openapiField: {
+	description: _displayNameDescription("team"),
+	exampleValue: "My Team"
+} });
+const teamProfileImageUrlSchema = urlSchema.max(1e6).meta({ openapiField: {
+	description: _profileImageUrlDescription("team"),
+	exampleValue: "https://example.com/image.jpg"
+} });
+const teamClientMetadataSchema = jsonSchema.meta({ openapiField: {
+	description: _clientMetaDataDescription("team"),
+	exampleValue: { key: "value" }
+} });
+const teamClientReadOnlyMetadataSchema = jsonSchema.meta({ openapiField: {
+	description: _clientReadOnlyMetaDataDescription("team"),
+	exampleValue: { key: "value" }
+} });
+const teamServerMetadataSchema = jsonSchema.meta({ openapiField: {
+	description: _serverMetaDataDescription("team"),
+	exampleValue: { key: "value" }
+} });
+const teamCreatedAtMillisSchema = yupNumber().meta({ openapiField: {
+	description: _createdAtMillisDescription("team"),
+	exampleValue: 163e10
+} });
+const teamInvitationEmailSchema = emailSchema.meta({ openapiField: {
+	description: "The email of the user to invite.",
+	exampleValue: "johndoe@example.com"
+} });
+const teamInvitationCallbackUrlSchema = urlSchema.meta({ openapiField: {
+	description: "The base callback URL to construct an invite link with. A query parameter `code` with the verification code will be appended to it. The page should then make a request to the `/team-invitations/accept` endpoint.",
+	exampleValue: "https://example.com/handler/team-invitation"
+} });
+const teamCreatorUserIdSchema = userIdOrMeSchema.meta({ openapiField: {
+	description: "The ID of the creator of the team. If not specified, the user will not be added to the team. Can be either \"me\" or the ID of the user. Only used on the client side.",
+	exampleValue: "me"
+} });
+const teamMemberDisplayNameSchema = yupString().meta({ openapiField: {
+	description: _displayNameDescription("team member") + " Note that this is separate from the display_name of the user.",
+	exampleValue: "John Doe"
+} });
+const teamMemberProfileImageUrlSchema = urlSchema.max(1e6).meta({ openapiField: {
+	description: _profileImageUrlDescription("team member"),
+	exampleValue: "https://example.com/image.jpg"
+} });
+const contactChannelIdSchema = yupString().uuid().meta({ openapiField: {
+	description: _idDescription("contact channel"),
+	exampleValue: "b3d396b8-c574-4c80-97b3-50031675ceb2"
+} });
+const contactChannelTypeSchema = yupString().oneOf(["email"]).meta({ openapiField: {
+	description: `The type of the contact channel. Currently only "email" is supported.`,
+	exampleValue: "email"
+} });
+const contactChannelValueSchema = yupString().when("type", {
+	is: "email",
+	then: (schema) => schema.email()
+}).meta({ openapiField: {
+	description: "The value of the contact channel. For email, this should be a valid email address.",
+	exampleValue: "johndoe@example.com"
+} });
+const contactChannelUsedForAuthSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether the contact channel is used for authentication. If this is set to `true`, the user will be able to sign in with the contact channel with password or OTP.",
+	exampleValue: true
+} });
+const contactChannelIsVerifiedSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether the contact channel has been verified. If this is set to `true`, the contact channel has been verified to belong to the user.",
+	exampleValue: true
+} });
+const contactChannelIsPrimarySchema = yupBoolean().meta({ openapiField: {
+	description: "Whether the contact channel is the primary contact channel. If this is set to `true`, it will be used for authentication and notifications by default.",
+	exampleValue: true
+} });
+const oauthProviderIdSchema = yupString().uuid().meta({ openapiField: {
+	description: _idDescription("OAuth provider"),
+	exampleValue: "b3d396b8-c574-4c80-97b3-50031675ceb2"
+} });
+const oauthProviderEmailSchema = emailSchema.meta({ openapiField: {
+	description: "Email of the OAuth provider. This is used to display and identify the OAuth provider in the UI.",
+	exampleValue: "test@gmail.com"
+} });
+const oauthProviderTypeSchema = yupString().oneOf(__utils_oauth_js.allProviders).meta({ openapiField: {
+	description: `OAuth provider type, one of ${__utils_oauth_js.allProviders.map((x) => `\`${x}\``).join(", ")}`,
+	exampleValue: "google"
+} });
+const oauthProviderAllowSignInSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether the user can use this OAuth provider to sign in. Only one OAuth provider per type can have this set to `true`.",
+	exampleValue: true
+} });
+const oauthProviderAllowConnectedAccountsSchema = yupBoolean().meta({ openapiField: {
+	description: "Whether the user can use this OAuth provider as connected account. Multiple OAuth providers per type can have this set to `true`.",
+	exampleValue: true
+} });
+const oauthProviderAccountIdSchema = yupString().meta({ openapiField: {
+	description: "Account ID of the OAuth provider. This uniquely identifies the account on the provider side.",
+	exampleValue: "google-account-id-12345"
+} });
+const oauthProviderProviderConfigIdSchema = yupString().meta({ openapiField: {
+	description: "Provider config ID of the OAuth provider. This uniquely identifies the provider config on config.json file",
+	exampleValue: "google"
+} });
+const basicAuthorizationHeaderSchema = yupString().test("is-basic-authorization-header", "Authorization header must be in the format \"Basic <base64>\"", (value) => {
+	if (!value) return true;
+	return (0, __utils_http_js.decodeBasicAuthorizationHeader)(value) !== null;
+});
+const neonAuthorizationHeaderSchema = basicAuthorizationHeaderSchema.test("is-authorization-header", "Invalid client_id:client_secret values; did you use the correct values for the integration?", (value) => {
+	if (!value) return true;
+	const decoded = (0, __utils_http_js.decodeBasicAuthorizationHeader)(value);
+	if (decoded === null) return true;
+	const [clientId, clientSecret] = decoded;
+	for (const neonClientConfig of JSON.parse((0, __utils_env_js.getProcessEnv)("STACK_INTEGRATION_CLIENTS_CONFIG") || "[]")) if (clientId === neonClientConfig.client_id && clientSecret === neonClientConfig.client_secret) return true;
+	return false;
+});
+(void 0)?.test("neonAuthorizationHeaderSchema handles malformed Basic auth as a validation error", async ({ expect }) => {
+	await expect(neonAuthorizationHeaderSchema.validate("Basic", { abortEarly: false })).rejects.toThrow("Authorization header must be in the format \"Basic <base64>\"");
+});
+function yupDefinedWhen(schema, triggers) {
+	const entries = Object.entries(triggers);
+	return schema.when(entries.map(([key]) => key), {
+		is: (...values) => entries.every(([key, value], index) => value === values[index]),
+		then: (schema) => schema.defined(),
+		otherwise: (schema) => schema.optional()
+	});
+}
+function yupDefinedAndNonEmptyWhen(schema, triggers) {
+	const entries = Object.entries(triggers);
+	return schema.when(entries.map(([key]) => key), {
+		is: (...values) => entries.every(([key, value], index) => value === values[index]),
+		then: (schema) => schema.defined().nonEmpty(),
+		otherwise: (schema) => schema.optional()
+	});
+}
+const branchConfigSourceSchema = yupUnion(yupObject({
+	type: yupString().oneOf(["pushed-from-github"]).defined(),
+	owner: yupString().defined(),
+	repo: yupString().defined(),
+	branch: yupString().defined(),
+	commit_hash: yupString().defined(),
+	config_file_path: yupString().defined(),
+	workflow_path: yupString().optional()
+}), yupObject({ type: yupString().oneOf(["pushed-from-unknown"]).defined() }), yupObject({ type: yupString().oneOf(["unlinked"]).defined() }));
+
+//#endregion
+exports.ReplaceFieldWithOwnUserId = ReplaceFieldWithOwnUserId;
+exports.USER_SPECIFIED_ID_MAX_LENGTH = USER_SPECIFIED_ID_MAX_LENGTH;
+exports.USER_SPECIFIED_ID_PATTERN = USER_SPECIFIED_ID_PATTERN;
+exports.accessTokenPayloadSchema = accessTokenPayloadSchema;
+exports.accessTokenResponseSchema = accessTokenResponseSchema;
+exports.adaptSchema = adaptSchema;
+exports.adminAuthTypeSchema = adminAuthTypeSchema;
+exports.base64Schema = base64Schema;
+exports.basicAuthorizationHeaderSchema = basicAuthorizationHeaderSchema;
+exports.branchConfigSourceSchema = branchConfigSourceSchema;
+exports.clientOrHigherAuthTypeSchema = clientOrHigherAuthTypeSchema;
+exports.contactChannelIdSchema = contactChannelIdSchema;
+exports.contactChannelIsPrimarySchema = contactChannelIsPrimarySchema;
+exports.contactChannelIsVerifiedSchema = contactChannelIsVerifiedSchema;
+exports.contactChannelTypeSchema = contactChannelTypeSchema;
+exports.contactChannelUsedForAuthSchema = contactChannelUsedForAuthSchema;
+exports.contactChannelValueSchema = contactChannelValueSchema;
+exports.containedPermissionIdsSchema = containedPermissionIdsSchema;
+exports.countryCodeSchema = countryCodeSchema;
+exports.customDashboardsSchema = customDashboardsSchema;
+exports.customPermissionDefinitionIdSchema = customPermissionDefinitionIdSchema;
+exports.customerTypeSchema = customerTypeSchema;
+exports.dayIntervalOrNeverSchema = dayIntervalOrNeverSchema;
+exports.dayIntervalSchema = dayIntervalSchema;
+exports.emailHostSchema = emailHostSchema;
+exports.emailOtpSignInCallbackUrlSchema = emailOtpSignInCallbackUrlSchema;
+exports.emailPasswordSchema = emailPasswordSchema;
+exports.emailPortSchema = emailPortSchema;
+exports.emailSchema = emailSchema;
+exports.emailSenderEmailSchema = emailSenderEmailSchema;
+exports.emailSenderNameSchema = emailSenderNameSchema;
+exports.emailTemplateListSchema = emailTemplateListSchema;
+exports.emailThemeListSchema = emailThemeListSchema;
+exports.emailThemeSchema = emailThemeSchema;
+exports.emailTypeSchema = emailTypeSchema;
+exports.emailUsernameSchema = emailUsernameSchema;
+exports.emailVerificationCallbackUrlSchema = emailVerificationCallbackUrlSchema;
+exports.ensureObjectSchema = ensureObjectSchema;
+exports.getUserSpecifiedIdErrorMessage = getUserSpecifiedIdErrorMessage;
+exports.handlerPathSchema = handlerPathSchema;
+exports.inlineProductSchema = inlineProductSchema;
+exports.intervalOrNeverSchema = intervalOrNeverSchema;
+exports.intervalSchema = intervalSchema;
+Object.defineProperty(exports, 'isValidCountryCode', {
+  enumerable: true,
+  get: function () {
+    return __utils_country_codes_js.isValidCountryCode;
+  }
+});
+exports.isValidUserSpecifiedId = isValidUserSpecifiedId;
+exports.jsonSchema = jsonSchema;
+exports.jsonStringOrEmptySchema = jsonStringOrEmptySchema;
+exports.jsonStringSchema = jsonStringSchema;
+exports.moneyAmountSchema = moneyAmountSchema;
+exports.neonAuthorizationHeaderSchema = neonAuthorizationHeaderSchema;
+Object.defineProperty(exports, 'normalizeCountryCode', {
+  enumerable: true,
+  get: function () {
+    return __utils_country_codes_js.normalizeCountryCode;
+  }
+});
+exports.oauthAccountMergeStrategySchema = oauthAccountMergeStrategySchema;
+exports.oauthAppleBundleIdSchema = oauthAppleBundleIdSchema;
+exports.oauthAppleBundleIdsSchema = oauthAppleBundleIdsSchema;
+exports.oauthClientIdSchema = oauthClientIdSchema;
+exports.oauthClientSecretSchema = oauthClientSecretSchema;
+exports.oauthEnabledSchema = oauthEnabledSchema;
+exports.oauthFacebookConfigIdSchema = oauthFacebookConfigIdSchema;
+exports.oauthIdSchema = oauthIdSchema;
+exports.oauthMicrosoftTenantIdSchema = oauthMicrosoftTenantIdSchema;
+exports.oauthProviderAccountIdSchema = oauthProviderAccountIdSchema;
+exports.oauthProviderAllowConnectedAccountsSchema = oauthProviderAllowConnectedAccountsSchema;
+exports.oauthProviderAllowSignInSchema = oauthProviderAllowSignInSchema;
+exports.oauthProviderEmailSchema = oauthProviderEmailSchema;
+exports.oauthProviderIdSchema = oauthProviderIdSchema;
+exports.oauthProviderProviderConfigIdSchema = oauthProviderProviderConfigIdSchema;
+exports.oauthProviderTypeSchema = oauthProviderTypeSchema;
+exports.oauthTypeSchema = oauthTypeSchema;
+exports.passwordSchema = passwordSchema;
+exports.permissionDefinitionIdSchema = permissionDefinitionIdSchema;
+exports.pricesSchema = pricesSchema;
+exports.primaryEmailAuthEnabledSchema = primaryEmailAuthEnabledSchema;
+exports.primaryEmailSchema = primaryEmailSchema;
+exports.primaryEmailVerifiedSchema = primaryEmailVerifiedSchema;
+exports.productClientMetadataSchema = productClientMetadataSchema;
+exports.productClientReadOnlyMetadataSchema = productClientReadOnlyMetadataSchema;
+exports.productPriceSchema = productPriceSchema;
+exports.productSchema = productSchema;
+exports.productSchemaWithMetadata = productSchemaWithMetadata;
+exports.productServerMetadataSchema = productServerMetadataSchema;
+exports.profileImageUrlSchema = profileImageUrlSchema;
+exports.projectAllowLocalhostSchema = projectAllowLocalhostSchema;
+exports.projectBranchIdSchema = projectBranchIdSchema;
+exports.projectClientTeamCreationEnabledSchema = projectClientTeamCreationEnabledSchema;
+exports.projectClientUserDeletionEnabledSchema = projectClientUserDeletionEnabledSchema;
+exports.projectConfigIdSchema = projectConfigIdSchema;
+exports.projectCreateTeamOnSignUpSchema = projectCreateTeamOnSignUpSchema;
+exports.projectCreatedAtMillisSchema = projectCreatedAtMillisSchema;
+exports.projectCredentialEnabledSchema = projectCredentialEnabledSchema;
+exports.projectDescriptionSchema = projectDescriptionSchema;
+exports.projectDisplayNameSchema = projectDisplayNameSchema;
+exports.projectIdSchema = projectIdSchema;
+exports.projectIsProductionModeSchema = projectIsProductionModeSchema;
+exports.projectLogoDarkModeUrlSchema = projectLogoDarkModeUrlSchema;
+exports.projectLogoFullDarkModeUrlSchema = projectLogoFullDarkModeUrlSchema;
+exports.projectLogoFullUrlSchema = projectLogoFullUrlSchema;
+exports.projectLogoUrlSchema = projectLogoUrlSchema;
+exports.projectMagicLinkEnabledSchema = projectMagicLinkEnabledSchema;
+exports.projectOnboardingStatusSchema = projectOnboardingStatusSchema;
+exports.projectOnboardingStatusValues = projectOnboardingStatusValues;
+exports.projectPasskeyEnabledSchema = projectPasskeyEnabledSchema;
+exports.projectSignUpEnabledSchema = projectSignUpEnabledSchema;
+exports.refreshTokenResponseSchema = refreshTokenResponseSchema;
+exports.restrictedReasonSchema = restrictedReasonSchema;
+exports.restrictedReasonTypes = restrictedReasonTypes;
+exports.sanitizeUserSpecifiedId = sanitizeUserSpecifiedId;
+exports.selectedTeamIdSchema = selectedTeamIdSchema;
+exports.serverOrHigherAuthTypeSchema = serverOrHigherAuthTypeSchema;
+exports.signInEmailSchema = signInEmailSchema;
+exports.signInResponseSchema = signInResponseSchema;
+exports.signedUpAtMillisSchema = signedUpAtMillisSchema;
+exports.strictEmailSchema = strictEmailSchema;
+exports.teamClientMetadataSchema = teamClientMetadataSchema;
+exports.teamClientReadOnlyMetadataSchema = teamClientReadOnlyMetadataSchema;
+exports.teamCreatedAtMillisSchema = teamCreatedAtMillisSchema;
+exports.teamCreatorUserIdSchema = teamCreatorUserIdSchema;
+exports.teamDisplayNameSchema = teamDisplayNameSchema;
+exports.teamIdSchema = teamIdSchema;
+exports.teamInvitationCallbackUrlSchema = teamInvitationCallbackUrlSchema;
+exports.teamInvitationEmailSchema = teamInvitationEmailSchema;
+exports.teamMemberDisplayNameSchema = teamMemberDisplayNameSchema;
+exports.teamMemberProfileImageUrlSchema = teamMemberProfileImageUrlSchema;
+exports.teamPermissionDescriptionSchema = teamPermissionDescriptionSchema;
+exports.teamProfileImageUrlSchema = teamProfileImageUrlSchema;
+exports.teamServerMetadataSchema = teamServerMetadataSchema;
+exports.teamSystemPermissions = teamSystemPermissions;
+exports.templateThemeIdSchema = templateThemeIdSchema;
+exports.urlSchema = urlSchema;
+exports.userClientMetadataSchema = userClientMetadataSchema;
+exports.userClientReadOnlyMetadataSchema = userClientReadOnlyMetadataSchema;
+exports.userDisplayNameSchema = userDisplayNameSchema;
+exports.userHasPasswordSchema = userHasPasswordSchema;
+exports.userIdOrMeSchema = userIdOrMeSchema;
+exports.userIdSchema = userIdSchema;
+exports.userLastActiveAtMillisSchema = userLastActiveAtMillisSchema;
+exports.userOAuthProviderSchema = userOAuthProviderSchema;
+exports.userOtpAuthEnabledMutationSchema = userOtpAuthEnabledMutationSchema;
+exports.userOtpAuthEnabledSchema = userOtpAuthEnabledSchema;
+exports.userPasskeyAuthEnabledSchema = userPasskeyAuthEnabledSchema;
+exports.userPasswordHashMutationSchema = userPasswordHashMutationSchema;
+exports.userPasswordMutationSchema = userPasswordMutationSchema;
+exports.userServerMetadataSchema = userServerMetadataSchema;
+exports.userSpecifiedIdSchema = userSpecifiedIdSchema;
+exports.userTotpSecretMutationSchema = userTotpSecretMutationSchema;
+Object.defineProperty(exports, 'validateCountryCode', {
+  enumerable: true,
+  get: function () {
+    return __utils_country_codes_js.validateCountryCode;
+  }
+});
+exports.wildcardProtocolAndDomainSchema = wildcardProtocolAndDomainSchema;
+exports.wildcardUrlSchema = wildcardUrlSchema;
+exports.yupArray = yupArray;
+exports.yupBoolean = yupBoolean;
+exports.yupDate = yupDate;
+exports.yupDefinedAndNonEmptyWhen = yupDefinedAndNonEmptyWhen;
+exports.yupDefinedWhen = yupDefinedWhen;
+exports.yupMixed = yupMixed;
+exports.yupNever = yupNever;
+exports.yupNumber = yupNumber;
+exports.yupObject = yupObject;
+exports.yupObjectWithAutoDefault = yupObjectWithAutoDefault;
+exports.yupRecord = yupRecord;
+exports.yupString = yupString;
+exports.yupTuple = yupTuple;
+exports.yupUnion = yupUnion;
+exports.yupValidate = yupValidate;
+//# sourceMappingURL=schema-fields.js.map