@hexclave/shared 1.0.41 → 1.0.42

package/dist/config-eval.js

@@ -1,12 +1,11 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('./chunk-BE-pF4vm.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.js");
 let __config_authoring_js = require("./config-authoring.js");
 let fs = require("fs");
 let jiti = require("jiti");
 let path = require("path");
-path = require_chunk.__toESM(path);
+path = require_rolldown_runtime.__toESM(path);
 let __config_rendering_js = require("./config-rendering.js");
-
 //#region src/config-eval.ts
 const jiti$1 = (0, jiti.createJiti)(require("url").pathToFileURL(__filename).href, { moduleCache: false });
 /**
@@ -68,50 +67,9 @@ function evalConfigFileContent(content, filePath) {
 	if (isRecord(config)) return config;
 	throw invalidConfigShape(filePath);
 }
-(void 0)?.test("evalConfigFileContent parses static config exports", ({ expect }) => {
-	expect(evalConfigFileContent(`
-    import type { StackConfig } from "@hexclave/js";
-    export const config: StackConfig = {
-      auth: { allowSignUp: true },
-      payments: { testMode: false },
-    };
-  `, "stack.config.ts")).toMatchInlineSnapshot(`
-    {
-      "auth": {
-        "allowSignUp": true,
-      },
-      "payments": {
-        "testMode": false,
-      },
-    }
-  `);
-});
-(void 0)?.test("evalConfigFileContent parses show-onboarding", ({ expect }) => {
-	expect(evalConfigFileContent("export const config = \"show-onboarding\";", "stack.config.ts")).toBe("show-onboarding");
-});
-(void 0)?.test("evalConfigFileContent rejects content without config export", ({ expect }) => {
-	expect(() => evalConfigFileContent("export const other = {};", "stack.config.ts")).toThrow(/must export/);
-});
-(void 0)?.test("evalConfigFileContent rejects arbitrary string config values", ({ expect }) => {
-	expect(() => evalConfigFileContent("export const config = \"arbitrary-string\";", "stack.config.ts")).toThrow(/must be "show-onboarding"/);
-});
-(void 0)?.test("evalConfigFileContent rejects unresolvable config factories", ({ expect }) => {
-	expect(() => evalConfigFileContent("export const config = makeConfig();", "stack.config.ts")).toThrow();
-});
-(void 0)?.test("evalConfigFileContent rejects missing config import targets", ({ expect }) => {
-	expect(() => evalConfigFileContent(`
-    import missingConfigPart from "./missing-config-part";
-    export const config = { auth: missingConfigPart };
-  `, "/tmp/hexclave-missing-import-config.ts")).toThrow();
-});
-(void 0)?.test("evalConfigFileContent surfaces invalid syntax as a loader error, not ConfigFileEvalError", ({ expect }) => {
-	const evalInvalid = () => evalConfigFileContent("export const config = {", "stack.config.ts");
-	expect(evalInvalid).toThrow();
-	expect(evalInvalid).not.toThrow(ConfigFileEvalError);
-});
-
 //#endregion
 exports.ConfigFileEvalError = ConfigFileEvalError;
 exports.detectImportPackageFromDir = detectImportPackageFromDir;
 exports.evalConfigFileContent = evalConfigFileContent;
+
 //# sourceMappingURL=config-eval.js.map

package/dist/config-eval.js.map

@@ -1 +1 @@
-{"version":3,"file":"config-eval.js","names":[],"sources":["../src/config-eval.ts"],"sourcesContent":["import { existsSync, readFileSync } from \"fs\";\nimport { createJiti } from \"jiti\";\nimport path from \"path\";\nimport { showOnboardingHexclaveConfigValue } from \"./config-authoring\";\nimport { detectConfigImportPackage } from \"./config-rendering\";\n\nconst jiti = createJiti(import.meta.url, { moduleCache: false });\n\n/**\n * Thrown when a config file evaluates successfully but its exported `config`\n * isn't a usable shape (missing, or not an object / \"show-onboarding\" string).\n * Distinct from the underlying loader errors jiti throws, so callers can tell a\n * malformed config apart from a file that simply failed to load.\n */\nexport class ConfigFileEvalError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"ConfigFileEvalError\";\n  }\n}\n\n/**\n * Walks up from `dir` to find the nearest `package.json` and returns the\n * best SDK package to use for the `HexclaveConfig` type import.\n */\nexport function detectImportPackageFromDir(dir: string): string | undefined {\n  let current = dir;\n  while (true) {\n    const pkgPath = path.join(current, \"package.json\");\n    if (existsSync(pkgPath)) {\n      try {\n        const pkg = JSON.parse(readFileSync(pkgPath, \"utf-8\"));\n        const deps = [\n          ...Object.keys(pkg.dependencies ?? {}),\n          ...Object.keys(pkg.devDependencies ?? {}),\n        ];\n        return detectConfigImportPackage(deps);\n      } catch {\n        return undefined;\n      }\n    }\n    const parent = path.dirname(current);\n    if (parent === current) break;\n    current = parent;\n  }\n  return undefined;\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return value != null && typeof value === \"object\" && !Array.isArray(value);\n}\n\n/** A config object, or the `\"show-onboarding\"` sentinel that stands in for one. */\nexport type ParsedConfigValue = Record<string, unknown> | typeof showOnboardingHexclaveConfigValue;\n\nfunction invalidConfigShape(filePath: string): ConfigFileEvalError {\n  return new ConfigFileEvalError(`Invalid config in ${filePath}. The file must export a plain \\`config\\` object or \"${showOnboardingHexclaveConfigValue}\".`);\n}\n\n/**\n * Evaluates config file content using jiti and returns the exported `config`\n * value.\n *\n * WARNING: This executes arbitrary code via `jiti.evalModule` — only use on\n * content that is fully operator-controlled (local filesystem). Never call\n * this on untrusted input (e.g. content fetched from a remote repository).\n */\nexport function evalConfigFileContent(content: string, filePath: string): ParsedConfigValue {\n  if (content.trim() === \"\") return {};\n  const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(filePath);\n  const mod: unknown = jiti.evalModule(content, { filename: resolvedPath });\n  if (!isRecord(mod)) {\n    throw invalidConfigShape(filePath);\n  }\n  const config = mod.config;\n  if (config === undefined) {\n    throw invalidConfigShape(filePath);\n  }\n  if (typeof config === \"string\") {\n    if (config !== showOnboardingHexclaveConfigValue) {\n      throw new ConfigFileEvalError(`Invalid config in ${filePath}. String config values must be \"${showOnboardingHexclaveConfigValue}\", got \"${config}\".`);\n    }\n    return config;\n  }\n  if (isRecord(config)) return config;\n  throw invalidConfigShape(filePath);\n}\n\n// --- inline vitest tests ---\n\nimport.meta.vitest?.test(\"evalConfigFileContent parses static config exports\", ({ expect }) => {\n  expect(evalConfigFileContent(`\n    import type { StackConfig } from \"@hexclave/js\";\n    export const config: StackConfig = {\n      auth: { allowSignUp: true },\n      payments: { testMode: false },\n    };\n  `, \"stack.config.ts\")).toMatchInlineSnapshot(`\n    {\n      \"auth\": {\n        \"allowSignUp\": true,\n      },\n      \"payments\": {\n        \"testMode\": false,\n      },\n    }\n  `);\n});\n\nimport.meta.vitest?.test(\"evalConfigFileContent parses show-onboarding\", ({ expect }) => {\n  expect(evalConfigFileContent('export const config = \"show-onboarding\";', \"stack.config.ts\")).toBe(\"show-onboarding\");\n});\n\nimport.meta.vitest?.test(\"evalConfigFileContent rejects content without config export\", ({ expect }) => {\n  expect(() => evalConfigFileContent(\"export const other = {};\", \"stack.config.ts\")).toThrow(/must export/);\n});\n\nimport.meta.vitest?.test(\"evalConfigFileContent rejects arbitrary string config values\", ({ expect }) => {\n  expect(() => evalConfigFileContent('export const config = \"arbitrary-string\";', \"stack.config.ts\")).toThrow(/must be \"show-onboarding\"/);\n});\n\nimport.meta.vitest?.test(\"evalConfigFileContent rejects unresolvable config factories\", ({ expect }) => {\n  expect(() => evalConfigFileContent(\"export const config = makeConfig();\", \"stack.config.ts\")).toThrow();\n});\n\nimport.meta.vitest?.test(\"evalConfigFileContent rejects missing config import targets\", ({ expect }) => {\n  expect(() => evalConfigFileContent(`\n    import missingConfigPart from \"./missing-config-part\";\n    export const config = { auth: missingConfigPart };\n  `, \"/tmp/hexclave-missing-import-config.ts\")).toThrow();\n});\n\nimport.meta.vitest?.test(\"evalConfigFileContent surfaces invalid syntax as a loader error, not ConfigFileEvalError\", ({ expect }) => {\n  // A malformed file fails inside jiti's parser, so the thrown error is a loader\n  // error — NOT a ConfigFileEvalError. Callers depend on that distinction to route\n  // it to \"Failed to load config file\" rather than \"Invalid config\".\n  const evalInvalid = () => evalConfigFileContent(\"export const config = {\", \"stack.config.ts\");\n  expect(evalInvalid).toThrow();\n  expect(evalInvalid).not.toThrow(ConfigFileEvalError);\n});\n"],"mappings":";;;;;;;;;;AAMA,MAAM,6EAAmC,EAAE,aAAa,OAAO,CAAC;;;;;;;AAQhE,IAAa,sBAAb,cAAyC,MAAM;CAC7C,YAAY,SAAiB;AAC3B,QAAM,QAAQ;AACd,OAAK,OAAO;;;;;;;AAQhB,SAAgB,2BAA2B,KAAiC;CAC1E,IAAI,UAAU;AACd,QAAO,MAAM;EACX,MAAM,UAAU,aAAK,KAAK,SAAS,eAAe;AAClD,yBAAe,QAAQ,CACrB,KAAI;GACF,MAAM,MAAM,KAAK,2BAAmB,SAAS,QAAQ,CAAC;AAKtD,+DAJa,CACX,GAAG,OAAO,KAAK,IAAI,gBAAgB,EAAE,CAAC,EACtC,GAAG,OAAO,KAAK,IAAI,mBAAmB,EAAE,CAAC,CAC1C,CACqC;UAChC;AACN;;EAGJ,MAAM,SAAS,aAAK,QAAQ,QAAQ;AACpC,MAAI,WAAW,QAAS;AACxB,YAAU;;;AAKd,SAAS,SAAS,OAAkD;AAClE,QAAO,SAAS,QAAQ,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,MAAM;;AAM5E,SAAS,mBAAmB,UAAuC;AACjE,QAAO,IAAI,oBAAoB,qBAAqB,SAAS,uDAAuD,wDAAkC,IAAI;;;;;;;;;;AAW5J,SAAgB,sBAAsB,SAAiB,UAAqC;AAC1F,KAAI,QAAQ,MAAM,KAAK,GAAI,QAAO,EAAE;CACpC,MAAM,eAAe,aAAK,WAAW,SAAS,GAAG,WAAW,aAAK,QAAQ,SAAS;CAClF,MAAM,MAAe,OAAK,WAAW,SAAS,EAAE,UAAU,cAAc,CAAC;AACzE,KAAI,CAAC,SAAS,IAAI,CAChB,OAAM,mBAAmB,SAAS;CAEpC,MAAM,SAAS,IAAI;AACnB,KAAI,WAAW,OACb,OAAM,mBAAmB,SAAS;AAEpC,KAAI,OAAO,WAAW,UAAU;AAC9B,MAAI,WAAW,wDACb,OAAM,IAAI,oBAAoB,qBAAqB,SAAS,kCAAkC,wDAAkC,UAAU,OAAO,IAAI;AAEvJ,SAAO;;AAET,KAAI,SAAS,OAAO,CAAE,QAAO;AAC7B,OAAM,mBAAmB,SAAS;;CAKpC,SAAW,KAAC,uDAAyD,EAAA,aAAa;AAChF,QAAO,sBAAsB;;;;;;KAM1B,kBAAkB,CAAC,CAAC,sBAAsB;;;;;;;;;IAS3C;EACF;CAEF,SAAW,KAAC,iDAAgD,EAAA,aAAgB;AAC1E,QAAO,sBAAsB,8CAA4C,kBAAkB,CAAC,CAAC,KAAK,kBAAkB;EACpH;CAEF,SAAW,KAAC,gEAAmE,EAAA,aAAY;AACzF,cAAa,sBAAsB,4BAA4B,kBAAkB,CAAC,CAAC,QAAQ,cAAc;EACzG;CAEF,SAAW,KAAC,iEAAoE,EAAA,aAAY;AAC1F,cAAa,sBAAsB,+CAA6C,kBAAkB,CAAC,CAAC,QAAQ,4BAA4B;EACxI;CAEF,SAAW,KAAC,gEAAgE,EAAA,aAAe;AACzF,cAAa,sBAAsB,uCAAuC,kBAAkB,CAAC,CAAC,SAAS;EACvG;CAEF,SAAW,KAAC,gEAAkE,EAAA,aAAa;AACzF,cAAa,sBAAsB;;;KAGhC,yCAAyC,CAAC,CAAC,SAAS;EACvD;CAEF,SAAW,KAAC,6FAAmF,EAAA,aAAyB;CAItH,MAAM,oBAAoB,sBAAsB,2BAA2B,kBAAkB;AAC7F,QAAO,YAAY,CAAC,SAAS;AAC7B,QAAO,YAAY,CAAC,IAAI,QAAQ,oBAAoB;EACpD"}
+{"version":3,"file":"config-eval.js","names":["jiti","showOnboardingHexclaveConfigValue"],"sources":["../src/config-eval.ts"],"sourcesContent":["import { existsSync, readFileSync } from \"fs\";\nimport { createJiti } from \"jiti\";\nimport path from \"path\";\nimport { showOnboardingHexclaveConfigValue } from \"./config-authoring\";\nimport { detectConfigImportPackage } from \"./config-rendering\";\n\nconst jiti = createJiti(import.meta.url, { moduleCache: false });\n\n/**\n * Thrown when a config file evaluates successfully but its exported `config`\n * isn't a usable shape (missing, or not an object / \"show-onboarding\" string).\n * Distinct from the underlying loader errors jiti throws, so callers can tell a\n * malformed config apart from a file that simply failed to load.\n */\nexport class ConfigFileEvalError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"ConfigFileEvalError\";\n  }\n}\n\n/**\n * Walks up from `dir` to find the nearest `package.json` and returns the\n * best SDK package to use for the `HexclaveConfig` type import.\n */\nexport function detectImportPackageFromDir(dir: string): string | undefined {\n  let current = dir;\n  while (true) {\n    const pkgPath = path.join(current, \"package.json\");\n    if (existsSync(pkgPath)) {\n      try {\n        const pkg = JSON.parse(readFileSync(pkgPath, \"utf-8\"));\n        const deps = [\n          ...Object.keys(pkg.dependencies ?? {}),\n          ...Object.keys(pkg.devDependencies ?? {}),\n        ];\n        return detectConfigImportPackage(deps);\n      } catch {\n        return undefined;\n      }\n    }\n    const parent = path.dirname(current);\n    if (parent === current) break;\n    current = parent;\n  }\n  return undefined;\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return value != null && typeof value === \"object\" && !Array.isArray(value);\n}\n\n/** A config object, or the `\"show-onboarding\"` sentinel that stands in for one. */\nexport type ParsedConfigValue = Record<string, unknown> | typeof showOnboardingHexclaveConfigValue;\n\nfunction invalidConfigShape(filePath: string): ConfigFileEvalError {\n  return new ConfigFileEvalError(`Invalid config in ${filePath}. The file must export a plain \\`config\\` object or \"${showOnboardingHexclaveConfigValue}\".`);\n}\n\n/**\n * Evaluates config file content using jiti and returns the exported `config`\n * value.\n *\n * WARNING: This executes arbitrary code via `jiti.evalModule` — only use on\n * content that is fully operator-controlled (local filesystem). Never call\n * this on untrusted input (e.g. content fetched from a remote repository).\n */\nexport function evalConfigFileContent(content: string, filePath: string): ParsedConfigValue {\n  if (content.trim() === \"\") return {};\n  const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(filePath);\n  const mod: unknown = jiti.evalModule(content, { filename: resolvedPath });\n  if (!isRecord(mod)) {\n    throw invalidConfigShape(filePath);\n  }\n  const config = mod.config;\n  if (config === undefined) {\n    throw invalidConfigShape(filePath);\n  }\n  if (typeof config === \"string\") {\n    if (config !== showOnboardingHexclaveConfigValue) {\n      throw new ConfigFileEvalError(`Invalid config in ${filePath}. String config values must be \"${showOnboardingHexclaveConfigValue}\", got \"${config}\".`);\n    }\n    return config;\n  }\n  if (isRecord(config)) return config;\n  throw invalidConfigShape(filePath);\n}\n\n// --- inline vitest tests ---\n\nimport.meta.vitest?.test(\"evalConfigFileContent parses static config exports\", ({ expect }) => {\n  expect(evalConfigFileContent(`\n    import type { StackConfig } from \"@hexclave/js\";\n    export const config: StackConfig = {\n      auth: { allowSignUp: true },\n      payments: { testMode: false },\n    };\n  `, \"stack.config.ts\")).toMatchInlineSnapshot(`\n    {\n      \"auth\": {\n        \"allowSignUp\": true,\n      },\n      \"payments\": {\n        \"testMode\": false,\n      },\n    }\n  `);\n});\n\nimport.meta.vitest?.test(\"evalConfigFileContent parses show-onboarding\", ({ expect }) => {\n  expect(evalConfigFileContent('export const config = \"show-onboarding\";', \"stack.config.ts\")).toBe(\"show-onboarding\");\n});\n\nimport.meta.vitest?.test(\"evalConfigFileContent rejects content without config export\", ({ expect }) => {\n  expect(() => evalConfigFileContent(\"export const other = {};\", \"stack.config.ts\")).toThrow(/must export/);\n});\n\nimport.meta.vitest?.test(\"evalConfigFileContent rejects arbitrary string config values\", ({ expect }) => {\n  expect(() => evalConfigFileContent('export const config = \"arbitrary-string\";', \"stack.config.ts\")).toThrow(/must be \"show-onboarding\"/);\n});\n\nimport.meta.vitest?.test(\"evalConfigFileContent rejects unresolvable config factories\", ({ expect }) => {\n  expect(() => evalConfigFileContent(\"export const config = makeConfig();\", \"stack.config.ts\")).toThrow();\n});\n\nimport.meta.vitest?.test(\"evalConfigFileContent rejects missing config import targets\", ({ expect }) => {\n  expect(() => evalConfigFileContent(`\n    import missingConfigPart from \"./missing-config-part\";\n    export const config = { auth: missingConfigPart };\n  `, \"/tmp/hexclave-missing-import-config.ts\")).toThrow();\n});\n\nimport.meta.vitest?.test(\"evalConfigFileContent surfaces invalid syntax as a loader error, not ConfigFileEvalError\", ({ expect }) => {\n  // A malformed file fails inside jiti's parser, so the thrown error is a loader\n  // error — NOT a ConfigFileEvalError. Callers depend on that distinction to route\n  // it to \"Failed to load config file\" rather than \"Invalid config\".\n  const evalInvalid = () => evalConfigFileContent(\"export const config = {\", \"stack.config.ts\");\n  expect(evalInvalid).toThrow();\n  expect(evalInvalid).not.toThrow(ConfigFileEvalError);\n});\n"],"mappings":";;;;;;;;;AAMA,MAAMA,UAAAA,GAAAA,KAAAA,WAAAA,CAAAA,QAAAA,KAAAA,CAAAA,CAAAA,cAAAA,UAAAA,CAAAA,CAAAA,MAAmC,EAAE,aAAa,MAAM,CAAC;;;;;;;AAQ/D,IAAa,sBAAb,cAAyC,MAAM;CAC7C,YAAY,SAAiB;EAC3B,MAAM,OAAO;EACb,KAAK,OAAO;CACd;AACF;;;;;AAMA,SAAgB,2BAA2B,KAAiC;CAC1E,IAAI,UAAU;CACd,OAAO,MAAM;EACX,MAAM,UAAU,KAAA,QAAK,KAAK,SAAS,cAAc;EACjD,KAAA,GAAA,GAAA,WAAA,CAAe,OAAO,GACpB,IAAI;GACF,MAAM,MAAM,KAAK,OAAA,GAAA,GAAA,aAAA,CAAmB,SAAS,OAAO,CAAC;GAKrD,QAAA,GAAA,sBAAA,0BAAA,CAAiC,CAH/B,GAAG,OAAO,KAAK,IAAI,gBAAgB,CAAC,CAAC,GACrC,GAAG,OAAO,KAAK,IAAI,mBAAmB,CAAC,CAAC,CAEN,CAAC;EACvC,QAAQ;GACN;EACF;EAEF,MAAM,SAAS,KAAA,QAAK,QAAQ,OAAO;EACnC,IAAI,WAAW,SAAS;EACxB,UAAU;CACZ;AAEF;AAEA,SAAS,SAAS,OAAkD;CAClE,OAAO,SAAS,QAAQ,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK;AAC3E;AAKA,SAAS,mBAAmB,UAAuC;CACjE,OAAO,IAAI,oBAAoB,qBAAqB,SAAS,uDAAuDC,sBAAAA,kCAAkC,GAAG;AAC3J;;;;;;;;;AAUA,SAAgB,sBAAsB,SAAiB,UAAqC;CAC1F,IAAI,QAAQ,KAAK,MAAM,IAAI,OAAO,CAAC;CACnC,MAAM,eAAe,KAAA,QAAK,WAAW,QAAQ,IAAI,WAAW,KAAA,QAAK,QAAQ,QAAQ;CACjF,MAAM,MAAeD,OAAK,WAAW,SAAS,EAAE,UAAU,aAAa,CAAC;CACxE,IAAI,CAAC,SAAS,GAAG,GACf,MAAM,mBAAmB,QAAQ;CAEnC,MAAM,SAAS,IAAI;CACnB,IAAI,WAAW,KAAA,GACb,MAAM,mBAAmB,QAAQ;CAEnC,IAAI,OAAO,WAAW,UAAU;EAC9B,IAAI,WAAWC,sBAAAA,mCACb,MAAM,IAAI,oBAAoB,qBAAqB,SAAS,kCAAkCA,sBAAAA,kCAAkC,UAAU,OAAO,GAAG;EAEtJ,OAAO;CACT;CACA,IAAI,SAAS,MAAM,GAAG,OAAO;CAC7B,MAAM,mBAAmB,QAAQ;AACnC"}

package/dist/config-rendering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config-rendering.d.ts","names":[],"sources":["../src/config-rendering.ts"],"mappings":";;AA4BA;;;;iBAAgB,yBAAA,CAA0B,YAAA;AAY1C;;;AAAA,iBAAgB,uBAAA,CAAwB,MAAA,WAAiB,aAAA"}
+{"version":3,"file":"config-rendering.d.ts","names":[],"sources":["../src/config-rendering.ts"],"mappings":";;AA4BA;;;;iBAAgB,yBAAA,CAA0B,YAAsB;AAYhE;;;AAAA,iBAAgB,uBAAA,CAAwB,MAAA,WAAiB,aAAsB"}

package/dist/config-rendering.js

@@ -1,7 +1,5 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('./chunk-BE-pF4vm.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let __config_format_js = require("./config/format.js");
-
 //#region src/config-rendering.ts
 const DEFAULT_CONFIG_IMPORT_PACKAGE = "@hexclave/js";
 /**
@@ -45,52 +43,8 @@ function renderConfigFileContent(config, importPackage) {
 	const pkg = importPackage ?? DEFAULT_CONFIG_IMPORT_PACKAGE;
 	return `${`import type { HexclaveConfig } from "${pkg.startsWith("@hexclave/") ? `${pkg}/config` : pkg}";`}\n\nexport const config: HexclaveConfig = ${JSON.stringify(normalizedConfig, null, 2)};\n`;
 }
-(void 0)?.test("renderConfigFileContent normalizes config exports", ({ expect }) => {
-	expect(renderConfigFileContent({
-		"payments.items.todos.displayName": "Todo Slots",
-		"payments.items.todos.customerType": "user"
-	})).toContain(`export const config: HexclaveConfig = {
-  "payments": {
-    "items": {
-      "todos": {
-        "displayName": "Todo Slots",
-        "customerType": "user"
-      }
-    }
-  }
-};`);
-});
-(void 0)?.test("renderConfigFileContent rejects conflicting dotted keys", ({ expect }) => {
-	expect(() => renderConfigFileContent({
-		"a.b": 1,
-		"a.b.c": 2
-	})).toThrowError(/conflicting keys.*"a\.b\.c"/);
-});
-(void 0)?.test("renderConfigFileContent rejects invalid config exports", ({ expect }) => {
-	expect(() => renderConfigFileContent(null)).toThrowErrorMatchingInlineSnapshot(`[Error: Invalid config: expected a plain object.]`);
-});
-(void 0)?.test("renderConfigFileContent uses custom import package", ({ expect }) => {
-	expect(renderConfigFileContent({}, "@hexclave/next")).toContain("import type { HexclaveConfig } from \"@hexclave/next/config\";");
-});
-(void 0)?.test("renderConfigFileContent defaults to @hexclave/js", ({ expect }) => {
-	expect(renderConfigFileContent({})).toContain("import type { HexclaveConfig } from \"@hexclave/js/config\";");
-});
-(void 0)?.test("renderConfigFileContent keeps legacy @stackframe packages on their root entrypoint", ({ expect }) => {
-	expect(renderConfigFileContent({}, "@stackframe/next")).toContain("import type { HexclaveConfig } from \"@stackframe/next\";");
-});
-(void 0)?.test("detectConfigImportPackage picks first matching package by priority", ({ expect }) => {
-	expect(detectConfigImportPackage(["@hexclave/next", "@hexclave/js"])).toBe("@hexclave/next");
-	expect(detectConfigImportPackage(["@hexclave/react", "@hexclave/js"])).toBe("@hexclave/react");
-	expect(detectConfigImportPackage(["@hexclave/js"])).toBe("@hexclave/js");
-	expect(detectConfigImportPackage(["@hexclave/tanstack-start"])).toBe("@hexclave/tanstack-start");
-	expect(detectConfigImportPackage(["@stackframe/stack", "@hexclave/next"])).toBe("@hexclave/next");
-	expect(detectConfigImportPackage(["@stackframe/stack"])).toBe("@stackframe/stack");
-	expect(detectConfigImportPackage(["@stackframe/template"])).toBe("@stackframe/template");
-	expect(detectConfigImportPackage(["lodash", "express"])).toBeUndefined();
-	expect(detectConfigImportPackage([])).toBeUndefined();
-});
-
 //#endregion
 exports.detectConfigImportPackage = detectConfigImportPackage;
 exports.renderConfigFileContent = renderConfigFileContent;
+
 //# sourceMappingURL=config-rendering.js.map

package/dist/config-rendering.js.map

@@ -1 +1 @@
-{"version":3,"file":"config-rendering.js","names":[],"sources":["../src/config-rendering.ts"],"sourcesContent":["import { isValidConfig, normalize } from \"./config/format\";\n\nconst DEFAULT_CONFIG_IMPORT_PACKAGE = \"@hexclave/js\";\n\n/**\n * Packages that export the `HexclaveConfig` type, in priority order.\n * The first match found in a project's dependencies wins. Hexclave-branded\n * packages come first (canonical); the legacy `@stackframe/*` names remain\n * so projects pinned to the last legacy release still render a config file\n * that compiles against their installed SDK.\n */\nconst CONFIG_IMPORT_PACKAGES = [\n  \"@hexclave/next\",\n  \"@hexclave/react\",\n  \"@hexclave/tanstack-start\",\n  \"@hexclave/js\",\n  \"@hexclave/template\",\n  \"@stackframe/stack\",\n  \"@stackframe/react\",\n  \"@stackframe/js\",\n  \"@stackframe/template\",\n] as const;\n\n/**\n * Given a list of dependency names (from package.json), returns the SDK\n * package that should be used for the `HexclaveConfig` import, or `undefined`\n * if none of the known packages are installed.\n */\nexport function detectConfigImportPackage(dependencies: string[]): string | undefined {\n  for (const pkg of CONFIG_IMPORT_PACKAGES) {\n    if (dependencies.includes(pkg)) {\n      return pkg;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Renders a config object into the source text of a `stack.config.ts` file.\n */\nexport function renderConfigFileContent(config: unknown, importPackage?: string): string {\n  if (!isValidConfig(config)) {\n    throw new Error(\"Invalid config: expected a plain object.\");\n  }\n\n  const droppedKeys: string[] = [];\n  const normalizedConfig = normalize(config, {\n    onDotIntoNonObject: \"ignore\",\n    onDotIntoNull: \"empty-object\",\n    droppedKeys,\n  });\n  if (droppedKeys.length > 0) {\n    throw new Error(`Config has conflicting keys that would be dropped during normalization: ${droppedKeys.map(k => JSON.stringify(k)).join(\", \")}`);\n  }\n  const pkg = importPackage ?? DEFAULT_CONFIG_IMPORT_PACKAGE;\n  const importSpecifier = pkg.startsWith(\"@hexclave/\") ? `${pkg}/config` : pkg;\n  const importLine = `import type { HexclaveConfig } from \"${importSpecifier}\";`;\n  return `${importLine}\\n\\nexport const config: HexclaveConfig = ${JSON.stringify(normalizedConfig, null, 2)};\\n`;\n}\n\n// --- inline vitest tests ---\n\nimport.meta.vitest?.test(\"renderConfigFileContent normalizes config exports\", ({ expect }) => {\n  expect(renderConfigFileContent({\n    \"payments.items.todos.displayName\": \"Todo Slots\",\n    \"payments.items.todos.customerType\": \"user\",\n  })).toContain(`export const config: HexclaveConfig = {\n  \"payments\": {\n    \"items\": {\n      \"todos\": {\n        \"displayName\": \"Todo Slots\",\n        \"customerType\": \"user\"\n      }\n    }\n  }\n};`);\n});\n\nimport.meta.vitest?.test(\"renderConfigFileContent rejects conflicting dotted keys\", ({ expect }) => {\n  expect(() => renderConfigFileContent({\n    \"a.b\": 1,\n    \"a.b.c\": 2,\n  })).toThrowError(/conflicting keys.*\"a\\.b\\.c\"/);\n});\n\nimport.meta.vitest?.test(\"renderConfigFileContent rejects invalid config exports\", ({ expect }) => {\n  expect(() => renderConfigFileContent(null)).toThrowErrorMatchingInlineSnapshot(\n    `[Error: Invalid config: expected a plain object.]`,\n  );\n});\n\nimport.meta.vitest?.test(\"renderConfigFileContent uses custom import package\", ({ expect }) => {\n  const content = renderConfigFileContent({}, \"@hexclave/next\");\n  expect(content).toContain('import type { HexclaveConfig } from \"@hexclave/next/config\";');\n});\n\nimport.meta.vitest?.test(\"renderConfigFileContent defaults to @hexclave/js\", ({ expect }) => {\n  const content = renderConfigFileContent({});\n  expect(content).toContain('import type { HexclaveConfig } from \"@hexclave/js/config\";');\n});\n\nimport.meta.vitest?.test(\"renderConfigFileContent keeps legacy @stackframe packages on their root entrypoint\", ({ expect }) => {\n  const content = renderConfigFileContent({}, \"@stackframe/next\");\n  expect(content).toContain('import type { HexclaveConfig } from \"@stackframe/next\";');\n});\n\nimport.meta.vitest?.test(\"detectConfigImportPackage picks first matching package by priority\", ({ expect }) => {\n  expect(detectConfigImportPackage([\"@hexclave/next\", \"@hexclave/js\"])).toBe(\"@hexclave/next\");\n  expect(detectConfigImportPackage([\"@hexclave/react\", \"@hexclave/js\"])).toBe(\"@hexclave/react\");\n  expect(detectConfigImportPackage([\"@hexclave/js\"])).toBe(\"@hexclave/js\");\n  expect(detectConfigImportPackage([\"@hexclave/tanstack-start\"])).toBe(\"@hexclave/tanstack-start\");\n  expect(detectConfigImportPackage([\"@stackframe/stack\", \"@hexclave/next\"])).toBe(\"@hexclave/next\");\n  expect(detectConfigImportPackage([\"@stackframe/stack\"])).toBe(\"@stackframe/stack\");\n  expect(detectConfigImportPackage([\"@stackframe/template\"])).toBe(\"@stackframe/template\");\n  expect(detectConfigImportPackage([\"lodash\", \"express\"])).toBeUndefined();\n  expect(detectConfigImportPackage([])).toBeUndefined();\n});\n"],"mappings":";;;;;AAEA,MAAM,gCAAgC;;;;;;;;AAStC,MAAM,yBAAyB;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;;;;;;AAOD,SAAgB,0BAA0B,cAA4C;AACpF,MAAK,MAAM,OAAO,uBAChB,KAAI,aAAa,SAAS,IAAI,CAC5B,QAAO;;;;;AASb,SAAgB,wBAAwB,QAAiB,eAAgC;AACvF,KAAI,uCAAe,OAAO,CACxB,OAAM,IAAI,MAAM,2CAA2C;CAG7D,MAAM,cAAwB,EAAE;CAChC,MAAM,qDAA6B,QAAQ;EACzC,oBAAoB;EACpB,eAAe;EACf;EACD,CAAC;AACF,KAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,2EAA2E,YAAY,KAAI,MAAK,KAAK,UAAU,EAAE,CAAC,CAAC,KAAK,KAAK,GAAG;CAElJ,MAAM,MAAM,iBAAiB;AAG7B,QAAO,GADY,wCADK,IAAI,WAAW,aAAa,GAAG,GAAG,IAAI,WAAW,IACE,IACtD,4CAA4C,KAAK,UAAU,kBAAkB,MAAM,EAAE,CAAC;;CAK7G,SAAW,KAAC,sDAAwD,EAAA,aAAa;AAC/E,QAAO,wBAAwB;EAC7B,oCAAoC;EACpC,qCAAqC;EACtC,CAAC,CAAC,CAAC,UAAU;;;;;;;;;IASZ;EACF;CAEF,SAAW,KAAC,4DAAgE,EAAC,aAAU;AACrF,cAAa,wBAAwB;EACnC,OAAO;EACP,SAAS;EACV,CAAC,CAAC,CAAC,aAAa,8BAA8B;EAC/C;CAEF,SAAW,KAAC,2DAA6D,EAAA,aAAa;AACpF,cAAa,wBAAwB,KAAK,CAAC,CAAC,mCAC1C,oDACD;EACD;CAEF,SAAW,KAAC,uDAAyD,EAAA,aAAa;AAEhF,QADgB,wBAAwB,EAAE,EAAE,iBAAiB,CAC9C,CAAC,UAAU,iEAA+D;EACzF;CAEF,SAAW,KAAC,qDAAmD,EAAQ,aAAS;AAE9E,QADgB,wBAAwB,EAAE,CAAC,CAC5B,CAAC,UAAU,+DAA6D;EACvF;CAEF,SAAW,KAAC,uFAAsF,EAAA,aAAgB;AAEhH,QADgB,wBAAwB,EAAE,EAAE,mBAAmB,CAChD,CAAC,UAAU,4DAA0D;EACpF;CAEF,SAAW,KAAC,uEAAwE,EAAA,aAAc;AAChG,QAAO,0BAA0B,CAAC,kBAAkB,eAAe,CAAC,CAAC,CAAC,KAAK,iBAAiB;AAC5F,QAAO,0BAA0B,CAAC,mBAAmB,eAAe,CAAC,CAAC,CAAC,KAAK,kBAAkB;AAC9F,QAAO,0BAA0B,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,eAAe;AACxE,QAAO,0BAA0B,CAAC,2BAA2B,CAAC,CAAC,CAAC,KAAK,2BAA2B;AAChG,QAAO,0BAA0B,CAAC,qBAAqB,iBAAiB,CAAC,CAAC,CAAC,KAAK,iBAAiB;AACjG,QAAO,0BAA0B,CAAC,oBAAoB,CAAC,CAAC,CAAC,KAAK,oBAAoB;AAClF,QAAO,0BAA0B,CAAC,uBAAuB,CAAC,CAAC,CAAC,KAAK,uBAAuB;AACxF,QAAO,0BAA0B,CAAC,UAAU,UAAU,CAAC,CAAC,CAAC,eAAe;AACxE,QAAO,0BAA0B,EAAE,CAAC,CAAC,CAAC,eAAe;EACrD"}
+{"version":3,"file":"config-rendering.js","names":[],"sources":["../src/config-rendering.ts"],"sourcesContent":["import { isValidConfig, normalize } from \"./config/format\";\n\nconst DEFAULT_CONFIG_IMPORT_PACKAGE = \"@hexclave/js\";\n\n/**\n * Packages that export the `HexclaveConfig` type, in priority order.\n * The first match found in a project's dependencies wins. Hexclave-branded\n * packages come first (canonical); the legacy `@stackframe/*` names remain\n * so projects pinned to the last legacy release still render a config file\n * that compiles against their installed SDK.\n */\nconst CONFIG_IMPORT_PACKAGES = [\n  \"@hexclave/next\",\n  \"@hexclave/react\",\n  \"@hexclave/tanstack-start\",\n  \"@hexclave/js\",\n  \"@hexclave/template\",\n  \"@stackframe/stack\",\n  \"@stackframe/react\",\n  \"@stackframe/js\",\n  \"@stackframe/template\",\n] as const;\n\n/**\n * Given a list of dependency names (from package.json), returns the SDK\n * package that should be used for the `HexclaveConfig` import, or `undefined`\n * if none of the known packages are installed.\n */\nexport function detectConfigImportPackage(dependencies: string[]): string | undefined {\n  for (const pkg of CONFIG_IMPORT_PACKAGES) {\n    if (dependencies.includes(pkg)) {\n      return pkg;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Renders a config object into the source text of a `stack.config.ts` file.\n */\nexport function renderConfigFileContent(config: unknown, importPackage?: string): string {\n  if (!isValidConfig(config)) {\n    throw new Error(\"Invalid config: expected a plain object.\");\n  }\n\n  const droppedKeys: string[] = [];\n  const normalizedConfig = normalize(config, {\n    onDotIntoNonObject: \"ignore\",\n    onDotIntoNull: \"empty-object\",\n    droppedKeys,\n  });\n  if (droppedKeys.length > 0) {\n    throw new Error(`Config has conflicting keys that would be dropped during normalization: ${droppedKeys.map(k => JSON.stringify(k)).join(\", \")}`);\n  }\n  const pkg = importPackage ?? DEFAULT_CONFIG_IMPORT_PACKAGE;\n  const importSpecifier = pkg.startsWith(\"@hexclave/\") ? `${pkg}/config` : pkg;\n  const importLine = `import type { HexclaveConfig } from \"${importSpecifier}\";`;\n  return `${importLine}\\n\\nexport const config: HexclaveConfig = ${JSON.stringify(normalizedConfig, null, 2)};\\n`;\n}\n\n// --- inline vitest tests ---\n\nimport.meta.vitest?.test(\"renderConfigFileContent normalizes config exports\", ({ expect }) => {\n  expect(renderConfigFileContent({\n    \"payments.items.todos.displayName\": \"Todo Slots\",\n    \"payments.items.todos.customerType\": \"user\",\n  })).toContain(`export const config: HexclaveConfig = {\n  \"payments\": {\n    \"items\": {\n      \"todos\": {\n        \"displayName\": \"Todo Slots\",\n        \"customerType\": \"user\"\n      }\n    }\n  }\n};`);\n});\n\nimport.meta.vitest?.test(\"renderConfigFileContent rejects conflicting dotted keys\", ({ expect }) => {\n  expect(() => renderConfigFileContent({\n    \"a.b\": 1,\n    \"a.b.c\": 2,\n  })).toThrowError(/conflicting keys.*\"a\\.b\\.c\"/);\n});\n\nimport.meta.vitest?.test(\"renderConfigFileContent rejects invalid config exports\", ({ expect }) => {\n  expect(() => renderConfigFileContent(null)).toThrowErrorMatchingInlineSnapshot(\n    `[Error: Invalid config: expected a plain object.]`,\n  );\n});\n\nimport.meta.vitest?.test(\"renderConfigFileContent uses custom import package\", ({ expect }) => {\n  const content = renderConfigFileContent({}, \"@hexclave/next\");\n  expect(content).toContain('import type { HexclaveConfig } from \"@hexclave/next/config\";');\n});\n\nimport.meta.vitest?.test(\"renderConfigFileContent defaults to @hexclave/js\", ({ expect }) => {\n  const content = renderConfigFileContent({});\n  expect(content).toContain('import type { HexclaveConfig } from \"@hexclave/js/config\";');\n});\n\nimport.meta.vitest?.test(\"renderConfigFileContent keeps legacy @stackframe packages on their root entrypoint\", ({ expect }) => {\n  const content = renderConfigFileContent({}, \"@stackframe/next\");\n  expect(content).toContain('import type { HexclaveConfig } from \"@stackframe/next\";');\n});\n\nimport.meta.vitest?.test(\"detectConfigImportPackage picks first matching package by priority\", ({ expect }) => {\n  expect(detectConfigImportPackage([\"@hexclave/next\", \"@hexclave/js\"])).toBe(\"@hexclave/next\");\n  expect(detectConfigImportPackage([\"@hexclave/react\", \"@hexclave/js\"])).toBe(\"@hexclave/react\");\n  expect(detectConfigImportPackage([\"@hexclave/js\"])).toBe(\"@hexclave/js\");\n  expect(detectConfigImportPackage([\"@hexclave/tanstack-start\"])).toBe(\"@hexclave/tanstack-start\");\n  expect(detectConfigImportPackage([\"@stackframe/stack\", \"@hexclave/next\"])).toBe(\"@hexclave/next\");\n  expect(detectConfigImportPackage([\"@stackframe/stack\"])).toBe(\"@stackframe/stack\");\n  expect(detectConfigImportPackage([\"@stackframe/template\"])).toBe(\"@stackframe/template\");\n  expect(detectConfigImportPackage([\"lodash\", \"express\"])).toBeUndefined();\n  expect(detectConfigImportPackage([])).toBeUndefined();\n});\n"],"mappings":";;;AAEA,MAAM,gCAAgC;;;;;;;;AAStC,MAAM,yBAAyB;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;AAOA,SAAgB,0BAA0B,cAA4C;CACpF,KAAK,MAAM,OAAO,wBAChB,IAAI,aAAa,SAAS,GAAG,GAC3B,OAAO;AAIb;;;;AAKA,SAAgB,wBAAwB,QAAiB,eAAgC;CACvF,IAAI,EAAA,GAAA,mBAAA,cAAA,CAAe,MAAM,GACvB,MAAM,IAAI,MAAM,0CAA0C;CAG5D,MAAM,cAAwB,CAAC;CAC/B,MAAM,oBAAA,GAAA,mBAAA,UAAA,CAA6B,QAAQ;EACzC,oBAAoB;EACpB,eAAe;EACf;CACF,CAAC;CACD,IAAI,YAAY,SAAS,GACvB,MAAM,IAAI,MAAM,2EAA2E,YAAY,KAAI,MAAK,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG;CAEjJ,MAAM,MAAM,iBAAiB;CAG7B,OAAO,GAAG,wCAFc,IAAI,WAAW,YAAY,IAAI,GAAG,IAAI,WAAW,IACE,IACtD,4CAA4C,KAAK,UAAU,kBAAkB,MAAM,CAAC,EAAE;AAC7G"}

package/dist/connected-accounts-D5CKe50A.d.ts

@@ -0,0 +1,67 @@
+import { c as CrudTypeOf, s as CrudSchemaFromOptions } from "./crud-CqmEW9s6.js";
+
+//#region src/interface/crud/connected-accounts.d.ts
+declare const connectedAccountClientReadSchema: import("yup").ObjectSchema<{
+  user_id: string;
+  provider: string;
+  provider_account_id: string;
+}, import("yup").AnyObject, {
+  user_id: undefined;
+  provider: undefined;
+  provider_account_id: undefined;
+}, "">;
+declare const connectedAccountCrud: CrudSchemaFromOptions<{
+  clientReadSchema: import("yup").ObjectSchema<{
+    user_id: string;
+    provider: string;
+    provider_account_id: string;
+  }, import("yup").AnyObject, {
+    user_id: undefined;
+    provider: undefined;
+    provider_account_id: undefined;
+  }, "">;
+  docs: {
+    clientRead: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+    clientList: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+  };
+}>;
+type ConnectedAccountCrud = CrudTypeOf<typeof connectedAccountCrud>;
+declare const connectedAccountAccessTokenReadSchema: import("yup").ObjectSchema<{
+  access_token: string;
+}, import("yup").AnyObject, {
+  access_token: undefined;
+}, "">;
+declare const connectedAccountAccessTokenCreateSchema: import("yup").ObjectSchema<{
+  scope: string | undefined;
+}, import("yup").AnyObject, {
+  scope: undefined;
+}, "">;
+declare const connectedAccountAccessTokenCrud: CrudSchemaFromOptions<{
+  clientReadSchema: import("yup").ObjectSchema<{
+    access_token: string;
+  }, import("yup").AnyObject, {
+    access_token: undefined;
+  }, "">;
+  clientCreateSchema: import("yup").ObjectSchema<{
+    scope: string | undefined;
+  }, import("yup").AnyObject, {
+    scope: undefined;
+  }, "">;
+  docs: {
+    clientCreate: {
+      hidden: true;
+    };
+  };
+}>;
+type ConnectedAccountAccessTokenCrud = CrudTypeOf<typeof connectedAccountAccessTokenCrud>;
+//#endregion
+export { connectedAccountAccessTokenReadSchema as a, connectedAccountAccessTokenCrud as i, ConnectedAccountCrud as n, connectedAccountClientReadSchema as o, connectedAccountAccessTokenCreateSchema as r, connectedAccountCrud as s, ConnectedAccountAccessTokenCrud as t };
+//# sourceMappingURL=connected-accounts-D5CKe50A.d.ts.map

package/dist/connected-accounts-D5CKe50A.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connected-accounts-D5CKe50A.d.ts","names":[],"sources":["../src/interface/crud/connected-accounts.ts"],"mappings":";;;cAUa,gCAAA,gBAAgC,YAAA;;;;;;;;;cAMhC,oBAAA,EAcX,qBAd+B;;;;;;;;;;;;;;;;;;;;;;;KAerB,oBAAA,GAAuB,UAAU,QAAQ,oBAAA;AAAA,cAGxC,qCAAA,gBAAqC,YAAA;;;;;cAIrC,uCAAA,gBAAuC,YAAA;;;;;cAIvC,+BAAA,EAQX,qBAR0C;;;;;;;;;;;;;;;;;KAShC,+BAAA,GAAkC,UAAU,QAAQ,+BAAA"}

package/dist/contact-channels-DW8yQxlc.d.ts

@@ -0,0 +1,180 @@
+import { c as CrudTypeOf, s as CrudSchemaFromOptions } from "./crud-CqmEW9s6.js";
+
+//#region src/interface/crud/contact-channels.d.ts
+declare const contactChannelsClientReadSchema: import("yup").ObjectSchema<{
+  user_id: string;
+  id: string;
+  value: string;
+  type: "email";
+  used_for_auth: boolean;
+  is_verified: boolean;
+  is_primary: boolean;
+}, import("yup").AnyObject, {
+  user_id: undefined;
+  id: undefined;
+  value: undefined;
+  type: undefined;
+  used_for_auth: undefined;
+  is_verified: undefined;
+  is_primary: undefined;
+}, "">;
+declare const contactChannelsCrudClientUpdateSchema: import("yup").ObjectSchema<{
+  value: string | undefined;
+  type: "email" | undefined;
+  used_for_auth: boolean | undefined;
+  is_primary: boolean | undefined;
+}, import("yup").AnyObject, {
+  value: undefined;
+  type: undefined;
+  used_for_auth: undefined;
+  is_primary: undefined;
+}, "">;
+declare const contactChannelsCrudServerUpdateSchema: import("yup").ObjectSchema<{
+  value: string | undefined;
+  type: "email" | undefined;
+  used_for_auth: boolean | undefined;
+  is_primary: boolean | undefined;
+} & {
+  is_verified: boolean | undefined;
+}, import("yup").AnyObject, {
+  value: undefined;
+  type: undefined;
+  used_for_auth: undefined;
+  is_primary: undefined;
+  is_verified: undefined;
+}, "">;
+declare const contactChannelsCrudClientCreateSchema: import("yup").ObjectSchema<{
+  user_id: string;
+  value: string;
+  type: "email";
+  used_for_auth: boolean;
+  is_primary: boolean | undefined;
+}, import("yup").AnyObject, {
+  user_id: undefined;
+  value: undefined;
+  type: undefined;
+  used_for_auth: undefined;
+  is_primary: undefined;
+}, "">;
+declare const contactChannelsCrudServerCreateSchema: import("yup").ObjectSchema<{
+  user_id: string;
+  value: string;
+  type: "email";
+  used_for_auth: boolean;
+  is_primary: boolean | undefined;
+} & {
+  is_verified: boolean | undefined;
+}, import("yup").AnyObject, {
+  user_id: undefined;
+  value: undefined;
+  type: undefined;
+  used_for_auth: undefined;
+  is_primary: undefined;
+  is_verified: undefined;
+}, "">;
+declare const contactChannelsCrudClientDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+declare const contactChannelsCrud: CrudSchemaFromOptions<{
+  clientReadSchema: import("yup").ObjectSchema<{
+    user_id: string;
+    id: string;
+    value: string;
+    type: "email";
+    used_for_auth: boolean;
+    is_verified: boolean;
+    is_primary: boolean;
+  }, import("yup").AnyObject, {
+    user_id: undefined;
+    id: undefined;
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_verified: undefined;
+    is_primary: undefined;
+  }, "">;
+  clientUpdateSchema: import("yup").ObjectSchema<{
+    value: string | undefined;
+    type: "email" | undefined;
+    used_for_auth: boolean | undefined;
+    is_primary: boolean | undefined;
+  }, import("yup").AnyObject, {
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_primary: undefined;
+  }, "">;
+  clientCreateSchema: import("yup").ObjectSchema<{
+    user_id: string;
+    value: string;
+    type: "email";
+    used_for_auth: boolean;
+    is_primary: boolean | undefined;
+  }, import("yup").AnyObject, {
+    user_id: undefined;
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_primary: undefined;
+  }, "">;
+  clientDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+  serverUpdateSchema: import("yup").ObjectSchema<{
+    value: string | undefined;
+    type: "email" | undefined;
+    used_for_auth: boolean | undefined;
+    is_primary: boolean | undefined;
+  } & {
+    is_verified: boolean | undefined;
+  }, import("yup").AnyObject, {
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_primary: undefined;
+    is_verified: undefined;
+  }, "">;
+  serverCreateSchema: import("yup").ObjectSchema<{
+    user_id: string;
+    value: string;
+    type: "email";
+    used_for_auth: boolean;
+    is_primary: boolean | undefined;
+  } & {
+    is_verified: boolean | undefined;
+  }, import("yup").AnyObject, {
+    user_id: undefined;
+    value: undefined;
+    type: undefined;
+    used_for_auth: undefined;
+    is_primary: undefined;
+    is_verified: undefined;
+  }, "">;
+  docs: {
+    clientRead: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+    clientCreate: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+    clientUpdate: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+    clientDelete: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+    clientList: {
+      summary: string;
+      description: string;
+      tags: string[];
+    };
+  };
+}>;
+type ContactChannelsCrud = CrudTypeOf<typeof contactChannelsCrud>;
+//#endregion
+export { contactChannelsCrudClientDeleteSchema as a, contactChannelsCrudServerUpdateSchema as c, contactChannelsCrudClientCreateSchema as i, contactChannelsClientReadSchema as n, contactChannelsCrudClientUpdateSchema as o, contactChannelsCrud as r, contactChannelsCrudServerCreateSchema as s, ContactChannelsCrud as t };
+//# sourceMappingURL=contact-channels-DW8yQxlc.d.ts.map

package/dist/contact-channels-DW8yQxlc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contact-channels-DW8yQxlc.d.ts","names":[],"sources":["../src/interface/crud/contact-channels.ts"],"mappings":";;;cAGa,+BAAA,gBAA+B,YAAA;;;;;;;;;;;;;;;;;cAU/B,qCAAA,gBAAqC,YAAA;;;;;;;;;;;cAOrC,qCAAA,gBAAqC,YAAA;;;;;;;;;;;;;;cAIrC,qCAAA,gBAAqC,YAAA;;;;;;;;;;;;;cAQrC,qCAAA,gBAAqC,YAAA;;;;;;;;;;;;;;;;cAIrC,qCAAA,gBAAqC,WAAA,+BAAA,SAAA;AAAA,cAErC,mBAAA,EAkCX,qBAlC8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmCpB,mBAAA,GAAsB,UAAU,QAAQ,mBAAA"}

package/dist/country-codes-CRWDroBE.d.ts

@@ -0,0 +1,11 @@
+//#region src/utils/country-codes.d.ts
+declare function normalizeCountryCode(countryCode: string): string;
+declare function isValidCountryCode(countryCode: string): boolean;
+/**
+ * Validates and normalizes a country code value (single string or array).
+ * Returns null if valid, or an error message string if invalid.
+ */
+declare function validateCountryCode(value: string | string[]): string | null;
+//#endregion
+export { normalizeCountryCode as n, validateCountryCode as r, isValidCountryCode as t };
+//# sourceMappingURL=country-codes-CRWDroBE.d.ts.map

package/dist/country-codes-CRWDroBE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"country-codes-CRWDroBE.d.ts","names":[],"sources":["../src/utils/country-codes.ts"],"mappings":";iBAAgB,oBAAA,CAAqB,WAAmB;AAAA,iBAIxC,kBAAA,CAAmB,WAAmB;;;;AAJE;iBAaxC,mBAAA,CAAoB,KAAwB"}

package/dist/crud-CqmEW9s6.d.ts

@@ -0,0 +1,98 @@
+import { m as NullishCoalesce } from "./types-DfTcxNtM.js";
+import * as yup$1 from "yup";
+
+//#region src/crud.d.ts
+type AccessType = "client" | "server" | "admin";
+type CrudOperation = "create" | "read" | "update" | "delete";
+type CrudlOperation = "create" | "read" | "update" | "delete" | "list";
+type AccessTypeXCrudOperation = `${AccessType}${Capitalize<CrudOperation>}`;
+type AccessTypeXCrudlOperation = `${AccessType}${Capitalize<CrudlOperation>}`;
+declare module 'yup' {
+  interface CustomSchemaMetadata {
+    openapiField?: {
+      description?: string;
+      exampleValue?: any;
+      hidden?: boolean;
+      onlyShowInOperations?: Capitalize<CrudlOperation>[];
+    };
+  }
+}
+type ShownEndpointDocumentation = {
+  summary: string;
+  description: string;
+  tags?: string[];
+  crudOperation?: Capitalize<CrudlOperation>;
+};
+type EndpointDocumentation = ({
+  hidden: true;
+} & Partial<ShownEndpointDocumentation>) | ({
+  hidden?: boolean;
+} & ShownEndpointDocumentation);
+type InnerCrudSchema<CreateSchema extends yup$1.AnySchema | undefined = yup$1.AnySchema | undefined, ReadSchema extends yup$1.AnySchema | undefined = yup$1.AnySchema | undefined, UpdateSchema extends yup$1.AnySchema | undefined = yup$1.AnySchema | undefined, DeleteSchema extends yup$1.AnySchema | undefined = yup$1.AnySchema | undefined> = {
+  createSchema: CreateSchema;
+  createDocs: EndpointDocumentation | undefined;
+  readSchema: ReadSchema;
+  readDocs: EndpointDocumentation | undefined;
+  listDocs: EndpointDocumentation | undefined;
+  updateSchema: UpdateSchema;
+  updateDocs: EndpointDocumentation | undefined;
+  deleteSchema: DeleteSchema;
+  deleteDocs: EndpointDocumentation | undefined;
+};
+type CrudSchema<ClientSchema extends InnerCrudSchema = InnerCrudSchema, ServerSchema extends InnerCrudSchema = InnerCrudSchema, AdminSchema extends InnerCrudSchema = InnerCrudSchema> = {
+  client: ClientSchema;
+  server: ServerSchema;
+  admin: AdminSchema;
+  hasCreate: boolean;
+  hasRead: boolean;
+  hasUpdate: boolean;
+  hasDelete: boolean;
+};
+type CrudSchemaCreationOptions = { [K in AccessTypeXCrudOperation as `${K}Schema`]?: yup$1.AnySchema };
+type FillInOptionalsPrepareStep<O extends CrudSchemaCreationOptions> = { [K in keyof Required<CrudSchemaCreationOptions>]: K extends keyof O ? O[K] : undefined };
+type FillInOptionalsStep<O extends FillInOptionalsPrepareStep<CrudSchemaCreationOptions>> = {
+  clientCreateSchema: NullishCoalesce<O['clientCreateSchema'], undefined>;
+  clientReadSchema: NullishCoalesce<O['clientReadSchema'], undefined>;
+  clientUpdateSchema: NullishCoalesce<O['clientUpdateSchema'], undefined>;
+  clientDeleteSchema: NullishCoalesce<O['clientDeleteSchema'], undefined>;
+  serverCreateSchema: NullishCoalesce<O['serverCreateSchema'], O['clientCreateSchema']>;
+  serverReadSchema: NullishCoalesce<O['serverReadSchema'], O['clientReadSchema']>;
+  serverUpdateSchema: NullishCoalesce<O['serverUpdateSchema'], O['clientUpdateSchema']>;
+  serverDeleteSchema: NullishCoalesce<O['serverDeleteSchema'], O['clientDeleteSchema']>;
+  adminCreateSchema: NullishCoalesce<O['adminCreateSchema'], O['serverCreateSchema']>;
+  adminReadSchema: NullishCoalesce<O['adminReadSchema'], O['serverReadSchema']>;
+  adminUpdateSchema: NullishCoalesce<O['adminUpdateSchema'], O['serverUpdateSchema']>;
+  adminDeleteSchema: NullishCoalesce<O['adminDeleteSchema'], O['serverDeleteSchema']>;
+};
+type FillInOptionals<O extends CrudSchemaCreationOptions> = FillInOptionalsStep<FillInOptionalsStep<FillInOptionalsStep<FillInOptionalsPrepareStep<O>>>>;
+type CrudSchemaFromOptionsInner<O extends FillInOptionals<any>> = CrudSchema<InnerCrudSchema<O['clientCreateSchema'], O['clientReadSchema'], O['clientUpdateSchema'], O['clientDeleteSchema']>, InnerCrudSchema<O['serverCreateSchema'], O['serverReadSchema'], O['serverUpdateSchema'], O['serverDeleteSchema']>, InnerCrudSchema<O['adminCreateSchema'], O['adminReadSchema'], O['adminUpdateSchema'], O['adminDeleteSchema']>>;
+type CrudSchemaFromOptions<O extends CrudSchemaCreationOptions> = CrudSchemaFromOptionsInner<FillInOptionals<O>>;
+type InnerCrudTypeOf<S extends InnerCrudSchema> = (S['createSchema'] extends {} ? {
+  Create: yup$1.InferType<S['createSchema']>;
+} : {}) & (S['readSchema'] extends {} ? {
+  Read: yup$1.InferType<S['readSchema']>;
+} : {}) & (S['updateSchema'] extends {} ? {
+  Update: yup$1.InferType<S['updateSchema']>;
+} : {}) & (S['deleteSchema'] extends {} ? {
+  Delete: yup$1.InferType<S['deleteSchema']>;
+} : {}) & (S['readSchema'] extends {} ? {
+  List: {
+    items: yup$1.InferType<S['readSchema']>[];
+    is_paginated: boolean;
+    pagination?: {
+      next_cursor: string | null;
+    };
+  };
+} : {});
+type CrudTypeOf<S extends CrudSchema> = {
+  Client: InnerCrudTypeOf<S['client']>;
+  Server: InnerCrudTypeOf<S['server']>;
+  Admin: InnerCrudTypeOf<S['admin']>;
+};
+type CrudDocsCreationOptions<SO extends CrudSchemaCreationOptions> = { [X in AccessTypeXCrudlOperation]?: EndpointDocumentation };
+declare function createCrud<SO extends CrudSchemaCreationOptions>(options: SO & {
+  docs?: CrudDocsCreationOptions<SO>;
+}): CrudSchemaFromOptions<SO>;
+//#endregion
+export { CrudSchema as a, CrudTypeOf as c, createCrud as d, CrudOperation as i, CrudlOperation as l, AccessTypeXCrudOperation as n, CrudSchemaCreationOptions as o, AccessTypeXCrudlOperation as r, CrudSchemaFromOptions as s, AccessType as t, EndpointDocumentation as u };
+//# sourceMappingURL=crud-CqmEW9s6.d.ts.map

package/dist/crud-CqmEW9s6.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud-CqmEW9s6.d.ts","names":[],"sources":["../src/crud.tsx"],"mappings":"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"}