create-krispya 0.1.0

package/dist/integrations/fiber.js

@@ -0,0 +1,35 @@
+export function generateFiber(generator, _options) {
+    generator.inject("import", `import { Box } from "./box.js"`);
+    generator.inject("scene", [
+        `<ambientLight intensity={Math.PI / 2} />`,
+        `<spotLight position={[10, 10, 10]} angle={0.15} penumbra={1} decay={0} intensity={Math.PI} />`,
+        `<pointLight position={[-10, -10, -10]} decay={0} intensity={Math.PI} />`,
+        `<Box position={[-1.2, 0, 0]} />`,
+        `<Box position={[1.2, 0, 0]} />`,
+    ].join("\n"));
+    generator.addFile("src/box.tsx", {
+        type: "text",
+        content: `import type { Mesh } from 'three'
+import { useRef, useState } from 'react'
+import { useFrame, ThreeElements } from '@react-three/fiber'
+
+export function Box(props: ThreeElements['mesh']) {
+  const meshRef = useRef<Mesh>(null!)
+  const [hovered, setHover] = useState(false)
+  const [active, setActive] = useState(false)
+  useFrame((state, delta) => (meshRef.current.rotation.x += delta))
+  return (
+    <mesh
+      {...props}
+      ref={meshRef}
+      scale={active ? 1.5 : 1}
+      onClick={(event) => setActive(!active)}
+      onPointerOver={(event) => setHover(true)}
+      onPointerOut={(event) => setHover(false)}>
+      <boxGeometry args={[1, 1, 1]} />
+      <meshStandardMaterial color={hovered ? 'hotpink' : '#2f74c0'} />
+    </mesh>
+  )
+}`,
+    });
+}

package/dist/integrations/github-pages.d.ts

@@ -0,0 +1,3 @@
+import type { Generator } from "../index.js";
+export type GenerateGithubPagesOptions = {} | boolean;
+export declare function generateGithubPages(generator: Generator, options: GenerateGithubPagesOptions | undefined): void;

package/dist/integrations/github-pages.js

@@ -0,0 +1,58 @@
+export function generateGithubPages(generator, options) {
+    if (options === false ||
+        (generator.options.packageManager ?? "npm") != "npm") {
+        return;
+    }
+    generator.addFile(".github/workflows/gh-pages.yml", {
+        type: "text",
+        content: `name: Deploy to Github Pages
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      contents: read
+      id-token: write
+
+    environment:
+      name: github-pages
+      url: \${{ steps.deployment.outputs.page_url }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: 20
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build project
+        run: npm run build
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: './dist'
+
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
+`,
+    });
+    generator.inject("readme-start", `A github pages deployment action is configurd.`);
+    if (generator.options.githubUserName != null &&
+        generator.options.githubRepoName != null) {
+        const address = `${generator.options.githubUserName}.github.io/${generator.options.githubRepoName}`;
+        generator.inject("readme-start", `Your app will be publish at [${address}](https://${address}) once the github action is finished.\n`);
+    }
+}

package/dist/integrations/handle.d.ts

@@ -0,0 +1,3 @@
+import type { Generator } from "../index.js";
+export type GenerateHandleOptions = {} | boolean;
+export declare function generateHandle(generator: Generator, options: GenerateHandleOptions | undefined): void;

package/dist/integrations/handle.js

@@ -0,0 +1,7 @@
+export function generateHandle(generator, options) {
+    if (options == null) {
+        return;
+    }
+    generator.addDependency("@react-three/handle", "^6.6.16");
+    generator.inject("readme-libraries", `[@react-three/handle](https://pmndrs.github.io/xr/docs/handles/introduction) - interactive controls and handles for your 3D objects`);
+}

package/dist/integrations/koota.d.ts

@@ -0,0 +1,8 @@
+import type { Generator } from "../index.js";
+export type GenerateKootaOptions = {
+    /**
+     * @default true
+     */
+    addExample?: boolean;
+} | boolean;
+export declare function generateKoota(generator: Generator, options: GenerateKootaOptions | undefined): void;

package/dist/integrations/koota.js

@@ -0,0 +1,7 @@
+export function generateKoota(generator, options) {
+    if (options == null) {
+        return;
+    }
+    generator.addDependency("koota", "^0.4.0");
+    generator.inject("readme-libraries", `[koota](https://github.com/pmndrs/koota) - ECS-based state management library optimized for real-time apps, games, and XR experiences`);
+}

package/dist/integrations/leva.d.ts

@@ -0,0 +1,3 @@
+import type { Generator } from "../index.js";
+export type GenerateLevaOptions = {} | boolean;
+export declare function generateLeva(generator: Generator, options: GenerateLevaOptions | undefined): void;

package/dist/integrations/leva.js

@@ -0,0 +1,7 @@
+export function generateLeva(generator, options) {
+    if (options == null) {
+        return;
+    }
+    generator.addDependency("leva", "^0.10.0");
+    generator.inject("readme-libraries", `[leva](https://github.com/pmndrs/leva) - HTML GUI panel for React with lightweight, beautiful and extensible controls`);
+}

package/dist/integrations/offscreen.d.ts

@@ -0,0 +1,3 @@
+import type { Generator } from "../index.js";
+export type GenerateOffscreenOptions = {} | boolean;
+export declare function generateOffscreen(generator: Generator, options: GenerateOffscreenOptions | undefined): void;

package/dist/integrations/offscreen.js

@@ -0,0 +1,12 @@
+import chalk from "chalk";
+export function generateOffscreen(generator, options) {
+    if (options == null) {
+        return;
+    }
+    if (generator.options.xr != null) {
+        console.info(chalk.blue("Info:"), "@react-three/offscreen is disabled because it is not supported with XR");
+        return;
+    }
+    generator.addDependency("@react-three/offscreen", "^0.0.8");
+    generator.inject("readme-libraries", `[@react-three/offscreen](https://github.com/pmndrs/offscreen) - Offload your scene to a worker thread for better performance`);
+}

package/dist/integrations/oxfmt.d.ts

@@ -0,0 +1,3 @@
+import type { Generator } from "../index.js";
+export type GenerateOxfmtOptions = {} | boolean;
+export declare function generateOxfmt(generator: Generator, options: GenerateOxfmtOptions | undefined): void;

package/dist/integrations/oxfmt.js

@@ -0,0 +1,27 @@
+import { defaultFormatterConfig } from "../constants.js";
+export function generateOxfmt(generator, options) {
+    if (options == null) {
+        return;
+    }
+    const version = generator.versions.oxfmt ?? "0.1.0";
+    generator.addDependency("oxfmt", `^${version}`);
+    // Add oxfmt config using common formatter settings (Prettier-compatible format)
+    const oxfmtConfig = {
+        printWidth: defaultFormatterConfig.printWidth,
+        tabWidth: defaultFormatterConfig.tabWidth,
+        useTabs: defaultFormatterConfig.useTabs,
+        semi: defaultFormatterConfig.semi,
+        singleQuote: defaultFormatterConfig.singleQuote,
+        trailingComma: defaultFormatterConfig.trailingComma,
+        bracketSpacing: defaultFormatterConfig.bracketSpacing,
+        arrowParens: defaultFormatterConfig.arrowParens,
+    };
+    generator.addFile(".oxfmt.json", {
+        type: "text",
+        content: JSON.stringify(oxfmtConfig, null, 2),
+    });
+    generator.addScript("format", "oxfmt --write .");
+    generator.inject("readme-tools", "[Oxfmt](https://oxc.rs/docs/guide/usage/formatter) - Fast Prettier-compatible code formatter");
+    generator.inject("vscode-extension-suggestion", "oxc.oxc-vscode");
+    generator.addVscodeSetting("editor.defaultFormatter", "oxc.oxc-vscode");
+}

package/dist/integrations/oxlint.d.ts

@@ -0,0 +1,3 @@
+import { type Generator } from "../index.js";
+export type GenerateOxlintOptions = {} | boolean;
+export declare function generateOxlint(generator: Generator, options: GenerateOxlintOptions | undefined): void;

package/dist/integrations/oxlint.js

@@ -0,0 +1,52 @@
+import { defaultLinterConfig } from "../constants.js";
+import { getBaseTemplate } from "../index.js";
+// Helper to convert level to oxlint format
+function toOxlintLevel(level) {
+    return level;
+}
+export function generateOxlint(generator, options) {
+    if (options == null) {
+        return;
+    }
+    const version = generator.versions.oxlint ?? "0.16.0";
+    generator.addDependency("oxlint", `^${version}`);
+    const { rules } = defaultLinterConfig;
+    // Check if it's a React project
+    const template = generator.options.template ?? "vanilla";
+    const baseTemplate = getBaseTemplate(template);
+    const isReact = baseTemplate === "react" || baseTemplate === "r3f";
+    // Build plugins list - add react plugin for React projects
+    const plugins = ["unicorn", "typescript", "oxc"];
+    if (isReact) {
+        plugins.push("react");
+    }
+    // Add oxlint config with plugins and common rules
+    const oxlintConfig = {
+        $schema: "./node_modules/oxlint/configuration_schema.json",
+        plugins,
+        rules: {
+            "no-unused-vars": [
+                toOxlintLevel(rules.noUnusedVars.level),
+                {
+                    argsIgnorePattern: rules.noUnusedVars.argsIgnorePattern,
+                    varsIgnorePattern: rules.noUnusedVars.varsIgnorePattern,
+                    caughtErrorsIgnorePattern: rules.noUnusedVars.caughtErrorsIgnorePattern,
+                },
+            ],
+            "no-useless-escape": "off",
+            "no-unused-expressions": [
+                toOxlintLevel(rules.noUnusedExpressions.level),
+                { allowShortCircuit: rules.noUnusedExpressions.allowShortCircuit },
+            ],
+        },
+        ignorePatterns: defaultLinterConfig.ignorePatterns,
+    };
+    generator.addFile("oxlint.json", {
+        type: "text",
+        content: JSON.stringify(oxlintConfig, null, 2),
+    });
+    generator.addScript("lint", "oxlint");
+    generator.inject("readme-tools", "[Oxlint](https://oxc.rs/docs/guide/usage/linter) - A fast linter for JavaScript and TypeScript");
+    generator.inject("vscode-extension-suggestion", "oxc.oxc-vscode");
+    generator.addVscodeSetting("oxc.enable", true);
+}

package/dist/integrations/postprocessing.d.ts

@@ -0,0 +1,3 @@
+import type { Generator } from "../index.js";
+export type GeneratePostprocessingOptions = {} | boolean;
+export declare function generatePostprocessing(generator: Generator, options: GeneratePostprocessingOptions | undefined): void;

package/dist/integrations/postprocessing.js

@@ -0,0 +1,12 @@
+import chalk from "chalk";
+export function generatePostprocessing(generator, options) {
+    if (options == null) {
+        return;
+    }
+    if (generator.options.xr != null) {
+        console.info(chalk.blue("Info:"), "@react-three/postprocessing is disabled because it is not supported with XR");
+        return;
+    }
+    generator.addDependency("@react-three/postprocessing", "^3.0.4");
+    generator.inject("readme-libraries", `[@react-three/postprocessing](https://react-postprocessing.docs.pmnd.rs/) - Post-processing effects for @react-three/fiber`);
+}

package/dist/integrations/prettier.d.ts

@@ -0,0 +1,3 @@
+import type { Generator } from "../index.js";
+export type GeneratePrettierOptions = {} | boolean;
+export declare function generatePrettier(generator: Generator, options: GeneratePrettierOptions | undefined): void;

package/dist/integrations/prettier.js

@@ -0,0 +1,28 @@
+import { defaultFormatterConfig } from "../constants.js";
+export function generatePrettier(generator, options) {
+    if (options == null) {
+        return;
+    }
+    const version = generator.versions.prettier ?? "3.4.2";
+    generator.addDependency("prettier", `^${version}`);
+    // Add prettier config using common formatter settings
+    const prettierConfig = {
+        $schema: "https://json.schemastore.org/prettierrc",
+        printWidth: defaultFormatterConfig.printWidth,
+        tabWidth: defaultFormatterConfig.tabWidth,
+        useTabs: defaultFormatterConfig.useTabs,
+        semi: defaultFormatterConfig.semi,
+        singleQuote: defaultFormatterConfig.singleQuote,
+        trailingComma: defaultFormatterConfig.trailingComma,
+        bracketSpacing: defaultFormatterConfig.bracketSpacing,
+        arrowParens: defaultFormatterConfig.arrowParens,
+    };
+    generator.addFile(".prettierrc", {
+        type: "text",
+        content: JSON.stringify(prettierConfig, null, 2),
+    });
+    generator.addScript("format", "prettier --write .");
+    generator.inject("readme-tools", "[Prettier](https://prettier.io/) - Opinionated code formatter");
+    generator.inject("vscode-extension-suggestion", "esbenp.prettier-vscode");
+    generator.addVscodeSetting("editor.defaultFormatter", "esbenp.prettier-vscode");
+}

package/dist/integrations/rapier.d.ts

@@ -0,0 +1,3 @@
+import type { Generator } from "../index.js";
+export type GenerateRapierOptions = {} | boolean;
+export declare function generateRapier(generator: Generator, options: GenerateRapierOptions | undefined): void;

package/dist/integrations/rapier.js

@@ -0,0 +1,7 @@
+export function generateRapier(generator, options) {
+    if (options == null) {
+        return;
+    }
+    generator.addDependency("@react-three/rapier", "^2.1.0");
+    generator.inject("readme-libraries", `[@react-three/rapier](https://github.com/pmndrs/react-three-rapier) - Physics based on Rapier for your @react-three/fiber scene`);
+}

package/dist/integrations/triplex.d.ts

@@ -0,0 +1,26 @@
+import type { Generator } from "../index.js";
+export type GenerateTriplexOptions = {} | boolean;
+export type PropValue = {
+    declaredPropDefaultValue: unknown;
+    declaredPropName: string;
+    declaredPropType: string;
+    propName: string;
+    propValue: string;
+};
+export type ProviderDefinition = Record<string, {
+    component: string;
+    type: "wrapped-jsx";
+    import: string;
+    props?: PropValue[];
+} | {
+    code: string;
+    type: "inline-jsx";
+    import: string;
+    props?: PropValue[];
+} | {
+    code: string;
+    type: "layout-effect";
+    import: string;
+    props?: PropValue[];
+}>;
+export declare function generateTriplex(generator: Generator, options: GenerateTriplexOptions | undefined): void;

package/dist/integrations/triplex.js

@@ -0,0 +1,159 @@
+import { unique } from "../lib/array.js";
+function generateProvidersModule(generator) {
+    const canvasProviders = [];
+    const globalProviders = [];
+    const providerDefs = {
+        uikit: {
+            type: "layout-effect",
+            props: [
+                {
+                    declaredPropDefaultValue: '"light"',
+                    declaredPropName: "colorMode",
+                    propName: "colorMode",
+                    propValue: "colorMode",
+                    declaredPropType: '"light" | "dark"',
+                },
+            ],
+            code: `
+        setPreferredColorScheme(colorMode);
+      `,
+            import: 'import { setPreferredColorScheme } from "@react-three/uikit"',
+        },
+        rapier: {
+            component: "Physics",
+            type: "wrapped-jsx",
+            import: 'import { Physics } from "@react-three/rapier";',
+            props: [
+                {
+                    declaredPropDefaultValue: false,
+                    declaredPropName: "physicsEnabled",
+                    propName: "paused",
+                    propValue: "!physicsEnabled",
+                    declaredPropType: "boolean",
+                },
+                {
+                    declaredPropDefaultValue: true,
+                    declaredPropName: "debugPhysics",
+                    propName: "debug",
+                    propValue: "debugPhysics",
+                    declaredPropType: "boolean",
+                },
+            ],
+        },
+        postprocessing: {
+            type: "inline-jsx",
+            code: `
+        <EffectComposer enabled={postProcessingEnabled}>
+          <DepthOfField
+            focusDistance={0}
+            focalLength={0.02}
+            bokehScale={2}
+            height={480}
+          />
+          <Bloom luminanceThreshold={0} luminanceSmoothing={0.9} height={300} />
+        </EffectComposer>
+      `,
+            import: 'import { Bloom, DepthOfField, EffectComposer } from "@react-three/postprocessing";',
+            props: [
+                {
+                    declaredPropDefaultValue: true,
+                    declaredPropName: "postProcessingEnabled",
+                    propName: "enabled",
+                    propValue: "postProcessingEnabled",
+                    declaredPropType: "boolean",
+                },
+            ],
+        },
+    };
+    if (generator.options.rapier) {
+        canvasProviders.push("rapier");
+    }
+    if (!!generator.options.postprocessing && !generator.options.xr) {
+        canvasProviders.push("postprocessing");
+    }
+    if (generator.options.uikit) {
+        globalProviders.push("uikit");
+    }
+    function generateProviderFunction(name, { jsdoc, providers }) {
+        const resolvedProviders = providers.map((provider) => providerDefs[provider]);
+        const providerProps = resolvedProviders.flatMap((provider) => provider.props || []);
+        const providerImports = resolvedProviders.flatMap((provider) => provider.import);
+        const wrappedComponents = resolvedProviders.filter((provider) => provider.type === "wrapped-jsx");
+        const inlineComponents = resolvedProviders.filter((provider) => provider.type === "inline-jsx");
+        const layoutEffects = resolvedProviders.filter((provider) => provider.type === "layout-effect");
+        const declaredProps = providerProps
+            .map((prop) => `${prop.declaredPropName} = ${prop.declaredPropDefaultValue}`)
+            .join(", ");
+        const declaredTypes = providerProps
+            .map((prop) => `${prop.declaredPropName}?: ${prop.declaredPropType}`)
+            .join("; ");
+        const reactImports = ["type ReactNode"];
+        if (layoutEffects.length) {
+            reactImports.push("useLayoutEffect");
+        }
+        return {
+            reactImports,
+            imports: providerImports,
+            code: `
+      /**
+${jsdoc
+                .split("\n")
+                .map((line) => `       * ${line}`)
+                .join("\n")}
+       */
+      export function ${name}({ children, ${declaredProps} }: { children: ReactNode; ${declaredTypes} }) {
+        ${layoutEffects.length
+                ? `
+          useLayoutEffect(() => {
+            ${layoutEffects.map((effect) => effect.code).join("\n")}
+          }, [${layoutEffects.map((effect) => effect.props?.[0]?.propValue)}]);
+        `
+                : ""}
+        return (
+          <>
+            ${inlineComponents.map((provider) => provider.code)}
+            ${wrappedComponents.reduce((acc, provider) => {
+                const props = provider.props
+                    ?.map((prop) => `${prop.propName}={${prop.propValue}}`)
+                    .join(" ");
+                return `<${provider.component} ${props}>${acc}</${provider.component}>`;
+            }, "{children}")}
+          </>
+        );
+      }`,
+        };
+    }
+    const global = generateProviderFunction("GlobalProvider", {
+        jsdoc: "The global provider is rendered at the root of your application,\nuse it to set up global configuration like themes.\nProps defined on this component appear as controls inside Triplex.\n\nSee: https://triplex.dev/docs/building-your-scene/providers#global-provider",
+        providers: globalProviders,
+    });
+    const canvas = generateProviderFunction("CanvasProvider", {
+        jsdoc: "The canvas provider is rendered as a child inside the React Three Fiber canvas,\nuse it to set up canvas specific configuration like post-processing and physics.\nProps defined on this component appear as controls inside Triplex.\n\nSee: https://triplex.dev/docs/building-your-scene/providers#canvas-provider",
+        providers: canvasProviders,
+    });
+    return `
+    import { ${unique(global.reactImports, canvas.reactImports).sort().join(", ")} } from "react";
+    ${unique(global.imports, canvas.imports).sort().join("\n")}
+    
+    ${global.code}
+    ${canvas.code}
+  `;
+}
+export function generateTriplex(generator, options) {
+    if (options == null) {
+        return;
+    }
+    generator.inject("vscode-extension-suggestion", "trytriplex.triplex-vsce");
+    generator.inject("readme-tools", `[Triplex](https://triplex.dev) - Your visual workspace for React / Three Fiber. Get started by installing [Triplex for VS Code](https://triplex.dev/docs/get-started/vscode). Don't use Visual Studio Code? Download [Triplex Standalone](https://triplex.dev/docs/get-started/standalone).`);
+    generator.addFile(".triplex/providers.tsx", {
+        content: generateProvidersModule(generator),
+        type: "text",
+    });
+    generator.addFile(".triplex/config.json", {
+        content: JSON.stringify({
+            $schema: "https://triplex.dev/config.schema.json",
+            provider: "./providers.tsx",
+        }, null, 2),
+        type: "text",
+    });
+}

package/dist/integrations/uikit.d.ts

@@ -0,0 +1,3 @@
+import type { Generator } from "../index.js";
+export type GenerateUikitOptions = {} | boolean;
+export declare function generateUikit(generator: Generator, options: GenerateUikitOptions | undefined): void;

package/dist/integrations/uikit.js

@@ -0,0 +1,7 @@
+export function generateUikit(generator, options) {
+    if (options == null) {
+        return;
+    }
+    generator.addDependency("@react-three/uikit", "^0.8.15");
+    generator.inject("readme-libraries", `[@react-three/uikit](https://pmndrs.github.io/uikit/docs/) - UI primitives for React Three Fiber`);
+}

package/dist/integrations/viverse.d.ts

@@ -0,0 +1,3 @@
+import type { Generator } from "../index.js";
+export type GenerateViverseOptions = {} | boolean;
+export declare function generateViverse(generator: Generator, options: GenerateViverseOptions | undefined): void;

package/dist/integrations/viverse.js

@@ -0,0 +1,74 @@
+export function generateViverse(generator, options) {
+    if (options == null || (generator.options.packageManager ?? "npm") != "npm") {
+        return;
+    }
+    generator.addFile(".github/workflows/viverse.yml", {
+        type: "text",
+        content: `name: Deploy to Viverse
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  check-secrets:
+    runs-on: ubuntu-latest
+    outputs:
+      secrets-available: \${{ steps.check.outputs.secrets-available }}
+    steps:
+      - id: check
+        run: |
+          if [[ -n "\${{ secrets.VIVERSE_EMAIL }}" && -n "\${{ secrets.VIVERSE_PASSWORD }}" ]]; then
+            echo "secrets-available=true" >> $GITHUB_OUTPUT
+          else
+            echo "secrets-available=false" >> $GITHUB_OUTPUT
+          fi
+
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    needs: check-secrets
+    # Only run if secrets are present
+    if: needs.check-secrets.outputs.secrets-available == 'true'
+    permissions:
+      contents: read
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: 22
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build project
+        run: npm run build
+
+      - name: Viverse Login
+        run: npx viverse-cli auth login -e \${{ secrets.VIVERSE_EMAIL }} -p \${{ secrets.VIVERSE_PASSWORD }}
+
+      - name: Deploy to Viverse
+        run: npx viverse-cli app publish ./dist --auto-create-app --name ${generator.options.name}
+
+`,
+    });
+    generator.addDependency("@viverse/cli", "^0.9.5-beta.8");
+    generator.inject("readme-start", `A GitHub CI/CD workflow for publishing to Viverse is configured.
+
+To use publish to viverse via the CI/CD workflow:
+1. Set \`VIVERSE_EMAIL\` and \`VIVERSE_PASSWORD\` secrets in your repository settings under \`Secrets and Variables\` > \`Actions\` > \`New repository secret\`
+2. Manually trigger the "Deploy to Viverse" workflow or push to the main branch
+
+**Manual CLI Upload:**
+You can also upload your project manually using the Viverse CLI:
+\`\`\`bash
+viverse-cli auth login -e <email> -p <password>
+npm run build
+viverse-cli app publish ./dist --auto-create-app --name ${generator.options.name}
+\`\`\`\n`);
+}

package/dist/integrations/xr.d.ts

@@ -0,0 +1,5 @@
+import type { Generator } from "../index.js";
+export type GenerateXrOptions = {
+    storeOptions?: any;
+} | boolean;
+export declare function generateXr(generator: Generator, options: GenerateXrOptions | undefined): void;