Upload folder using huggingface_hub

6.5.0/model3D/Example.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">
+	export let value: string | null;
+	export let type: "gallery" | "table";
+	export let selected = false;
+</script>
+
+<div
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+>
+	{value ? value : ""}
+</div>
+
+<style>
+	.gallery {
+		padding: var(--size-1) var(--size-2);
+	}
+</style>

6.5.0/model3D/Index.svelte

@@ -0,0 +1,177 @@
+<script context="module" lang="ts">
+	export { default as BaseModel3D } from "./shared/Model3D.svelte";
+	export { default as BaseModel3DUpload } from "./shared/Model3DUpload.svelte";
+	export { default as BaseExample } from "./Example.svelte";
+</script>
+
+<script lang="ts">
+	import { tick } from "svelte";
+	import type { Model3DProps, Model3DEvents } from "./types";
+	import type { FileData } from "@gradio/client";
+	import { Gradio } from "@gradio/utils";
+	import Model3D from "./shared/Model3D.svelte";
+	import Model3DUpload from "./shared/Model3DUpload.svelte";
+	import {
+		BlockLabel,
+		Block,
+		Empty,
+		UploadText,
+		IconButtonWrapper
+	} from "@gradio/atoms";
+	import { File } from "@gradio/icons";
+	import { StatusTracker } from "@gradio/statustracker";
+
+	class Model3dGradio extends Gradio<Model3DEvents, Model3DProps> {
+		async get_data() {
+			if (upload_promise) {
+				await upload_promise;
+				await tick();
+			}
+			const data = await super.get_data();
+
+			return data;
+		}
+	}
+
+	const props = $props();
+	const gradio = new Model3dGradio(props);
+
+	let old_value = $state(gradio.props.value);
+	let uploading = $state(false);
+	let dragging = $state(false);
+	let has_change_history = $state(false);
+	let upload_promise = $state<Promise<any>>();
+
+	const is_browser = typeof window !== "undefined";
+
+	$effect(() => {
+		if (old_value !== gradio.props.value) {
+			old_value = gradio.props.value;
+			gradio.dispatch("change");
+		}
+	});
+
+	function handle_change(detail: FileData | null) {
+		gradio.props.value = detail;
+		gradio.dispatch("change", detail);
+		has_change_history = true;
+	}
+
+	function handle_drag(detail: boolean) {
+		dragging = detail;
+	}
+
+	function handle_clear() {
+		gradio.props.value = null;
+		gradio.dispatch("clear");
+	}
+
+	function handle_load(detail: FileData) {
+		gradio.props.value = detail;
+		gradio.dispatch("upload");
+	}
+
+	function handle_error(detail: string) {
+		if (gradio.shared.loading_status)
+			gradio.shared.loading_status.status = "error";
+		gradio.dispatch("error", detail);
+	}
+</script>
+
+{#if !gradio.shared.interactive}
+	<Block
+		visible={gradio.shared.visible}
+		variant={gradio.props.value === null ? "dashed" : "solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+		height={gradio.props.height}
+	>
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+			on_clear_status={() =>
+				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+		/>
+
+		{#if gradio.props.value && is_browser}
+			<Model3D
+				value={gradio.props.value}
+				i18n={gradio.i18n}
+				display_mode={gradio.props.display_mode}
+				clear_color={gradio.props.clear_color}
+				label={gradio.shared.label}
+				show_label={gradio.shared.show_label}
+				camera_position={gradio.props.camera_position}
+				zoom_speed={gradio.props.zoom_speed}
+				{has_change_history}
+			/>
+		{:else}
+			{#if gradio.shared.show_label && gradio.props.buttons && gradio.props.buttons.length > 0}
+				<IconButtonWrapper
+					buttons={gradio.props.buttons}
+					on_custom_button_click={(id) => {
+						gradio.dispatch("custom_button_click", { id });
+					}}
+				/>
+			{/if}
+			<BlockLabel
+				show_label={gradio.shared.show_label}
+				Icon={File}
+				label={gradio.shared.label || "3D Model"}
+			/>
+
+			<Empty unpadded_box={true} size="large"><File /></Empty>
+		{/if}
+	</Block>
+{:else}
+	<Block
+		visible={gradio.shared.visible}
+		variant={gradio.props.value === null ? "dashed" : "solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+		height={gradio.props.height}
+	>
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+			on_clear_status={() =>
+				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+		/>
+
+		<Model3DUpload
+			bind:upload_promise
+			label={gradio.shared.label}
+			show_label={gradio.shared.show_label}
+			root={gradio.shared.root}
+			display_mode={gradio.props.display_mode}
+			clear_color={gradio.props.clear_color}
+			bind:value={gradio.props.value}
+			camera_position={gradio.props.camera_position}
+			zoom_speed={gradio.props.zoom_speed}
+			bind:uploading
+			onchange={handle_change}
+			ondrag={handle_drag}
+			onclear={handle_clear}
+			onload={handle_load}
+			onerror={handle_error}
+			i18n={gradio.i18n}
+			max_file_size={gradio.shared.max_file_size}
+			upload={(...args) => gradio.shared.client.upload(...args)}
+			stream_handler={(...args) => gradio.shared.client.stream(...args)}
+		>
+			<UploadText i18n={gradio.i18n} type="file" />
+		</Model3DUpload>
+	</Block>
+{/if}

6.5.0/model3D/package.json

@@ -0,0 +1,54 @@
+{
+	"name": "@gradio/model3d",
+	"version": "0.16.3",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@babylonjs/core": "^8.30.5",
+		"@babylonjs/loaders": "^8.30.5",
+		"@babylonjs/viewer": "^8.30.5",
+		"@gradio/atoms": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"@types/babylon": "^6.16.9",
+		"dequal": "^2.0.3",
+		"gsplat": "^1.2.9"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"main_changeset": true,
+	"main": "./Index.svelte",
+	"exports": {
+		".": {
+			"gradio": "./Index.svelte",
+			"svelte": "./dist/Index.svelte",
+			"types": "./dist/Index.svelte.d.ts"
+		},
+		"./example": {
+			"gradio": "./Example.svelte",
+			"svelte": "./dist/Example.svelte",
+			"types": "./dist/Example.svelte.d.ts"
+		},
+		"./base": {
+			"gradio": "./shared/Model3D.svelte",
+			"svelte": "./dist/shared/Model3D.svelte",
+			"types": "./dist/shared/Model3D.svelte.d.ts"
+		},
+		"./package.json": "./package.json"
+	},
+	"peerDependencies": {
+		"svelte": "^5.48.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/model3D"
+	}
+}

6.5.0/model3D/shared/Canvas3D.svelte

@@ -0,0 +1,125 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import type { FileData } from "@gradio/client";
+	import type { Viewer, ViewerDetails } from "@babylonjs/viewer";
+
+	let BABYLON_VIEWER: typeof import("@babylonjs/viewer");
+
+	let {
+		value,
+		display_mode,
+		clear_color,
+		camera_position,
+		zoom_speed,
+		pan_speed
+	}: {
+		value: FileData;
+		display_mode: "solid" | "point_cloud" | "wireframe";
+		clear_color: [number, number, number, number];
+		camera_position: [number | null, number | null, number | null];
+		zoom_speed: number;
+		pan_speed: number;
+	} = $props();
+
+	let url = $derived(value.url);
+
+	let canvas: HTMLCanvasElement;
+	let viewer = $state<Viewer>();
+	let viewerDetails = $state<Readonly<ViewerDetails>>();
+	let mounted = $state(false);
+
+	onMount(() => {
+		const initViewer = async (): Promise<void> => {
+			BABYLON_VIEWER = await import("@babylonjs/viewer");
+			BABYLON_VIEWER.CreateViewerForCanvas(canvas, {
+				clearColor: clear_color,
+				useRightHandedSystem: true,
+				animationAutoPlay: true,
+				cameraAutoOrbit: { enabled: false },
+				onInitialized: (details: any) => {
+					viewerDetails = details;
+				}
+			}).then((promiseViewer: any) => {
+				viewer = promiseViewer;
+				mounted = true;
+			});
+		};
+
+		initViewer();
+
+		return () => {
+			viewer?.dispose();
+		};
+	});
+
+	$effect(() => {
+		if (mounted) {
+			load_model(url);
+		}
+	});
+
+	function setRenderingMode(pointsCloud: boolean, wireframe: boolean): void {
+		if (!viewerDetails) return;
+		viewerDetails.scene.forcePointsCloud = pointsCloud;
+		viewerDetails.scene.forceWireframe = wireframe;
+	}
+
+	function load_model(url: string | undefined): void {
+		if (viewer) {
+			if (url) {
+				viewer
+					.loadModel(url, {
+						pluginOptions: {
+							obj: {
+								importVertexColors: true
+							}
+						}
+					})
+					.then(() => {
+						if (display_mode === "point_cloud") {
+							setRenderingMode(true, false);
+						} else if (display_mode === "wireframe") {
+							setRenderingMode(false, true);
+						} else {
+							update_camera(camera_position, zoom_speed, pan_speed);
+						}
+					});
+			} else {
+				viewer.resetModel();
+			}
+		}
+	}
+
+	export function update_camera(
+		camera_position: [number | null, number | null, number | null],
+		zoom_speed: number,
+		pan_speed: number
+	): void {
+		if (!viewerDetails) return;
+		const camera = viewerDetails.camera;
+		if (camera_position[0] !== null) {
+			camera.alpha = (camera_position[0] * Math.PI) / 180;
+		}
+		if (camera_position[1] !== null) {
+			camera.beta = (camera_position[1] * Math.PI) / 180;
+		}
+		if (camera_position[2] !== null) {
+			camera.radius = camera_position[2];
+		}
+		camera.lowerRadiusLimit = 0.1;
+		const updateCameraSensibility = (): void => {
+			camera.wheelPrecision = 250 / (camera.radius * zoom_speed);
+			camera.panningSensibility = (10000 * pan_speed) / camera.radius;
+		};
+		updateCameraSensibility();
+		camera.onAfterCheckInputsObservable.add(updateCameraSensibility);
+	}
+
+	export function reset_camera_position(): void {
+		if (viewerDetails && viewer) {
+			viewer.resetCamera();
+		}
+	}
+</script>
+
+<canvas bind:this={canvas}></canvas>

6.5.0/model3D/shared/Canvas3DGS.svelte

@@ -0,0 +1,110 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import * as SPLAT from "gsplat";
+	import type { FileData } from "@gradio/client";
+
+	let {
+		value,
+		zoom_speed,
+		pan_speed
+	}: {
+		value: FileData;
+		zoom_speed: number;
+		pan_speed: number;
+	} = $props();
+
+	let url = $derived(value.url);
+
+	let canvas: HTMLCanvasElement;
+	let scene: SPLAT.Scene;
+	let camera: SPLAT.Camera;
+	let renderer = $state<SPLAT.WebGLRenderer | null>(null);
+	let controls: SPLAT.OrbitControls;
+	let mounted = $state(false);
+	let frameId = $state<number | null>(null);
+
+	function reset_scene(): void {
+		if (frameId !== null) {
+			cancelAnimationFrame(frameId);
+			frameId = null;
+		}
+
+		if (renderer !== null) {
+			renderer.dispose();
+			renderer = null;
+		}
+
+		scene = new SPLAT.Scene();
+		camera = new SPLAT.Camera();
+		renderer = new SPLAT.WebGLRenderer(canvas);
+		controls = new SPLAT.OrbitControls(camera, canvas);
+		controls.zoomSpeed = zoom_speed;
+		controls.panSpeed = pan_speed;
+
+		if (!value) {
+			return;
+		}
+
+		let loading = false;
+		const load = async (): Promise<void> => {
+			if (loading) {
+				console.error("Already loading");
+				return;
+			}
+			if (!url) {
+				throw new Error("No resolved URL");
+			}
+			loading = true;
+			if (url.endsWith(".ply")) {
+				await SPLAT.PLYLoader.LoadAsync(url, scene, undefined);
+			} else if (url.endsWith(".splat")) {
+				await SPLAT.Loader.LoadAsync(url, scene, undefined);
+			} else {
+				throw new Error("Unsupported file type");
+			}
+			loading = false;
+		};
+
+		const frame = (): void => {
+			if (!renderer) {
+				return;
+			}
+
+			if (loading) {
+				frameId = requestAnimationFrame(frame);
+				return;
+			}
+
+			controls.update();
+			renderer.render(scene, camera);
+
+			frameId = requestAnimationFrame(frame);
+		};
+
+		load();
+		frameId = requestAnimationFrame(frame);
+	}
+
+	onMount(() => {
+		if (value != null) {
+			reset_scene();
+		}
+		mounted = true;
+
+		return () => {
+			if (renderer) {
+				renderer.dispose();
+			}
+		};
+	});
+
+	let path = $derived(value?.path);
+
+	$effect(() => {
+		if (canvas && mounted && path) {
+			reset_scene();
+		}
+	});
+</script>
+
+<canvas bind:this={canvas}></canvas>

6.5.0/model3D/shared/Model3D.svelte

@@ -0,0 +1,143 @@
+<script lang="ts">
+	import type { FileData } from "@gradio/client";
+	import { BlockLabel, IconButton, IconButtonWrapper } from "@gradio/atoms";
+	import { File, Download, Undo } from "@gradio/icons";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { dequal } from "dequal";
+	import type Canvas3DGS from "./Canvas3DGS.svelte";
+	import type Canvas3D from "./Canvas3D.svelte";
+
+	let {
+		value,
+		display_mode = "solid",
+		clear_color = [0, 0, 0, 0],
+		label = "",
+		show_label,
+		i18n,
+		zoom_speed = 1,
+		pan_speed = 1,
+		camera_position = [null, null, null],
+		has_change_history = false
+	}: {
+		value: FileData | null;
+		display_mode?: "solid" | "point_cloud" | "wireframe";
+		clear_color?: [number, number, number, number];
+		label?: string;
+		show_label: boolean;
+		i18n: I18nFormatter;
+		zoom_speed?: number;
+		pan_speed?: number;
+		camera_position?: [number | null, number | null, number | null];
+		has_change_history?: boolean;
+	} = $props();
+
+	let current_settings = $state({ camera_position, zoom_speed, pan_speed });
+	let use_3dgs = $state(false);
+	let Canvas3DGSComponent = $state<typeof Canvas3DGS>();
+	let Canvas3DComponent = $state<typeof Canvas3D>();
+	let canvas3d = $state<Canvas3D | undefined>();
+
+	async function loadCanvas3D(): Promise<typeof Canvas3D> {
+		const module = await import("./Canvas3D.svelte");
+		return module.default;
+	}
+	async function loadCanvas3DGS(): Promise<typeof Canvas3DGS> {
+		const module = await import("./Canvas3DGS.svelte");
+		return module.default;
+	}
+
+	$effect(() => {
+		if (value) {
+			use_3dgs = value.path.endsWith(".splat") || value.path.endsWith(".ply");
+			if (use_3dgs) {
+				loadCanvas3DGS().then((component) => {
+					Canvas3DGSComponent = component;
+				});
+			} else {
+				loadCanvas3D().then((component) => {
+					Canvas3DComponent = component;
+				});
+			}
+		}
+	});
+
+	function handle_undo(): void {
+		canvas3d?.reset_camera_position();
+	}
+
+	$effect(() => {
+		if (
+			!dequal(current_settings.camera_position, camera_position) ||
+			current_settings.zoom_speed !== zoom_speed ||
+			current_settings.pan_speed !== pan_speed
+		) {
+			canvas3d?.update_camera(camera_position, zoom_speed, pan_speed);
+			current_settings = { camera_position, zoom_speed, pan_speed };
+		}
+	});
+</script>
+
+<BlockLabel
+	{show_label}
+	Icon={File}
+	label={label || i18n("3D_model.3d_model")}
+/>
+{#if value}
+	<div class="model3D" data-testid="model3d">
+		<IconButtonWrapper>
+			{#if !use_3dgs}
+				<!-- Canvas3DGS doesn't implement the undo method (reset_camera_position) -->
+				<IconButton
+					Icon={Undo}
+					label="Undo"
+					onclick={() => handle_undo()}
+					disabled={!has_change_history}
+				/>
+			{/if}
+			<a
+				href={value.url}
+				target={window.__is_colab__ ? "_blank" : null}
+				download={window.__is_colab__ ? null : value.orig_name || value.path}
+			>
+				<IconButton Icon={Download} label={i18n("common.download")} />
+			</a>
+		</IconButtonWrapper>
+
+		{#if use_3dgs}
+			<svelte:component
+				this={Canvas3DGSComponent}
+				{value}
+				{zoom_speed}
+				{pan_speed}
+			/>
+		{:else}
+			<svelte:component
+				this={Canvas3DComponent}
+				bind:this={canvas3d}
+				{value}
+				{display_mode}
+				{clear_color}
+				{camera_position}
+				{zoom_speed}
+				{pan_speed}
+			/>
+		{/if}
+	</div>
+{/if}
+
+<style>
+	.model3D {
+		display: flex;
+		position: relative;
+		width: var(--size-full);
+		height: var(--size-full);
+		border-radius: var(--block-radius);
+		overflow: hidden;
+	}
+	.model3D :global(canvas) {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: contain;
+		overflow: hidden;
+	}
+</style>

6.5.0/model3D/shared/Model3DUpload.svelte

@@ -0,0 +1,179 @@
+<script lang="ts">
+	import { tick } from "svelte";
+	import { Upload, ModifyUpload } from "@gradio/upload";
+	import type { FileData, Client } from "@gradio/client";
+	import { BlockLabel } from "@gradio/atoms";
+	import { File } from "@gradio/icons";
+	import type { I18nFormatter } from "@gradio/utils";
+	import type Canvas3DGS from "./Canvas3DGS.svelte";
+	import type Canvas3D from "./Canvas3D.svelte";
+
+	let {
+		value = $bindable(),
+		display_mode = "solid",
+		clear_color = [0, 0, 0, 0],
+		label = "",
+		show_label,
+		root,
+		i18n,
+		zoom_speed = 1,
+		pan_speed = 1,
+		max_file_size = null,
+		uploading = $bindable(),
+		upload_promise = $bindable(),
+		camera_position = [null, null, null],
+		upload,
+		stream_handler,
+		onchange,
+		onclear,
+		ondrag,
+		onload,
+		onerror
+	}: {
+		value?: FileData | null;
+		display_mode?: "solid" | "point_cloud" | "wireframe";
+		clear_color?: [number, number, number, number];
+		label?: string;
+		show_label: boolean;
+		root: string;
+		i18n: I18nFormatter;
+		zoom_speed?: number;
+		pan_speed?: number;
+		max_file_size?: number | null;
+		uploading?: boolean;
+		upload_promise?: Promise<(FileData | null)[]> | null;
+		camera_position?: [number | null, number | null, number | null];
+		upload: Client["upload"];
+		stream_handler: Client["stream"];
+		onchange?: (value: FileData | null) => void;
+		onclear?: () => void;
+		ondrag?: (dragging: boolean) => void;
+		onload?: (value: FileData) => void;
+		onerror?: (error: string) => void;
+	} = $props();
+
+	let use_3dgs = $state(false);
+	let Canvas3DGSComponent = $state<typeof Canvas3DGS>();
+	let Canvas3DComponent = $state<typeof Canvas3D>();
+	let canvas3d = $state<Canvas3D | undefined>();
+	let dragging = $state(false);
+
+	async function loadCanvas3D(): Promise<typeof Canvas3D> {
+		const module = await import("./Canvas3D.svelte");
+		return module.default;
+	}
+	async function loadCanvas3DGS(): Promise<typeof Canvas3DGS> {
+		const module = await import("./Canvas3DGS.svelte");
+		return module.default;
+	}
+
+	$effect(() => {
+		if (value) {
+			use_3dgs = value.path.endsWith(".splat") || value.path.endsWith(".ply");
+			if (use_3dgs) {
+				loadCanvas3DGS().then((component) => {
+					Canvas3DGSComponent = component;
+				});
+			} else {
+				loadCanvas3D().then((component) => {
+					Canvas3DComponent = component;
+				});
+			}
+		}
+	});
+
+	$effect(() => {
+		ondrag?.(dragging);
+	});
+
+	async function handle_upload(detail: FileData): Promise<void> {
+		value = detail;
+		await tick();
+		onchange?.(value);
+		onload?.(value as FileData);
+	}
+
+	async function handle_clear(): Promise<void> {
+		value = null;
+		await tick();
+		onclear?.();
+		onchange?.(null);
+	}
+
+	async function handle_undo(): Promise<void> {
+		canvas3d?.reset_camera_position();
+	}
+
+	function handle_error(error: string): void {
+		onerror?.(error);
+	}
+</script>
+
+<BlockLabel {show_label} Icon={File} label={label || "3D Model"} />
+
+{#if value == null}
+	<Upload
+		bind:upload_promise
+		{upload}
+		{stream_handler}
+		onload={handle_upload}
+		{root}
+		{max_file_size}
+		filetype={[".stl", ".obj", ".gltf", ".glb", "model/obj", ".splat", ".ply"]}
+		bind:dragging
+		bind:uploading
+		onerror={handle_error}
+		aria_label={i18n("model3d.drop_to_upload")}
+	>
+		<slot />
+	</Upload>
+{:else}
+	<div class="input-model">
+		<ModifyUpload
+			undoable={!use_3dgs}
+			onclear={handle_clear}
+			{i18n}
+			onundo={handle_undo}
+		/>
+
+		{#if use_3dgs}
+			<svelte:component
+				this={Canvas3DGSComponent}
+				{value}
+				{zoom_speed}
+				{pan_speed}
+			/>
+		{:else}
+			<svelte:component
+				this={Canvas3DComponent}
+				bind:this={canvas3d}
+				{value}
+				{display_mode}
+				{clear_color}
+				{camera_position}
+				{zoom_speed}
+				{pan_speed}
+			/>
+		{/if}
+	</div>
+{/if}
+
+<style>
+	.input-model {
+		display: flex;
+		position: relative;
+		justify-content: center;
+		align-items: center;
+		width: var(--size-full);
+		height: var(--size-full);
+		border-radius: var(--block-radius);
+		overflow: hidden;
+	}
+
+	.input-model :global(canvas) {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: contain;
+		overflow: hidden;
+	}
+</style>

6.5.0/model3D/types.ts

@@ -0,0 +1,24 @@
+import type { FileData } from "@gradio/client";
+import type { LoadingStatus } from "js/statustracker";
+import type { CustomButton } from "@gradio/utils";
+
+export interface Model3DProps {
+	value: null | FileData;
+	display_mode: "solid" | "point_cloud" | "wireframe";
+	clear_color: [number, number, number, number];
+	height: number | undefined;
+	zoom_speed: number;
+	has_change_history: boolean;
+	camera_position: [number | null, number | null, number | null];
+	buttons: (string | CustomButton)[] | null;
+}
+
+export interface Model3DEvents {
+	change: FileData | null;
+	upload: FileData;
+	edit: never;
+	clear: never;
+	clear_status: LoadingStatus;
+	error: string;
+	custom_button_click: { id: number };
+}