@dcl/sdk 7.0.0-2982061039.commit-9cc9ea8 → 7.0.0-3000191624.commit-0ff97dc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/sdk",
-  "version": "7.0.0-2982061039.commit-9cc9ea8",
+  "version": "7.0.0-3000191624.commit-0ff97dc",
   "description": "",
   "main": "dist/src/index.js",
   "typings": "dist/index.d.ts",
@@ -27,8 +27,8 @@
     "src/cli/**/*.js"
   ],
   "dependencies": {
-    "@dcl/amd": "6.11.7-2982061039.commit-9cc9ea8",
-    "@dcl/build-ecs": "6.11.7-2982061039.commit-9cc9ea8",
+    "@dcl/amd": "6.11.7-3000191624.commit-0ff97dc",
+    "@dcl/build-ecs": "6.11.7-3000191624.commit-0ff97dc",
     "@dcl/kernel": "1.0.0-2638443584.commit-696a74b",
     "@dcl/posix": "^1.0.4",
     "@dcl/schemas": "4.8.0",
@@ -38,5 +38,5 @@
     "ignore": "^5.1.8"
   },
   "minCliVersion": "3.10.2",
-  "commit": "9cc9ea8eafb942a535f33ed483b653c88720ecb2"
+  "commit": "0ff97dc9c8394aec098148b4b99bd02a898ac0f9"
 }

package/types/rpc-modules/CommunicationsController/index.d.ts

@@ -0,0 +1,14 @@
+declare module "~system/CommunicationsController" {
+
+    export interface RealSendRequest {
+        message: string;
+    }
+    export interface RealSendResponse {
+    }
+
+// ########### BLOCK 
+
+    // importtype { RealSendRequest, RealSendResponse } from "proto/CommunicationsController.gen";
+    export function send(body: RealSendRequest): Promise<RealSendResponse>;
+
+}

package/types/rpc-modules/DevTools/index.d.ts

@@ -0,0 +1,15 @@
+declare module "~system/DevTools" {
+
+    export interface DevToolsBody {
+        type: string;
+        jsonPayload: string;
+    }
+    export interface EventResponse {
+    }
+
+// ########### BLOCK 
+
+    // importtype { DevToolsBody, EventResponse } from "proto/DevTools.gen";
+    export function event(body: DevToolsBody): Promise<EventResponse>;
+
+}

package/types/rpc-modules/EngineAPI/index.d.ts

@@ -0,0 +1,160 @@
+declare module "~system/EngineAPI" {
+
+    export enum QueryType {
+        InvalidQueryType = 0,
+        HitFirst = 1,
+        HitAll = 2,
+        HitFirstAvatar = 3,
+        HitAllAvatars = 4,
+        UNRECOGNIZED = -1
+    }
+    export enum EAType {
+        InvalidEAType = 0,
+        OpenExternalUrl = 1,
+        OpenNFTDialog = 2,
+        CreateEntity = 3,
+        RemoveEntity = 4,
+        UpdateEntityComponent = 5,
+        AttachEntityComponent = 6,
+        ComponentRemoved = 7,
+        SetEntityParent = 8,
+        Query = 9,
+        ComponentCreated = 10,
+        ComponentDisposed = 11,
+        ComponentUpdated = 12,
+        InitMessagesFinished = 13,
+        UNRECOGNIZED = -1
+    }
+    /** Events */
+    export enum EventDataType {
+        Generic = 0,
+        PositionChanged = 1,
+        RotationChanged = 2,
+        UNRECOGNIZED = -1
+    }
+    export interface OpenExternalUrlBody {
+        url: string;
+    }
+    export interface OpenNFTDialogBody {
+        assetContractAddress: string;
+        tokenId: string;
+        comment?: string | undefined;
+    }
+    export interface CreateEntityBody {
+        id: string;
+    }
+    export interface RemoveEntityBody {
+        id: string;
+    }
+    export interface UpdateEntityComponentBody {
+        entityId: string;
+        classId: number;
+        name: string;
+        json: string;
+    }
+    export interface AttachEntityComponentBody {
+        entityId: string;
+        name: string;
+        id: string;
+    }
+    export interface ComponentRemovedBody {
+        entityId: string;
+        name: string;
+    }
+    export interface SetEntityParentBody {
+        entityId: string;
+        parentId: string;
+    }
+    export interface QueryBody {
+        queryId: QueryType;
+        payload: string;
+    }
+    export interface ComponentCreatedBody {
+        id: string;
+        classId: number;
+        name: string;
+    }
+    export interface ComponentDisposedBody {
+        id: string;
+    }
+    export interface ComponentUpdatedBody {
+        id: string;
+        json: string;
+    }
+    export interface InitMessagesFinishedBody {
+    }
+    export interface Payload {
+        openExternalUrl?: OpenExternalUrlBody | undefined;
+        openNftDialog?: OpenNFTDialogBody | undefined;
+        createEntity?: CreateEntityBody | undefined;
+        removeEntity?: RemoveEntityBody | undefined;
+        updateEntityComponent?: UpdateEntityComponentBody | undefined;
+        attachEntityComponent?: AttachEntityComponentBody | undefined;
+        componentRemoved?: ComponentRemovedBody | undefined;
+        setEntityParent?: SetEntityParentBody | undefined;
+        query?: QueryBody | undefined;
+        componentCreated?: ComponentCreatedBody | undefined;
+        componentDisposed?: ComponentDisposedBody | undefined;
+        componentUpdated?: ComponentUpdatedBody | undefined;
+        initMessagesFinished?: InitMessagesFinishedBody | undefined;
+    }
+    export interface EntityAction {
+        type: EAType;
+        tag?: string | undefined;
+        payload: Payload | undefined;
+    }
+    export interface ManyEntityAction {
+        actions: EntityAction[];
+    }
+    export interface SendBatchResponse {
+        events: EventData[];
+    }
+    export interface UnsubscribeRequest {
+        eventId: string;
+    }
+    export interface SubscribeRequest {
+        eventId: string;
+    }
+    export interface SubscribeResponse {
+    }
+    export interface UnsubscribeResponse {
+    }
+    export interface GenericPayload {
+        eventId: string;
+        eventData: string;
+    }
+    export interface ReadOnlyVector3 {
+        x: number;
+        y: number;
+        z: number;
+    }
+    export interface ReadOnlyQuaternion {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }
+    export interface PositionChangedPayload {
+        position: ReadOnlyVector3 | undefined;
+        cameraPosition: ReadOnlyVector3 | undefined;
+        playerHeight: number;
+    }
+    export interface RotationChangedPayload {
+        rotation: ReadOnlyVector3 | undefined;
+        quaternion: ReadOnlyQuaternion | undefined;
+    }
+    export interface EventData {
+        type: EventDataType;
+        generic?: GenericPayload | undefined;
+        positionChanged?: PositionChangedPayload | undefined;
+        rotationChanged?: RotationChangedPayload | undefined;
+    }
+
+// ########### BLOCK 
+
+    // importtype { ManyEntityAction, SendBatchResponse, SubscribeRequest, SubscribeResponse, UnsubscribeRequest, UnsubscribeResponse } from "proto/EngineAPI.gen";
+    export function sendBatch(body: ManyEntityAction): Promise<SendBatchResponse>;
+    export function subscribe(body: SubscribeRequest): Promise<SubscribeResponse>;
+    export function unsubscribe(body: UnsubscribeRequest): Promise<UnsubscribeResponse>;
+
+}

package/types/rpc-modules/EnvironmentAPI/index.d.ts

@@ -0,0 +1,81 @@
+declare module "~system/EnvironmentAPI" {
+
+    
+    export interface ContentMapping {
+        file: string;
+        hash: string;
+    }
+
+// ########### BLOCK 
+
+    // importtype { ContentMapping } from "proto/common/ContentMapping.gen";
+    export interface MinimalRunnableEntity {
+        content: ContentMapping[];
+        metadataJson: string;
+    }
+    export interface BootstrapDataResponse {
+        id: string;
+        baseUrl: string;
+        entity: MinimalRunnableEntity | undefined;
+        useFPSThrottling: boolean;
+    }
+    export interface PreviewModeResponse {
+        isPreview: boolean;
+    }
+    export interface AreUnsafeRequestAllowedResponse {
+        status: boolean;
+    }
+    export interface GetPlatformResponse {
+        platform: string;
+    }
+    export interface EnvironmentRealm {
+        domain: string;
+        layer: string;
+        room: string;
+        serverName: string;
+        displayName: string;
+        protocol: string;
+    }
+    export interface GetCurrentRealmResponse {
+        currentRealm?: EnvironmentRealm | undefined;
+    }
+    export interface GetExplorerConfigurationResponse {
+        clientUri: string;
+        configurations: {
+            [key: string]: string;
+        };
+    }
+    export interface GetExplorerConfigurationResponse_ConfigurationsEntry {
+        key: string;
+        value: string;
+    }
+    export interface GetDecentralandTimeResponse {
+        seconds: number;
+    }
+    export interface GetBootstrapDataRequest {
+    }
+    export interface IsPreviewModeRequest {
+    }
+    export interface GetPlatformRequest {
+    }
+    export interface AreUnsafeRequestAllowedRequest {
+    }
+    export interface GetCurrentRealmRequest {
+    }
+    export interface GetExplorerConfigurationRequest {
+    }
+    export interface GetDecentralandTimeRequest {
+    }
+
+// ########### BLOCK 
+
+    // importtype { GetBootstrapDataRequest, BootstrapDataResponse, IsPreviewModeRequest, PreviewModeResponse, GetPlatformRequest, GetPlatformResponse, AreUnsafeRequestAllowedRequest, AreUnsafeRequestAllowedResponse, GetCurrentRealmRequest, GetCurrentRealmResponse, GetExplorerConfigurationRequest, GetExplorerConfigurationResponse, GetDecentralandTimeRequest, GetDecentralandTimeResponse } from "proto/EnvironmentAPI.gen";
+    export function getBootstrapData(body: GetBootstrapDataRequest): Promise<BootstrapDataResponse>;
+    export function isPreviewMode(body: IsPreviewModeRequest): Promise<PreviewModeResponse>;
+    export function getPlatform(body: GetPlatformRequest): Promise<GetPlatformResponse>;
+    export function areUnsafeRequestAllowed(body: AreUnsafeRequestAllowedRequest): Promise<AreUnsafeRequestAllowedResponse>;
+    export function getCurrentRealm(body: GetCurrentRealmRequest): Promise<GetCurrentRealmResponse>;
+    export function getExplorerConfiguration(body: GetExplorerConfigurationRequest): Promise<GetExplorerConfigurationResponse>;
+    export function getDecentralandTime(body: GetDecentralandTimeRequest): Promise<GetDecentralandTimeResponse>;
+
+}

package/types/rpc-modules/EthereumController/index.d.ts

@@ -0,0 +1,60 @@
+declare module "~system/EthereumController" {
+
+    export interface RequirePaymentRequest {
+        toAddress: string;
+        amount: number;
+        currency: string;
+    }
+    export interface RequirePaymentResponse {
+        jsonAnyResponse: string;
+    }
+    export interface SignMessageRequest {
+        message: {
+            [key: string]: string;
+        };
+    }
+    export interface SignMessageRequest_MessageEntry {
+        key: string;
+        value: string;
+    }
+    export interface SignMessageResponse {
+        message: string;
+        hexEncodedMessage: string;
+        signature: string;
+    }
+    export interface ConvertMessageToObjectRequest {
+        message: string;
+    }
+    export interface ConvertMessageToObjectResponse {
+        dict: {
+            [key: string]: string;
+        };
+    }
+    export interface ConvertMessageToObjectResponse_DictEntry {
+        key: string;
+        value: string;
+    }
+    export interface SendAsyncRequest {
+        id: number;
+        method: string;
+        jsonParams: string;
+    }
+    export interface SendAsyncResponse {
+        jsonAnyResponse: string;
+    }
+    export interface GetUserAccountRequest {
+    }
+    export interface GetUserAccountResponse {
+        address?: string | undefined;
+    }
+
+// ########### BLOCK 
+
+    // importtype { RequirePaymentRequest, RequirePaymentResponse, SignMessageRequest, SignMessageResponse, ConvertMessageToObjectRequest, ConvertMessageToObjectResponse, SendAsyncRequest, SendAsyncResponse, GetUserAccountRequest, GetUserAccountResponse } from "proto/EthereumController.gen";
+    export function requirePayment(body: RequirePaymentRequest): Promise<RequirePaymentResponse>;
+    export function signMessage(body: SignMessageRequest): Promise<SignMessageResponse>;
+    export function convertMessageToObject(body: ConvertMessageToObjectRequest): Promise<ConvertMessageToObjectResponse>;
+    export function sendAsync(body: SendAsyncRequest): Promise<SendAsyncResponse>;
+    export function getUserAccount(body: GetUserAccountRequest): Promise<GetUserAccountResponse>;
+
+}

package/types/rpc-modules/ExperimentalAPI/index.d.ts

@@ -0,0 +1,20 @@
+declare module "~system/ExperimentalAPI" {
+
+    export interface SendToRendererRequest {
+        data: Uint8Array;
+    }
+    export interface SendToResponse {
+    }
+    export interface MessageFromRendererRequest {
+    }
+    export interface MessageFromRendererResponse {
+        data: Uint8Array[];
+    }
+
+// ########### BLOCK 
+
+    // importtype { SendToRendererRequest, SendToResponse, MessageFromRendererRequest, MessageFromRendererResponse } from "proto/ExperimentalAPI.gen";
+    export function sendToRenderer(body: SendToRendererRequest): Promise<SendToResponse>;
+    export function messageFromRenderer(body: MessageFromRendererRequest): Promise<MessageFromRendererResponse>;
+
+}

package/types/rpc-modules/ParcelIdentity/index.d.ts

@@ -0,0 +1,48 @@
+declare module "~system/ParcelIdentity" {
+
+    
+    export interface ContentMapping {
+        file: string;
+        hash: string;
+    }
+
+// ########### BLOCK 
+
+    // importtype { ContentMapping } from "proto/common/ContentMapping.gen";
+    export interface MappingsResponse {
+        parcelId: string;
+        rootCid: string;
+        contents: ContentMapping[];
+    }
+    export interface Land {
+        sceneId: string;
+        sceneJsonData: string;
+        baseUrl: string;
+        baseUrlBundles: string;
+        mappingsResponse: MappingsResponse | undefined;
+    }
+    export interface GetParcelRequest {
+    }
+    export interface GetParcelResponse {
+        land: Land | undefined;
+        cid: string;
+    }
+    export interface GetSceneIdRequest {
+    }
+    export interface GetSceneIdResponse {
+        sceneId: string;
+    }
+    export interface GetIsEmptyRequest {
+    }
+    export interface GetIsEmptyResponse {
+        isEmpty: boolean;
+    }
+
+// ########### BLOCK 
+
+    // importtype { GetParcelRequest, GetParcelResponse, GetSceneIdRequest, GetSceneIdResponse, GetIsEmptyRequest, GetIsEmptyResponse } from "proto/ParcelIdentity.gen";
+    export function getParcel(body: GetParcelRequest): Promise<GetParcelResponse>;
+    export function getSceneId(body: GetSceneIdRequest): Promise<GetSceneIdResponse>;
+    export function getIsEmpty(body: GetIsEmptyRequest): Promise<GetIsEmptyResponse>;
+
+}

package/types/rpc-modules/Permissions/index.d.ts

@@ -0,0 +1,30 @@
+declare module "~system/Permissions" {
+
+    export enum PermissionItem {
+        ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE = 0,
+        ALLOW_TO_TRIGGER_AVATAR_EMOTE = 1,
+        USE_WEB3_API = 2,
+        USE_WEBSOCKET = 3,
+        USE_FETCH = 4,
+        UNRECOGNIZED = -1
+    }
+    export interface PermissionResponse {
+        hasPermission: boolean;
+    }
+    export interface HasPermissionRequest {
+        permission: PermissionItem;
+    }
+    export interface HasManyPermissionRequest {
+        permissions: PermissionItem[];
+    }
+    export interface HasManyPermissionResponse {
+        hasManyPermission: boolean[];
+    }
+
+// ########### BLOCK 
+
+    // importtype { HasPermissionRequest, PermissionResponse, HasManyPermissionRequest, HasManyPermissionResponse } from "proto/Permissions.gen";
+    export function hasPermission(body: HasPermissionRequest): Promise<PermissionResponse>;
+    export function hasManyPermissions(body: HasManyPermissionRequest): Promise<HasManyPermissionResponse>;
+
+}

package/types/rpc-modules/Players/index.d.ts

@@ -0,0 +1,52 @@
+declare module "~system/Players" {
+
+    
+    export interface Snapshots {
+        face256: string;
+        body: string;
+    }
+    export interface AvatarForUserData {
+        bodyShape: string;
+        skinColor: string;
+        hairColor: string;
+        eyeColor: string;
+        wearables: string[];
+        snapshots: Snapshots | undefined;
+    }
+    export interface UserData {
+        displayName: string;
+        publicKey?: string | undefined;
+        hasConnectedWeb3: boolean;
+        userId: string;
+        version: number;
+        avatar: AvatarForUserData | undefined;
+    }
+
+// ########### BLOCK 
+
+    // importtype { UserData } from "proto/common/UserData.gen";
+    export interface Player {
+        userId: string;
+    }
+    export interface PlayersGetUserDataResponse {
+        data?: UserData | undefined;
+    }
+    export interface PlayerListResponse {
+        players: Player[];
+    }
+    export interface GetPlayerDataRequest {
+        userId: string;
+    }
+    export interface GetPlayersInSceneRequest {
+    }
+    export interface GetConnectedPlayersRequest {
+    }
+
+// ########### BLOCK 
+
+    // importtype { GetPlayerDataRequest, PlayersGetUserDataResponse, GetPlayersInSceneRequest, PlayerListResponse, GetConnectedPlayersRequest } from "proto/Players.gen";
+    export function getPlayerData(body: GetPlayerDataRequest): Promise<PlayersGetUserDataResponse>;
+    export function getPlayersInScene(body: GetPlayersInSceneRequest): Promise<PlayerListResponse>;
+    export function getConnectedPlayers(body: GetConnectedPlayersRequest): Promise<PlayerListResponse>;
+
+}

package/types/rpc-modules/PortableExperiences/index.d.ts

@@ -0,0 +1,38 @@
+declare module "~system/PortableExperiences" {
+
+    export interface KillRequest {
+        pid: string;
+    }
+    export interface KillResponse {
+        status: boolean;
+    }
+    export interface SpawnRequest {
+        pid: string;
+    }
+    export interface SpawnResponse {
+        pid: string;
+        parentCid: string;
+    }
+    export interface PxRequest {
+        pid: string;
+    }
+    export interface GetPortableExperiencesLoadedRequest {
+    }
+    export interface GetPortableExperiencesLoadedResponse {
+        loaded: SpawnResponse[];
+    }
+    export interface ExitRequest {
+    }
+    export interface ExitResponse {
+        status: boolean;
+    }
+
+// ########### BLOCK 
+
+    // importtype { SpawnRequest, SpawnResponse, KillRequest, KillResponse, ExitRequest, ExitResponse, GetPortableExperiencesLoadedRequest, GetPortableExperiencesLoadedResponse } from "proto/PortableExperiences.gen";
+    export function spawn(body: SpawnRequest): Promise<SpawnResponse>;
+    export function kill(body: KillRequest): Promise<KillResponse>;
+    export function exit(body: ExitRequest): Promise<ExitResponse>;
+    export function getPortableExperiencesLoaded(body: GetPortableExperiencesLoadedRequest): Promise<GetPortableExperiencesLoadedResponse>;
+
+}

package/types/rpc-modules/RestrictedActions/index.d.ts

@@ -0,0 +1,26 @@
+declare module "~system/RestrictedActions" {
+
+    export interface Vector3 {
+        x: number;
+        y: number;
+        z: number;
+    }
+    export interface MovePlayerToResponse {
+    }
+    export interface MovePlayerToRequest {
+        newRelativePosition: Vector3 | undefined;
+        cameraTarget?: Vector3 | undefined;
+    }
+    export interface TriggerEmoteResponse {
+    }
+    export interface TriggerEmoteRequest {
+        predefinedEmote: string;
+    }
+
+// ########### BLOCK 
+
+    // importtype { MovePlayerToRequest, MovePlayerToResponse, TriggerEmoteRequest, TriggerEmoteResponse } from "proto/RestrictedActions.gen";
+    export function movePlayerTo(body: MovePlayerToRequest): Promise<MovePlayerToResponse>;
+    export function triggerEmote(body: TriggerEmoteRequest): Promise<TriggerEmoteResponse>;
+
+}

package/types/rpc-modules/SceneStateStorageController/index.d.ts

@@ -0,0 +1,90 @@
+declare module "~system/SceneStateStorageController" {
+
+    export interface SerializedSceneState {
+        entities: SerializedEntity[];
+    }
+    export interface SerializedComponent {
+        type: number;
+        valueJson: string;
+    }
+    export interface SerializedEntity {
+        id: string;
+        components: SerializedComponent[];
+    }
+    export interface GetProjectManifestRequest {
+        projectId: string;
+    }
+    export interface GetProjectManifestResponse {
+        state?: SerializedSceneState | undefined;
+    }
+    export interface GetProjectManifestByCoordinatesRequest {
+        land: string;
+    }
+    export interface GetProjectManifestByCoordinatesResponse {
+        state?: SerializedSceneState | undefined;
+    }
+    export interface CreateProjectWithCoordsRequest {
+        coordinates: string;
+    }
+    export interface CreateProjectWithCoordsResponse {
+        ok: boolean;
+    }
+    export interface SaveSceneStateRequest {
+        serializedSceneState: SerializedSceneState | undefined;
+    }
+    export interface SaveSceneStateResponse {
+        ok: boolean;
+        error?: string | undefined;
+    }
+    export interface SaveProjectInfoRequest {
+        sceneState: SerializedSceneState | undefined;
+        projectName: string;
+        projectDescription: string;
+        projectScreenshot: string;
+    }
+    export interface SaveProjectInfoResponse {
+        ok: boolean;
+    }
+    export interface PublishSceneStateRequest {
+        sceneId: string;
+        sceneName: string;
+        sceneDescription: string;
+        sceneScreenshot: string;
+        sceneState: SerializedSceneState | undefined;
+    }
+    export interface PublishSceneStateResponse {
+        ok: boolean;
+        error?: string | undefined;
+    }
+    export interface GetStoredStateRequest {
+        sceneId: string;
+    }
+    export interface GetStoredStateResponse {
+        state?: SerializedSceneState | undefined;
+    }
+    export interface CreateProjectFromStateDefinitionRequest {
+    }
+    export interface CreateProjectFromStateDefinitionResponse {
+        state?: SerializedSceneState | undefined;
+    }
+    export interface SendAssetsToRendererRequest {
+        state: SerializedSceneState | undefined;
+    }
+    export interface SendAssetsToRendererResponse {
+        state: string;
+    }
+
+// ########### BLOCK 
+
+    // importtype { GetProjectManifestRequest, GetProjectManifestResponse, GetProjectManifestByCoordinatesRequest, GetProjectManifestByCoordinatesResponse, CreateProjectWithCoordsRequest, CreateProjectWithCoordsResponse, SaveSceneStateRequest, SaveSceneStateResponse, SaveProjectInfoRequest, SaveProjectInfoResponse, PublishSceneStateRequest, PublishSceneStateResponse, GetStoredStateRequest, GetStoredStateResponse, CreateProjectFromStateDefinitionRequest, CreateProjectFromStateDefinitionResponse, SendAssetsToRendererRequest, SendAssetsToRendererResponse } from "proto/SceneStateStorageController.gen";
+    export function getProjectManifest(body: GetProjectManifestRequest): Promise<GetProjectManifestResponse>;
+    export function getProjectManifestByCoordinates(body: GetProjectManifestByCoordinatesRequest): Promise<GetProjectManifestByCoordinatesResponse>;
+    export function createProjectWithCoords(body: CreateProjectWithCoordsRequest): Promise<CreateProjectWithCoordsResponse>;
+    export function saveSceneState(body: SaveSceneStateRequest): Promise<SaveSceneStateResponse>;
+    export function saveProjectInfo(body: SaveProjectInfoRequest): Promise<SaveProjectInfoResponse>;
+    export function publishSceneState(body: PublishSceneStateRequest): Promise<PublishSceneStateResponse>;
+    export function getStoredState(body: GetStoredStateRequest): Promise<GetStoredStateResponse>;
+    export function createProjectFromStateDefinition(body: CreateProjectFromStateDefinitionRequest): Promise<CreateProjectFromStateDefinitionResponse>;
+    export function sendAssetsToRenderer(body: SendAssetsToRendererRequest): Promise<SendAssetsToRendererResponse>;
+
+}