@dcl/ecs 7.0.0-3548419522.commit-ddcf4b7 → 7.0.0

package/dist/components/generated/pb/decentraland/sdk/components/camera_mode.gen.js

@@ -0,0 +1,33 @@
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBCameraMode() {
+    return { mode: 0 };
+}
+/**
+ * Internal
+ */
+export const PBCameraMode = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.mode !== 0) {
+            writer.uint32(8).int32(message.mode);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBCameraMode();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.mode = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

package/dist/components/generated/pb/decentraland/sdk/components/camera_mode_area.gen.d.ts

@@ -0,0 +1,14 @@
+import { CameraType } from './common/camera_type.gen';
+import { Vector3 } from '../../common/vectors.gen';
+import _m0 from 'protobufjs/minimal';
+export interface PBCameraModeArea {
+    area: Vector3 | undefined;
+    mode: CameraType;
+}
+/**
+ * Internal
+ */
+export declare const PBCameraModeArea: {
+    encode(message: PBCameraModeArea, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBCameraModeArea;
+};

package/dist/components/generated/pb/decentraland/sdk/components/camera_mode_area.gen.js

@@ -0,0 +1,40 @@
+import { Vector3 } from '../../common/vectors.gen';
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBCameraModeArea() {
+    return { area: undefined, mode: 0 };
+}
+/**
+ * Internal
+ */
+export const PBCameraModeArea = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.area !== undefined) {
+            Vector3.encode(message.area, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.mode !== 0) {
+            writer.uint32(16).int32(message.mode);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBCameraModeArea();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.area = Vector3.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.mode = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

package/dist/components/generated/pb/decentraland/sdk/components/common/camera_type.gen.d.ts

@@ -0,0 +1,4 @@
+export declare const enum CameraType {
+    CT_FIRST_PERSON = 0,
+    CT_THIRD_PERSON = 1
+}

package/dist/components/generated/pb/decentraland/sdk/components/common/camera_type.gen.js

@@ -0,0 +1,7 @@
+/* eslint-disable */
+const protobufPackage = 'decentraland.sdk.components.common';
+export var CameraType;
+(function (CameraType) {
+    CameraType[CameraType["CT_FIRST_PERSON"] = 0] = "CT_FIRST_PERSON";
+    CameraType[CameraType["CT_THIRD_PERSON"] = 1] = "CT_THIRD_PERSON";
+})(CameraType || (CameraType = {}));

package/dist/components/generated/pb/decentraland/sdk/components/common/id.gen.d.ts

@@ -0,0 +1 @@
+declare const protobufPackage = "decentraland.sdk.components.common";

package/dist/components/generated/pb/decentraland/sdk/components/common/id.gen.js

@@ -0,0 +1,3 @@
+"use strict";
+/* eslint-disable */
+const protobufPackage = 'decentraland.sdk.components.common';

package/dist/components/generated/pb/decentraland/sdk/components/common/input_action.gen.d.ts

@@ -0,0 +1,16 @@
+export declare const enum InputAction {
+    IA_POINTER = 0,
+    IA_PRIMARY = 1,
+    IA_SECONDARY = 2,
+    IA_ANY = 3,
+    IA_FORWARD = 4,
+    IA_BACKWARD = 5,
+    IA_RIGHT = 6,
+    IA_LEFT = 7,
+    IA_JUMP = 8,
+    IA_WALK = 9,
+    IA_ACTION_3 = 10,
+    IA_ACTION_4 = 11,
+    IA_ACTION_5 = 12,
+    IA_ACTION_6 = 13
+}

package/dist/components/generated/pb/decentraland/sdk/components/common/input_action.gen.js

@@ -0,0 +1,19 @@
+/* eslint-disable */
+const protobufPackage = 'decentraland.sdk.components.common';
+export var InputAction;
+(function (InputAction) {
+    InputAction[InputAction["IA_POINTER"] = 0] = "IA_POINTER";
+    InputAction[InputAction["IA_PRIMARY"] = 1] = "IA_PRIMARY";
+    InputAction[InputAction["IA_SECONDARY"] = 2] = "IA_SECONDARY";
+    InputAction[InputAction["IA_ANY"] = 3] = "IA_ANY";
+    InputAction[InputAction["IA_FORWARD"] = 4] = "IA_FORWARD";
+    InputAction[InputAction["IA_BACKWARD"] = 5] = "IA_BACKWARD";
+    InputAction[InputAction["IA_RIGHT"] = 6] = "IA_RIGHT";
+    InputAction[InputAction["IA_LEFT"] = 7] = "IA_LEFT";
+    InputAction[InputAction["IA_JUMP"] = 8] = "IA_JUMP";
+    InputAction[InputAction["IA_WALK"] = 9] = "IA_WALK";
+    InputAction[InputAction["IA_ACTION_3"] = 10] = "IA_ACTION_3";
+    InputAction[InputAction["IA_ACTION_4"] = 11] = "IA_ACTION_4";
+    InputAction[InputAction["IA_ACTION_5"] = 12] = "IA_ACTION_5";
+    InputAction[InputAction["IA_ACTION_6"] = 13] = "IA_ACTION_6";
+})(InputAction || (InputAction = {}));

package/dist/components/generated/pb/decentraland/sdk/components/common/texts.gen.d.ts

@@ -0,0 +1,15 @@
+export declare const enum TextAlignMode {
+    TAM_TOP_LEFT = 0,
+    TAM_TOP_CENTER = 1,
+    TAM_TOP_RIGHT = 2,
+    TAM_MIDDLE_LEFT = 3,
+    TAM_MIDDLE_CENTER = 4,
+    TAM_MIDDLE_RIGHT = 5,
+    TAM_BOTTOM_LEFT = 6,
+    TAM_BOTTOM_CENTER = 7,
+    TAM_BOTTOM_RIGHT = 8
+}
+export declare const enum Font {
+    F_LIBERATION_SANS = 0,
+    F_SANS_SERIF = 1
+}

package/dist/components/generated/pb/decentraland/sdk/components/common/texts.gen.js

@@ -0,0 +1,19 @@
+/* eslint-disable */
+const protobufPackage = 'decentraland.sdk.components.common';
+export var TextAlignMode;
+(function (TextAlignMode) {
+    TextAlignMode[TextAlignMode["TAM_TOP_LEFT"] = 0] = "TAM_TOP_LEFT";
+    TextAlignMode[TextAlignMode["TAM_TOP_CENTER"] = 1] = "TAM_TOP_CENTER";
+    TextAlignMode[TextAlignMode["TAM_TOP_RIGHT"] = 2] = "TAM_TOP_RIGHT";
+    TextAlignMode[TextAlignMode["TAM_MIDDLE_LEFT"] = 3] = "TAM_MIDDLE_LEFT";
+    TextAlignMode[TextAlignMode["TAM_MIDDLE_CENTER"] = 4] = "TAM_MIDDLE_CENTER";
+    TextAlignMode[TextAlignMode["TAM_MIDDLE_RIGHT"] = 5] = "TAM_MIDDLE_RIGHT";
+    TextAlignMode[TextAlignMode["TAM_BOTTOM_LEFT"] = 6] = "TAM_BOTTOM_LEFT";
+    TextAlignMode[TextAlignMode["TAM_BOTTOM_CENTER"] = 7] = "TAM_BOTTOM_CENTER";
+    TextAlignMode[TextAlignMode["TAM_BOTTOM_RIGHT"] = 8] = "TAM_BOTTOM_RIGHT";
+})(TextAlignMode || (TextAlignMode = {}));
+export var Font;
+(function (Font) {
+    Font[Font["F_LIBERATION_SANS"] = 0] = "F_LIBERATION_SANS";
+    Font[Font["F_SANS_SERIF"] = 1] = "F_SANS_SERIF";
+})(Font || (Font = {}));

package/dist/components/generated/pb/decentraland/sdk/components/gltf_container.gen.d.ts

@@ -0,0 +1,12 @@
+import _m0 from 'protobufjs/minimal';
+export interface PBGltfContainer {
+    /** which file to load */
+    src: string;
+}
+/**
+ * Internal
+ */
+export declare const PBGltfContainer: {
+    encode(message: PBGltfContainer, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBGltfContainer;
+};

package/dist/components/generated/pb/decentraland/sdk/components/gltf_container.gen.js

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+function createBasePBGltfContainer() {
+    return { src: '' };
+}
+/**
+ * Internal
+ */
+export const PBGltfContainer = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.src !== '') {
+            writer.uint32(10).string(message.src);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBGltfContainer();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.src = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

package/dist/components/generated/pb/decentraland/sdk/components/material.gen.d.ts

@@ -0,0 +1,82 @@
+import { TextureUnion } from '../../common/texture.gen';
+import { Color3 } from '../../common/colors.gen';
+import _m0 from 'protobufjs/minimal';
+export declare const enum MaterialTransparencyMode {
+    MTM_OPAQUE = 0,
+    MTM_ALPHA_TEST = 1,
+    MTM_ALPHA_BLEND = 2,
+    MTM_ALPHA_TEST_AND_ALPHA_BLEND = 3,
+    MTM_AUTO = 4
+}
+export interface PBMaterial {
+    material?: {
+        $case: 'unlit';
+        unlit: PBMaterial_UnlitMaterial;
+    } | {
+        $case: 'pbr';
+        pbr: PBMaterial_PbrMaterial;
+    };
+}
+export interface PBMaterial_UnlitMaterial {
+    /** default = null */
+    texture?: TextureUnion | undefined;
+    /** default = 0.5. range value: from 0 to 1 */
+    alphaTest?: number | undefined;
+    /** default =  true */
+    castShadows?: boolean | undefined;
+}
+export interface PBMaterial_PbrMaterial {
+    /** default = null */
+    texture?: TextureUnion | undefined;
+    /** default = 0.5. range value: from 0 to 1 */
+    alphaTest?: number | undefined;
+    /** default =  true */
+    castShadows?: boolean | undefined;
+    /** default = null */
+    alphaTexture?: TextureUnion | undefined;
+    /** default = null */
+    emissiveTexture?: TextureUnion | undefined;
+    /** default = null */
+    bumpTexture?: TextureUnion | undefined;
+    /** default = white; */
+    albedoColor?: Color3 | undefined;
+    /** default = black; */
+    emissiveColor?: Color3 | undefined;
+    /** default = white; */
+    reflectivityColor?: Color3 | undefined;
+    /** default = TransparencyMode.Auto */
+    transparencyMode?: MaterialTransparencyMode | undefined;
+    /** default = 0.5 */
+    metallic?: number | undefined;
+    /** default = 0.5 */
+    roughness?: number | undefined;
+    /** default = 1 */
+    glossiness?: number | undefined;
+    /** default = 1 */
+    specularIntensity?: number | undefined;
+    /** default = 2 */
+    emissiveIntensity?: number | undefined;
+    /** default = 1 */
+    directIntensity?: number | undefined;
+}
+/**
+ * Internal
+ */
+export declare const PBMaterial: {
+    encode(message: PBMaterial, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBMaterial;
+};
+/**
+ * Internal
+ */
+export declare const PBMaterial_UnlitMaterial: {
+    encode(message: PBMaterial_UnlitMaterial, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBMaterial_UnlitMaterial;
+};
+/**
+ * Internal
+ */
+export declare const PBMaterial_PbrMaterial: {
+    encode(message: PBMaterial_PbrMaterial, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBMaterial_PbrMaterial;
+};

package/dist/components/generated/pb/decentraland/sdk/components/material.gen.js

@@ -0,0 +1,231 @@
+/* eslint-disable */
+import { TextureUnion } from '../../common/texture.gen';
+import { Color3 } from '../../common/colors.gen';
+import _m0 from 'protobufjs/minimal';
+const protobufPackage = 'decentraland.sdk.components';
+export var MaterialTransparencyMode;
+(function (MaterialTransparencyMode) {
+    MaterialTransparencyMode[MaterialTransparencyMode["MTM_OPAQUE"] = 0] = "MTM_OPAQUE";
+    MaterialTransparencyMode[MaterialTransparencyMode["MTM_ALPHA_TEST"] = 1] = "MTM_ALPHA_TEST";
+    MaterialTransparencyMode[MaterialTransparencyMode["MTM_ALPHA_BLEND"] = 2] = "MTM_ALPHA_BLEND";
+    MaterialTransparencyMode[MaterialTransparencyMode["MTM_ALPHA_TEST_AND_ALPHA_BLEND"] = 3] = "MTM_ALPHA_TEST_AND_ALPHA_BLEND";
+    MaterialTransparencyMode[MaterialTransparencyMode["MTM_AUTO"] = 4] = "MTM_AUTO";
+})(MaterialTransparencyMode || (MaterialTransparencyMode = {}));
+function createBasePBMaterial() {
+    return { material: undefined };
+}
+/**
+ * Internal
+ */
+export const PBMaterial = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.material?.$case === 'unlit') {
+            PBMaterial_UnlitMaterial.encode(message.material.unlit, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.material?.$case === 'pbr') {
+            PBMaterial_PbrMaterial.encode(message.material.pbr, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBMaterial();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.material = { $case: 'unlit', unlit: PBMaterial_UnlitMaterial.decode(reader, reader.uint32()) };
+                    break;
+                case 2:
+                    message.material = { $case: 'pbr', pbr: PBMaterial_PbrMaterial.decode(reader, reader.uint32()) };
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBMaterial_UnlitMaterial() {
+    return { texture: undefined, alphaTest: undefined, castShadows: undefined };
+}
+/**
+ * Internal
+ */
+export const PBMaterial_UnlitMaterial = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.texture !== undefined) {
+            TextureUnion.encode(message.texture, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.alphaTest !== undefined) {
+            writer.uint32(21).float(message.alphaTest);
+        }
+        if (message.castShadows !== undefined) {
+            writer.uint32(24).bool(message.castShadows);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBMaterial_UnlitMaterial();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.texture = TextureUnion.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.alphaTest = reader.float();
+                    break;
+                case 3:
+                    message.castShadows = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};
+function createBasePBMaterial_PbrMaterial() {
+    return {
+        texture: undefined,
+        alphaTest: undefined,
+        castShadows: undefined,
+        alphaTexture: undefined,
+        emissiveTexture: undefined,
+        bumpTexture: undefined,
+        albedoColor: undefined,
+        emissiveColor: undefined,
+        reflectivityColor: undefined,
+        transparencyMode: undefined,
+        metallic: undefined,
+        roughness: undefined,
+        glossiness: undefined,
+        specularIntensity: undefined,
+        emissiveIntensity: undefined,
+        directIntensity: undefined
+    };
+}
+/**
+ * Internal
+ */
+export const PBMaterial_PbrMaterial = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.texture !== undefined) {
+            TextureUnion.encode(message.texture, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.alphaTest !== undefined) {
+            writer.uint32(21).float(message.alphaTest);
+        }
+        if (message.castShadows !== undefined) {
+            writer.uint32(24).bool(message.castShadows);
+        }
+        if (message.alphaTexture !== undefined) {
+            TextureUnion.encode(message.alphaTexture, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.emissiveTexture !== undefined) {
+            TextureUnion.encode(message.emissiveTexture, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.bumpTexture !== undefined) {
+            TextureUnion.encode(message.bumpTexture, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.albedoColor !== undefined) {
+            Color3.encode(message.albedoColor, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.emissiveColor !== undefined) {
+            Color3.encode(message.emissiveColor, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.reflectivityColor !== undefined) {
+            Color3.encode(message.reflectivityColor, writer.uint32(74).fork()).ldelim();
+        }
+        if (message.transparencyMode !== undefined) {
+            writer.uint32(80).int32(message.transparencyMode);
+        }
+        if (message.metallic !== undefined) {
+            writer.uint32(93).float(message.metallic);
+        }
+        if (message.roughness !== undefined) {
+            writer.uint32(101).float(message.roughness);
+        }
+        if (message.glossiness !== undefined) {
+            writer.uint32(109).float(message.glossiness);
+        }
+        if (message.specularIntensity !== undefined) {
+            writer.uint32(117).float(message.specularIntensity);
+        }
+        if (message.emissiveIntensity !== undefined) {
+            writer.uint32(125).float(message.emissiveIntensity);
+        }
+        if (message.directIntensity !== undefined) {
+            writer.uint32(133).float(message.directIntensity);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePBMaterial_PbrMaterial();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.texture = TextureUnion.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.alphaTest = reader.float();
+                    break;
+                case 3:
+                    message.castShadows = reader.bool();
+                    break;
+                case 4:
+                    message.alphaTexture = TextureUnion.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.emissiveTexture = TextureUnion.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.bumpTexture = TextureUnion.decode(reader, reader.uint32());
+                    break;
+                case 7:
+                    message.albedoColor = Color3.decode(reader, reader.uint32());
+                    break;
+                case 8:
+                    message.emissiveColor = Color3.decode(reader, reader.uint32());
+                    break;
+                case 9:
+                    message.reflectivityColor = Color3.decode(reader, reader.uint32());
+                    break;
+                case 10:
+                    message.transparencyMode = reader.int32();
+                    break;
+                case 11:
+                    message.metallic = reader.float();
+                    break;
+                case 12:
+                    message.roughness = reader.float();
+                    break;
+                case 13:
+                    message.glossiness = reader.float();
+                    break;
+                case 14:
+                    message.specularIntensity = reader.float();
+                    break;
+                case 15:
+                    message.emissiveIntensity = reader.float();
+                    break;
+                case 16:
+                    message.directIntensity = reader.float();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    }
+};

package/dist/components/generated/pb/decentraland/sdk/components/mesh_collider.gen.d.ts

@@ -0,0 +1,70 @@
+import _m0 from 'protobufjs/minimal';
+export declare const enum ColliderLayer {
+    CL_NONE = 0,
+    CL_POINTER = 1,
+    CL_PHYSICS = 2
+}
+export interface PBMeshCollider {
+    /** default = ColliderLayer.Physics | ColliderLayer.Pointer */
+    collisionMask?: number | undefined;
+    mesh?: {
+        $case: 'box';
+        box: PBMeshCollider_BoxMesh;
+    } | {
+        $case: 'sphere';
+        sphere: PBMeshCollider_SphereMesh;
+    } | {
+        $case: 'cylinder';
+        cylinder: PBMeshCollider_CylinderMesh;
+    } | {
+        $case: 'plane';
+        plane: PBMeshCollider_PlaneMesh;
+    };
+}
+export interface PBMeshCollider_BoxMesh {
+}
+export interface PBMeshCollider_CylinderMesh {
+    /** default=1.0 */
+    radiusTop?: number | undefined;
+    /** default=1.0 */
+    radiusBottom?: number | undefined;
+}
+export interface PBMeshCollider_PlaneMesh {
+}
+export interface PBMeshCollider_SphereMesh {
+}
+/**
+ * Internal
+ */
+export declare const PBMeshCollider: {
+    encode(message: PBMeshCollider, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider;
+};
+/**
+ * Internal
+ */
+export declare const PBMeshCollider_BoxMesh: {
+    encode(_: PBMeshCollider_BoxMesh, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_BoxMesh;
+};
+/**
+ * Internal
+ */
+export declare const PBMeshCollider_CylinderMesh: {
+    encode(message: PBMeshCollider_CylinderMesh, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_CylinderMesh;
+};
+/**
+ * Internal
+ */
+export declare const PBMeshCollider_PlaneMesh: {
+    encode(_: PBMeshCollider_PlaneMesh, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_PlaneMesh;
+};
+/**
+ * Internal
+ */
+export declare const PBMeshCollider_SphereMesh: {
+    encode(_: PBMeshCollider_SphereMesh, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_SphereMesh;
+};