@tanstack/cli 0.0.6 → 0.0.8

package/dist/bin.cjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-const require_template = require('./template-Cup47s9h.cjs');
+const require_template = require('./template-lWrIZhCQ.cjs');
+const require_fetch = require('./fetch-DG5dLrsb.cjs');
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 let zod = require("zod");
@@ -84,7 +85,7 @@ async function runCreate(projectName, options) {
 	s.start("Fetching available integrations...");
 	let manifest;
 	try {
-		manifest = await require_template.fetchManifest(integrationsPath);
+		manifest = await require_fetch.fetchManifest(integrationsPath);
 		s.stop("Integrations loaded");
 	} catch (error$1) {
 		s.stop("Failed to fetch integrations");
@@ -226,7 +227,7 @@ async function runCreate(projectName, options) {
 	}
 	let chosenIntegrations = [];
 	if (resolvedIds.size > 0) try {
-		chosenIntegrations = await require_template.fetchIntegrations(Array.from(resolvedIds), integrationsPath);
+		chosenIntegrations = await require_fetch.fetchIntegrations(Array.from(resolvedIds), integrationsPath);
 	} catch (error$1) {
 		s.stop("Failed to fetch integration details");
 		_clack_prompts.log.error("Could not fetch integration definitions.");
@@ -250,7 +251,10 @@ async function runCreate(projectName, options) {
 	for (const [filePath, content] of Object.entries(output.files)) {
 		const fullPath = (0, node_path.resolve)(targetDir, filePath);
 		(0, node_fs.mkdirSync)((0, node_path.resolve)(fullPath, ".."), { recursive: true });
-		(0, node_fs.writeFileSync)(fullPath, content, "utf-8");
+		if (content.startsWith(require_fetch.BINARY_PREFIX)) {
+			const base64Data = content.slice(require_fetch.BINARY_PREFIX.length);
+			(0, node_fs.writeFileSync)(fullPath, Buffer.from(base64Data, "base64"));
+		} else (0, node_fs.writeFileSync)(fullPath, content, "utf-8");
 	}
 	await require_template.writeConfigFile(targetDir, compileOptions);
 	s.stop("Files written");
@@ -608,7 +612,7 @@ function createServer() {
 	});
 	server.tool("listTanStackIntegrations", "List available integrations for creating TanStack applications", {}, async () => {
 		try {
-			const integrations = (await require_template.fetchManifest()).integrations.filter((a) => a.modes.includes("file-router")).map((integration) => ({
+			const integrations = (await require_fetch.fetchManifest()).integrations.filter((a) => a.modes.includes("file-router")).map((integration) => ({
 				id: integration.id,
 				name: integration.name,
 				description: integration.description,
@@ -646,9 +650,10 @@ function createServer() {
 		try {
 			const { mkdirSync: mkdirSync$1, writeFileSync: writeFileSync$1 } = await import("node:fs");
 			const { resolve: resolve$2 } = await import("node:path");
+			const { BINARY_PREFIX: BINARY_PREFIX$1 } = await Promise.resolve().then(() => require("./fetch-CbFFGJEw.cjs"));
 			const { execSync } = await import("node:child_process");
 			let chosenIntegrations = [];
-			if (integrations?.length) chosenIntegrations = await require_template.fetchIntegrations(integrations);
+			if (integrations?.length) chosenIntegrations = await require_fetch.fetchIntegrations(integrations);
 			const output = require_template.compile({
 				projectName,
 				framework: "react",
@@ -663,7 +668,10 @@ function createServer() {
 			for (const [filePath, content] of Object.entries(output.files)) {
 				const fullPath = resolve$2(targetDir, filePath);
 				mkdirSync$1(resolve$2(fullPath, ".."), { recursive: true });
-				writeFileSync$1(fullPath, content, "utf-8");
+				if (content.startsWith(BINARY_PREFIX$1)) {
+					const base64Data = content.slice(BINARY_PREFIX$1.length);
+					writeFileSync$1(fullPath, Buffer.from(base64Data, "base64"));
+				} else writeFileSync$1(fullPath, content, "utf-8");
 			}
 			try {
 				execSync("git init", {

package/dist/bin.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { A as writeConfigFile, a as initIntegration, d as fetchManifest, i as compileIntegration, j as compile, n as initTemplate, r as loadTemplate, t as compileTemplate, u as fetchIntegrations } from "./template-CkAkdP8n.mjs";
+import { a as initIntegration, i as compileIntegration, l as writeConfigFile, n as initTemplate, r as loadTemplate, t as compileTemplate, u as compile } from "./template-Szi7-AZJ.mjs";
+import { a as fetchIntegrations, o as fetchManifest, t as BINARY_PREFIX } from "./fetch-DhlVXS6S.mjs";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { z } from "zod";
@@ -248,7 +249,10 @@ async function runCreate(projectName, options) {
 	for (const [filePath, content] of Object.entries(output.files)) {
 		const fullPath = resolve(targetDir, filePath);
 		mkdirSync(resolve(fullPath, ".."), { recursive: true });
-		writeFileSync(fullPath, content, "utf-8");
+		if (content.startsWith(BINARY_PREFIX)) {
+			const base64Data = content.slice(BINARY_PREFIX.length);
+			writeFileSync(fullPath, Buffer.from(base64Data, "base64"));
+		} else writeFileSync(fullPath, content, "utf-8");
 	}
 	await writeConfigFile(targetDir, compileOptions);
 	s.stop("Files written");
@@ -644,6 +648,7 @@ function createServer() {
 		try {
 			const { mkdirSync: mkdirSync$1, writeFileSync: writeFileSync$1 } = await import("node:fs");
 			const { resolve: resolve$1 } = await import("node:path");
+			const { BINARY_PREFIX: BINARY_PREFIX$1 } = await import("./fetch-I_OVg8JX.mjs");
 			const { execSync } = await import("node:child_process");
 			let chosenIntegrations = [];
 			if (integrations?.length) chosenIntegrations = await fetchIntegrations(integrations);
@@ -661,7 +666,10 @@ function createServer() {
 			for (const [filePath, content] of Object.entries(output.files)) {
 				const fullPath = resolve$1(targetDir, filePath);
 				mkdirSync$1(resolve$1(fullPath, ".."), { recursive: true });
-				writeFileSync$1(fullPath, content, "utf-8");
+				if (content.startsWith(BINARY_PREFIX$1)) {
+					const base64Data = content.slice(BINARY_PREFIX$1.length);
+					writeFileSync$1(fullPath, Buffer.from(base64Data, "base64"));
+				} else writeFileSync$1(fullPath, content, "utf-8");
 			}
 			try {
 				execSync("git init", {

package/dist/fetch-CbFFGJEw.cjs

@@ -0,0 +1,3 @@
+const require_fetch = require('./fetch-DG5dLrsb.cjs');
+
+exports.BINARY_PREFIX = require_fetch.BINARY_PREFIX;

package/dist/fetch-DG5dLrsb.cjs

@@ -0,0 +1,522 @@
+const require_template = require('./template-lWrIZhCQ.cjs');
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let zod = require("zod");
+let node_os = require("node:os");
+
+//#region src/engine/types.ts
+const CategorySchema = zod.z.enum([
+	"tanstack",
+	"database",
+	"orm",
+	"auth",
+	"deploy",
+	"tooling",
+	"monitoring",
+	"api",
+	"i18n",
+	"cms",
+	"other"
+]);
+const IntegrationTypeSchema = zod.z.enum([
+	"integration",
+	"example",
+	"toolchain",
+	"deployment"
+]);
+const IntegrationPhaseSchema = zod.z.enum([
+	"setup",
+	"integration",
+	"example"
+]);
+const RouterModeSchema = zod.z.enum(["file-router", "code-router"]);
+const SelectOptionSchema = zod.z.object({
+	type: zod.z.literal("select"),
+	label: zod.z.string(),
+	description: zod.z.string().optional(),
+	default: zod.z.string(),
+	options: zod.z.array(zod.z.object({
+		value: zod.z.string(),
+		label: zod.z.string()
+	}))
+});
+const BooleanOptionSchema = zod.z.object({
+	type: zod.z.literal("boolean"),
+	label: zod.z.string(),
+	description: zod.z.string().optional(),
+	default: zod.z.boolean()
+});
+const StringOptionSchema = zod.z.object({
+	type: zod.z.literal("string"),
+	label: zod.z.string(),
+	description: zod.z.string().optional(),
+	default: zod.z.string()
+});
+const IntegrationOptionSchema = zod.z.discriminatedUnion("type", [
+	SelectOptionSchema,
+	BooleanOptionSchema,
+	StringOptionSchema
+]);
+const IntegrationOptionsSchema = zod.z.record(zod.z.string(), IntegrationOptionSchema);
+const HookTypeSchema = zod.z.enum([
+	"header-user",
+	"provider",
+	"root-provider",
+	"layout",
+	"vite-plugin",
+	"devtools",
+	"entry-client"
+]);
+const HookSchema = zod.z.object({
+	type: HookTypeSchema.optional(),
+	path: zod.z.string().optional(),
+	jsName: zod.z.string().optional(),
+	import: zod.z.string().optional(),
+	code: zod.z.string().optional()
+});
+const RouteSchema = zod.z.object({
+	url: zod.z.string().optional(),
+	name: zod.z.string().optional(),
+	icon: zod.z.string().optional(),
+	path: zod.z.string(),
+	jsName: zod.z.string(),
+	children: zod.z.array(zod.z.lazy(() => RouteSchema)).optional()
+});
+const EnvVarSchema = zod.z.object({
+	name: zod.z.string(),
+	description: zod.z.string(),
+	required: zod.z.boolean().optional(),
+	example: zod.z.string().optional()
+});
+const CommandSchema = zod.z.object({
+	command: zod.z.string(),
+	args: zod.z.array(zod.z.string()).optional()
+});
+const IntegrationInfoSchema = zod.z.object({
+	id: zod.z.string().optional(),
+	name: zod.z.string(),
+	description: zod.z.string(),
+	author: zod.z.string().optional(),
+	version: zod.z.string().optional(),
+	link: zod.z.string().optional(),
+	license: zod.z.string().optional(),
+	warning: zod.z.string().optional(),
+	type: IntegrationTypeSchema,
+	phase: IntegrationPhaseSchema,
+	category: CategorySchema.optional(),
+	modes: zod.z.array(RouterModeSchema),
+	priority: zod.z.number().optional(),
+	default: zod.z.boolean().optional(),
+	requiresTailwind: zod.z.boolean().optional(),
+	demoRequiresTailwind: zod.z.boolean().optional(),
+	dependsOn: zod.z.array(zod.z.string()).optional(),
+	exclusive: zod.z.array(zod.z.string()).optional(),
+	partnerId: zod.z.string().optional(),
+	options: IntegrationOptionsSchema.optional(),
+	hooks: zod.z.array(HookSchema).optional(),
+	routes: zod.z.array(RouteSchema).optional(),
+	packageAdditions: zod.z.object({
+		dependencies: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+		devDependencies: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+		scripts: zod.z.record(zod.z.string(), zod.z.string()).optional()
+	}).optional(),
+	shadcnComponents: zod.z.array(zod.z.string()).optional(),
+	gitignorePatterns: zod.z.array(zod.z.string()).optional(),
+	envVars: zod.z.array(EnvVarSchema).optional(),
+	command: CommandSchema.optional(),
+	integrationSpecialSteps: zod.z.array(zod.z.string()).optional(),
+	createSpecialSteps: zod.z.array(zod.z.string()).optional(),
+	postInitSpecialSteps: zod.z.array(zod.z.string()).optional(),
+	smallLogo: zod.z.string().optional(),
+	logo: zod.z.string().optional(),
+	readme: zod.z.string().optional()
+});
+const IntegrationCompiledSchema = IntegrationInfoSchema.extend({
+	id: zod.z.string(),
+	files: zod.z.record(zod.z.string(), zod.z.string()),
+	deletedFiles: zod.z.array(zod.z.string()).optional()
+});
+const CustomTemplateInfoSchema = zod.z.object({
+	id: zod.z.string().optional(),
+	name: zod.z.string(),
+	description: zod.z.string(),
+	framework: zod.z.string(),
+	mode: RouterModeSchema,
+	typescript: zod.z.boolean(),
+	tailwind: zod.z.boolean(),
+	integrations: zod.z.array(zod.z.string()),
+	integrationOptions: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())).optional(),
+	banner: zod.z.string().optional()
+});
+const CustomTemplateCompiledSchema = CustomTemplateInfoSchema.extend({ id: zod.z.string() });
+const ManifestIntegrationSchema = zod.z.object({
+	id: zod.z.string(),
+	name: zod.z.string(),
+	description: zod.z.string(),
+	type: IntegrationTypeSchema,
+	category: CategorySchema.optional(),
+	modes: zod.z.array(RouterModeSchema),
+	dependsOn: zod.z.array(zod.z.string()).optional(),
+	exclusive: zod.z.array(zod.z.string()).optional(),
+	partnerId: zod.z.string().optional(),
+	hasOptions: zod.z.boolean().optional(),
+	link: zod.z.string().optional(),
+	color: zod.z.string().optional(),
+	requiresTailwind: zod.z.boolean().optional(),
+	demoRequiresTailwind: zod.z.boolean().optional()
+});
+const ManifestCustomTemplateSchema = zod.z.object({
+	id: zod.z.string(),
+	name: zod.z.string(),
+	description: zod.z.string(),
+	banner: zod.z.string().optional(),
+	icon: zod.z.string().optional(),
+	features: zod.z.array(zod.z.string()).optional()
+});
+const ManifestSchema = zod.z.object({
+	version: zod.z.string(),
+	generated: zod.z.string(),
+	integrations: zod.z.array(ManifestIntegrationSchema),
+	customTemplates: zod.z.array(ManifestCustomTemplateSchema).optional()
+});
+
+//#endregion
+//#region src/cache/index.ts
+const CACHE_DIR = (0, node_path.join)((0, node_os.homedir)(), ".tanstack", "cache");
+const DEFAULT_TTL_MS = 1440 * 60 * 1e3;
+function ensureCacheDir() {
+	if (!(0, node_fs.existsSync)(CACHE_DIR)) (0, node_fs.mkdirSync)(CACHE_DIR, { recursive: true });
+}
+function getCachePath(key) {
+	return (0, node_path.join)(CACHE_DIR, `${key.replace(/[^a-zA-Z0-9-_]/g, "_")}.json`);
+}
+function getCached(key) {
+	const cachePath = getCachePath(key);
+	if (!(0, node_fs.existsSync)(cachePath)) return null;
+	try {
+		const raw = (0, node_fs.readFileSync)(cachePath, "utf-8");
+		const entry = JSON.parse(raw);
+		if (Date.now() - entry.timestamp > entry.ttl) return null;
+		return entry.data;
+	} catch {
+		return null;
+	}
+}
+function setCache(key, data, ttlMs = DEFAULT_TTL_MS) {
+	ensureCacheDir();
+	const cachePath = getCachePath(key);
+	const entry = {
+		data,
+		timestamp: Date.now(),
+		ttl: ttlMs
+	};
+	(0, node_fs.writeFileSync)(cachePath, JSON.stringify(entry, null, 2), "utf-8");
+}
+async function fetchWithCache(key, fetcher, ttlMs = DEFAULT_TTL_MS) {
+	const cached = getCached(key);
+	if (cached !== null) return cached;
+	const data = await fetcher();
+	setCache(key, data, ttlMs);
+	return data;
+}
+
+//#endregion
+//#region src/api/fetch.ts
+const GITHUB_RAW_BASE = "https://raw.githubusercontent.com/TanStack/cli/main/integrations";
+const CACHE_TTL_MS = 3600 * 1e3;
+const BINARY_EXTENSIONS = new Set([
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".webp",
+	".ico",
+	".svg",
+	".woff",
+	".woff2",
+	".ttf",
+	".eot",
+	".otf",
+	".pdf",
+	".zip",
+	".tar",
+	".gz",
+	".mp3",
+	".mp4",
+	".wav",
+	".ogg",
+	".webm"
+]);
+const BINARY_PREFIX = "base64:";
+/**
+* Check if a file should be treated as binary based on extension
+*/
+function isBinaryFile(filePath) {
+	return BINARY_EXTENSIONS.has((0, node_path.extname)(filePath).toLowerCase());
+}
+/**
+* Check if a path is a local directory
+*/
+function isLocalPath(path) {
+	return path.startsWith("/") || path.startsWith("./") || path.startsWith("..");
+}
+/**
+* Fetch the integration manifest from GitHub or local path (with caching for remote)
+*/
+async function fetchManifest(baseUrl = GITHUB_RAW_BASE) {
+	if (isLocalPath(baseUrl)) {
+		const manifestPath = (0, node_path.join)(baseUrl, "manifest.json");
+		if (!(0, node_fs.existsSync)(manifestPath)) throw new Error(`Manifest not found at ${manifestPath}`);
+		const data = JSON.parse((0, node_fs.readFileSync)(manifestPath, "utf-8"));
+		return ManifestSchema.parse(data);
+	}
+	return fetchWithCache(`manifest_${baseUrl.replace(/[^a-zA-Z0-9]/g, "_")}`, async () => {
+		const url = `${baseUrl}/manifest.json`;
+		const response = await fetch(url);
+		if (!response.ok) throw new Error(`Failed to fetch manifest: ${response.statusText}`);
+		const data = await response.json();
+		return ManifestSchema.parse(data);
+	}, CACHE_TTL_MS);
+}
+/**
+* Fetch integration info.json from GitHub or local path (with caching for remote)
+*/
+async function fetchIntegrationInfo(integrationId, baseUrl = GITHUB_RAW_BASE) {
+	if (isLocalPath(baseUrl)) {
+		const infoPath = (0, node_path.join)(baseUrl, integrationId, "info.json");
+		if (!(0, node_fs.existsSync)(infoPath)) throw new Error(`Integration info not found at ${infoPath}`);
+		const data = JSON.parse((0, node_fs.readFileSync)(infoPath, "utf-8"));
+		return IntegrationInfoSchema.parse(data);
+	}
+	return fetchWithCache(`integration_info_${integrationId}_${baseUrl.replace(/[^a-zA-Z0-9]/g, "_")}`, async () => {
+		const url = `${baseUrl}/${integrationId}/info.json`;
+		const response = await fetch(url);
+		if (!response.ok) throw new Error(`Failed to fetch integration ${integrationId}: ${response.statusText}`);
+		const data = await response.json();
+		return IntegrationInfoSchema.parse(data);
+	}, CACHE_TTL_MS);
+}
+/**
+* Recursively read all files from a directory
+* Binary files are read as base64 with a prefix marker
+*/
+function readDirRecursive(dir, basePath = "") {
+	const files = {};
+	if (!(0, node_fs.existsSync)(dir)) return files;
+	for (const entry of (0, node_fs.readdirSync)(dir)) {
+		const fullPath = (0, node_path.join)(dir, entry);
+		const relativePath = basePath ? `${basePath}/${entry}` : entry;
+		if ((0, node_fs.statSync)(fullPath).isDirectory()) Object.assign(files, readDirRecursive(fullPath, relativePath));
+		else if (isBinaryFile(relativePath)) files[relativePath] = BINARY_PREFIX + (0, node_fs.readFileSync)(fullPath).toString("base64");
+		else files[relativePath] = (0, node_fs.readFileSync)(fullPath, "utf-8");
+	}
+	return files;
+}
+/**
+* Fetch all files for an integration from GitHub or local path (with caching for remote)
+*/
+async function fetchIntegrationFiles(integrationId, baseUrl = GITHUB_RAW_BASE) {
+	if (isLocalPath(baseUrl)) return readDirRecursive((0, node_path.join)(baseUrl, integrationId, "assets"));
+	return fetchWithCache(`integration_files_${integrationId}_${baseUrl.replace(/[^a-zA-Z0-9]/g, "_")}`, async () => {
+		const filesUrl = `${baseUrl}/${integrationId}/files.json`;
+		const response = await fetch(filesUrl);
+		if (!response.ok) return {};
+		const fileList = await response.json();
+		const files = {};
+		await Promise.all(fileList.map(async (filePath) => {
+			const fileUrl = `${baseUrl}/${integrationId}/assets/${filePath}`;
+			const fileResponse = await fetch(fileUrl);
+			if (fileResponse.ok) if (isBinaryFile(filePath)) {
+				const buffer = await fileResponse.arrayBuffer();
+				files[filePath] = BINARY_PREFIX + Buffer.from(buffer).toString("base64");
+			} else files[filePath] = await fileResponse.text();
+		}));
+		return files;
+	}, CACHE_TTL_MS);
+}
+/**
+* Fetch integration package.json if it exists
+*/
+async function fetchIntegrationPackageJson(integrationId, baseUrl) {
+	if (isLocalPath(baseUrl)) {
+		const pkgPath = (0, node_path.join)(baseUrl, integrationId, "package.json");
+		if ((0, node_fs.existsSync)(pkgPath)) return JSON.parse((0, node_fs.readFileSync)(pkgPath, "utf-8"));
+		return null;
+	}
+	const url = `${baseUrl}/${integrationId}/package.json`;
+	const response = await fetch(url);
+	if (!response.ok) return null;
+	return response.json();
+}
+/**
+* Fetch a complete compiled integration from GitHub
+*/
+async function fetchIntegration(integrationId, baseUrl = GITHUB_RAW_BASE) {
+	const [info, files, pkgJson] = await Promise.all([
+		fetchIntegrationInfo(integrationId, baseUrl),
+		fetchIntegrationFiles(integrationId, baseUrl),
+		fetchIntegrationPackageJson(integrationId, baseUrl)
+	]);
+	const packageAdditions = info.packageAdditions ?? {};
+	if (pkgJson) {
+		if (pkgJson.dependencies) packageAdditions.dependencies = {
+			...packageAdditions.dependencies,
+			...pkgJson.dependencies
+		};
+		if (pkgJson.devDependencies) packageAdditions.devDependencies = {
+			...packageAdditions.devDependencies,
+			...pkgJson.devDependencies
+		};
+		if (pkgJson.scripts) packageAdditions.scripts = {
+			...packageAdditions.scripts,
+			...pkgJson.scripts
+		};
+	}
+	return IntegrationCompiledSchema.parse({
+		...info,
+		id: integrationId,
+		files,
+		packageAdditions: Object.keys(packageAdditions).length > 0 ? packageAdditions : void 0,
+		deletedFiles: []
+	});
+}
+/**
+* Fetch multiple integrations in parallel
+*/
+async function fetchIntegrations(integrationIds, baseUrl = GITHUB_RAW_BASE) {
+	return Promise.all(integrationIds.map((id) => fetchIntegration(id, baseUrl)));
+}
+
+//#endregion
+Object.defineProperty(exports, 'BINARY_PREFIX', {
+  enumerable: true,
+  get: function () {
+    return BINARY_PREFIX;
+  }
+});
+Object.defineProperty(exports, 'CategorySchema', {
+  enumerable: true,
+  get: function () {
+    return CategorySchema;
+  }
+});
+Object.defineProperty(exports, 'CommandSchema', {
+  enumerable: true,
+  get: function () {
+    return CommandSchema;
+  }
+});
+Object.defineProperty(exports, 'CustomTemplateCompiledSchema', {
+  enumerable: true,
+  get: function () {
+    return CustomTemplateCompiledSchema;
+  }
+});
+Object.defineProperty(exports, 'CustomTemplateInfoSchema', {
+  enumerable: true,
+  get: function () {
+    return CustomTemplateInfoSchema;
+  }
+});
+Object.defineProperty(exports, 'EnvVarSchema', {
+  enumerable: true,
+  get: function () {
+    return EnvVarSchema;
+  }
+});
+Object.defineProperty(exports, 'HookSchema', {
+  enumerable: true,
+  get: function () {
+    return HookSchema;
+  }
+});
+Object.defineProperty(exports, 'IntegrationCompiledSchema', {
+  enumerable: true,
+  get: function () {
+    return IntegrationCompiledSchema;
+  }
+});
+Object.defineProperty(exports, 'IntegrationInfoSchema', {
+  enumerable: true,
+  get: function () {
+    return IntegrationInfoSchema;
+  }
+});
+Object.defineProperty(exports, 'IntegrationOptionSchema', {
+  enumerable: true,
+  get: function () {
+    return IntegrationOptionSchema;
+  }
+});
+Object.defineProperty(exports, 'IntegrationOptionsSchema', {
+  enumerable: true,
+  get: function () {
+    return IntegrationOptionsSchema;
+  }
+});
+Object.defineProperty(exports, 'IntegrationPhaseSchema', {
+  enumerable: true,
+  get: function () {
+    return IntegrationPhaseSchema;
+  }
+});
+Object.defineProperty(exports, 'IntegrationTypeSchema', {
+  enumerable: true,
+  get: function () {
+    return IntegrationTypeSchema;
+  }
+});
+Object.defineProperty(exports, 'ManifestIntegrationSchema', {
+  enumerable: true,
+  get: function () {
+    return ManifestIntegrationSchema;
+  }
+});
+Object.defineProperty(exports, 'ManifestSchema', {
+  enumerable: true,
+  get: function () {
+    return ManifestSchema;
+  }
+});
+Object.defineProperty(exports, 'RouteSchema', {
+  enumerable: true,
+  get: function () {
+    return RouteSchema;
+  }
+});
+Object.defineProperty(exports, 'RouterModeSchema', {
+  enumerable: true,
+  get: function () {
+    return RouterModeSchema;
+  }
+});
+Object.defineProperty(exports, 'fetchIntegration', {
+  enumerable: true,
+  get: function () {
+    return fetchIntegration;
+  }
+});
+Object.defineProperty(exports, 'fetchIntegrationFiles', {
+  enumerable: true,
+  get: function () {
+    return fetchIntegrationFiles;
+  }
+});
+Object.defineProperty(exports, 'fetchIntegrationInfo', {
+  enumerable: true,
+  get: function () {
+    return fetchIntegrationInfo;
+  }
+});
+Object.defineProperty(exports, 'fetchIntegrations', {
+  enumerable: true,
+  get: function () {
+    return fetchIntegrations;
+  }
+});
+Object.defineProperty(exports, 'fetchManifest', {
+  enumerable: true,
+  get: function () {
+    return fetchManifest;
+  }
+});