/*!
 * Copyright (c) 2026 Vertex Software LLC. All rights reserved.
 */
'use strict';

var wrappers_pb = require('./wrappers_pb-Dupo3Hcb.js');
var wrappers_pb$1 = require('./wrappers_pb-DCb8h8QZ.js');

var scene_view_api_pb_service = {};

var hasRequiredScene_view_api_pb_service;

function requireScene_view_api_pb_service () {
	if (hasRequiredScene_view_api_pb_service) return scene_view_api_pb_service;
	hasRequiredScene_view_api_pb_service = 1;
	// package: vertexvis.protobuf.sceneview.v1
	// file: sceneview/protos/scene_view_api.proto

	var sceneview_protos_scene_view_api_pb = wrappers_pb.requireScene_view_api_pb();
	var grpc = wrappers_pb$1.requireGrpcWebClient_umd().grpc;

	var SceneViewAPI = (function () {
	  function SceneViewAPI() {}
	  SceneViewAPI.serviceName = "vertexvis.protobuf.sceneview.v1.SceneViewAPI";
	  return SceneViewAPI;
	}());

	SceneViewAPI.GetSceneViewItem = {
	  methodName: "GetSceneViewItem",
	  service: SceneViewAPI,
	  requestStream: false,
	  responseStream: false,
	  requestType: sceneview_protos_scene_view_api_pb.GetSceneViewItemRequest,
	  responseType: sceneview_protos_scene_view_api_pb.GetSceneViewItemResponse
	};

	SceneViewAPI.CreateSceneViewAnnotationSet = {
	  methodName: "CreateSceneViewAnnotationSet",
	  service: SceneViewAPI,
	  requestStream: false,
	  responseStream: false,
	  requestType: sceneview_protos_scene_view_api_pb.CreateSceneViewAnnotationSetRequest,
	  responseType: sceneview_protos_scene_view_api_pb.CreateSceneViewAnnotationSetResponse
	};

	SceneViewAPI.DeleteSceneViewAnnotationSet = {
	  methodName: "DeleteSceneViewAnnotationSet",
	  service: SceneViewAPI,
	  requestStream: false,
	  responseStream: false,
	  requestType: sceneview_protos_scene_view_api_pb.DeleteSceneViewAnnotationSetRequest,
	  responseType: sceneview_protos_scene_view_api_pb.DeleteSceneViewAnnotationSetResponse
	};

	SceneViewAPI.ListItemRepresentations = {
	  methodName: "ListItemRepresentations",
	  service: SceneViewAPI,
	  requestStream: false,
	  responseStream: false,
	  requestType: sceneview_protos_scene_view_api_pb.ListItemRepresentationsRequest,
	  responseType: sceneview_protos_scene_view_api_pb.ListItemRepresentationsResponse
	};

	SceneViewAPI.ListItemModelViews = {
	  methodName: "ListItemModelViews",
	  service: SceneViewAPI,
	  requestStream: false,
	  responseStream: false,
	  requestType: sceneview_protos_scene_view_api_pb.ListItemModelViewsRequest,
	  responseType: sceneview_protos_scene_view_api_pb.ListItemModelViewsResponse
	};

	SceneViewAPI.ListPmiAnnotations = {
	  methodName: "ListPmiAnnotations",
	  service: SceneViewAPI,
	  requestStream: false,
	  responseStream: false,
	  requestType: sceneview_protos_scene_view_api_pb.ListPmiAnnotationsRequest,
	  responseType: sceneview_protos_scene_view_api_pb.ListPmiAnnotationsResponse
	};

	SceneViewAPI.ListSceneViewAnnotationSets = {
	  methodName: "ListSceneViewAnnotationSets",
	  service: SceneViewAPI,
	  requestStream: false,
	  responseStream: false,
	  requestType: sceneview_protos_scene_view_api_pb.ListSceneViewAnnotationSetsRequest,
	  responseType: sceneview_protos_scene_view_api_pb.ListSceneViewAnnotationSetsResponse
	};

	SceneViewAPI.ListSceneAnnotations = {
	  methodName: "ListSceneAnnotations",
	  service: SceneViewAPI,
	  requestStream: false,
	  responseStream: false,
	  requestType: sceneview_protos_scene_view_api_pb.ListSceneAnnotationsRequest,
	  responseType: sceneview_protos_scene_view_api_pb.ListSceneAnnotationsResponse
	};

	SceneViewAPI.UpdateModelEntities = {
	  methodName: "UpdateModelEntities",
	  service: SceneViewAPI,
	  requestStream: false,
	  responseStream: false,
	  requestType: sceneview_protos_scene_view_api_pb.UpdateModelEntitiesRequest,
	  responseType: sceneview_protos_scene_view_api_pb.UpdateModelEntitiesResponse
	};

	SceneViewAPI.Measure = {
	  methodName: "Measure",
	  service: SceneViewAPI,
	  requestStream: false,
	  responseStream: false,
	  requestType: sceneview_protos_scene_view_api_pb.MeasureRequest,
	  responseType: sceneview_protos_scene_view_api_pb.MeasureResponse
	};

	SceneViewAPI.ListSceneItemMetadata = {
	  methodName: "ListSceneItemMetadata",
	  service: SceneViewAPI,
	  requestStream: false,
	  responseStream: false,
	  requestType: sceneview_protos_scene_view_api_pb.ListSceneItemMetadataRequest,
	  responseType: sceneview_protos_scene_view_api_pb.ListSceneItemMetadataResponse
	};

	SceneViewAPI.GetCanvas = {
	  methodName: "GetCanvas",
	  service: SceneViewAPI,
	  requestStream: false,
	  responseStream: false,
	  requestType: sceneview_protos_scene_view_api_pb.GetCanvasRequest,
	  responseType: sceneview_protos_scene_view_api_pb.GetCanvasResponse
	};

	scene_view_api_pb_service.SceneViewAPI = SceneViewAPI;

	function SceneViewAPIClient(serviceHost, options) {
	  this.serviceHost = serviceHost;
	  this.options = options || {};
	}

	SceneViewAPIClient.prototype.getSceneViewItem = function getSceneViewItem(requestMessage, metadata, callback) {
	  if (arguments.length === 2) {
	    callback = arguments[1];
	  }
	  var client = grpc.unary(SceneViewAPI.GetSceneViewItem, {
	    request: requestMessage,
	    host: this.serviceHost,
	    metadata: metadata,
	    transport: this.options.transport,
	    debug: this.options.debug,
	    onEnd: function (response) {
	      if (callback) {
	        if (response.status !== grpc.Code.OK) {
	          var err = new Error(response.statusMessage);
	          err.code = response.status;
	          err.metadata = response.trailers;
	          callback(err, null);
	        } else {
	          callback(null, response.message);
	        }
	      }
	    }
	  });
	  return {
	    cancel: function () {
	      callback = null;
	      client.close();
	    }
	  };
	};

	SceneViewAPIClient.prototype.createSceneViewAnnotationSet = function createSceneViewAnnotationSet(requestMessage, metadata, callback) {
	  if (arguments.length === 2) {
	    callback = arguments[1];
	  }
	  var client = grpc.unary(SceneViewAPI.CreateSceneViewAnnotationSet, {
	    request: requestMessage,
	    host: this.serviceHost,
	    metadata: metadata,
	    transport: this.options.transport,
	    debug: this.options.debug,
	    onEnd: function (response) {
	      if (callback) {
	        if (response.status !== grpc.Code.OK) {
	          var err = new Error(response.statusMessage);
	          err.code = response.status;
	          err.metadata = response.trailers;
	          callback(err, null);
	        } else {
	          callback(null, response.message);
	        }
	      }
	    }
	  });
	  return {
	    cancel: function () {
	      callback = null;
	      client.close();
	    }
	  };
	};

	SceneViewAPIClient.prototype.deleteSceneViewAnnotationSet = function deleteSceneViewAnnotationSet(requestMessage, metadata, callback) {
	  if (arguments.length === 2) {
	    callback = arguments[1];
	  }
	  var client = grpc.unary(SceneViewAPI.DeleteSceneViewAnnotationSet, {
	    request: requestMessage,
	    host: this.serviceHost,
	    metadata: metadata,
	    transport: this.options.transport,
	    debug: this.options.debug,
	    onEnd: function (response) {
	      if (callback) {
	        if (response.status !== grpc.Code.OK) {
	          var err = new Error(response.statusMessage);
	          err.code = response.status;
	          err.metadata = response.trailers;
	          callback(err, null);
	        } else {
	          callback(null, response.message);
	        }
	      }
	    }
	  });
	  return {
	    cancel: function () {
	      callback = null;
	      client.close();
	    }
	  };
	};

	SceneViewAPIClient.prototype.listItemRepresentations = function listItemRepresentations(requestMessage, metadata, callback) {
	  if (arguments.length === 2) {
	    callback = arguments[1];
	  }
	  var client = grpc.unary(SceneViewAPI.ListItemRepresentations, {
	    request: requestMessage,
	    host: this.serviceHost,
	    metadata: metadata,
	    transport: this.options.transport,
	    debug: this.options.debug,
	    onEnd: function (response) {
	      if (callback) {
	        if (response.status !== grpc.Code.OK) {
	          var err = new Error(response.statusMessage);
	          err.code = response.status;
	          err.metadata = response.trailers;
	          callback(err, null);
	        } else {
	          callback(null, response.message);
	        }
	      }
	    }
	  });
	  return {
	    cancel: function () {
	      callback = null;
	      client.close();
	    }
	  };
	};

	SceneViewAPIClient.prototype.listItemModelViews = function listItemModelViews(requestMessage, metadata, callback) {
	  if (arguments.length === 2) {
	    callback = arguments[1];
	  }
	  var client = grpc.unary(SceneViewAPI.ListItemModelViews, {
	    request: requestMessage,
	    host: this.serviceHost,
	    metadata: metadata,
	    transport: this.options.transport,
	    debug: this.options.debug,
	    onEnd: function (response) {
	      if (callback) {
	        if (response.status !== grpc.Code.OK) {
	          var err = new Error(response.statusMessage);
	          err.code = response.status;
	          err.metadata = response.trailers;
	          callback(err, null);
	        } else {
	          callback(null, response.message);
	        }
	      }
	    }
	  });
	  return {
	    cancel: function () {
	      callback = null;
	      client.close();
	    }
	  };
	};

	SceneViewAPIClient.prototype.listPmiAnnotations = function listPmiAnnotations(requestMessage, metadata, callback) {
	  if (arguments.length === 2) {
	    callback = arguments[1];
	  }
	  var client = grpc.unary(SceneViewAPI.ListPmiAnnotations, {
	    request: requestMessage,
	    host: this.serviceHost,
	    metadata: metadata,
	    transport: this.options.transport,
	    debug: this.options.debug,
	    onEnd: function (response) {
	      if (callback) {
	        if (response.status !== grpc.Code.OK) {
	          var err = new Error(response.statusMessage);
	          err.code = response.status;
	          err.metadata = response.trailers;
	          callback(err, null);
	        } else {
	          callback(null, response.message);
	        }
	      }
	    }
	  });
	  return {
	    cancel: function () {
	      callback = null;
	      client.close();
	    }
	  };
	};

	SceneViewAPIClient.prototype.listSceneViewAnnotationSets = function listSceneViewAnnotationSets(requestMessage, metadata, callback) {
	  if (arguments.length === 2) {
	    callback = arguments[1];
	  }
	  var client = grpc.unary(SceneViewAPI.ListSceneViewAnnotationSets, {
	    request: requestMessage,
	    host: this.serviceHost,
	    metadata: metadata,
	    transport: this.options.transport,
	    debug: this.options.debug,
	    onEnd: function (response) {
	      if (callback) {
	        if (response.status !== grpc.Code.OK) {
	          var err = new Error(response.statusMessage);
	          err.code = response.status;
	          err.metadata = response.trailers;
	          callback(err, null);
	        } else {
	          callback(null, response.message);
	        }
	      }
	    }
	  });
	  return {
	    cancel: function () {
	      callback = null;
	      client.close();
	    }
	  };
	};

	SceneViewAPIClient.prototype.listSceneAnnotations = function listSceneAnnotations(requestMessage, metadata, callback) {
	  if (arguments.length === 2) {
	    callback = arguments[1];
	  }
	  var client = grpc.unary(SceneViewAPI.ListSceneAnnotations, {
	    request: requestMessage,
	    host: this.serviceHost,
	    metadata: metadata,
	    transport: this.options.transport,
	    debug: this.options.debug,
	    onEnd: function (response) {
	      if (callback) {
	        if (response.status !== grpc.Code.OK) {
	          var err = new Error(response.statusMessage);
	          err.code = response.status;
	          err.metadata = response.trailers;
	          callback(err, null);
	        } else {
	          callback(null, response.message);
	        }
	      }
	    }
	  });
	  return {
	    cancel: function () {
	      callback = null;
	      client.close();
	    }
	  };
	};

	SceneViewAPIClient.prototype.updateModelEntities = function updateModelEntities(requestMessage, metadata, callback) {
	  if (arguments.length === 2) {
	    callback = arguments[1];
	  }
	  var client = grpc.unary(SceneViewAPI.UpdateModelEntities, {
	    request: requestMessage,
	    host: this.serviceHost,
	    metadata: metadata,
	    transport: this.options.transport,
	    debug: this.options.debug,
	    onEnd: function (response) {
	      if (callback) {
	        if (response.status !== grpc.Code.OK) {
	          var err = new Error(response.statusMessage);
	          err.code = response.status;
	          err.metadata = response.trailers;
	          callback(err, null);
	        } else {
	          callback(null, response.message);
	        }
	      }
	    }
	  });
	  return {
	    cancel: function () {
	      callback = null;
	      client.close();
	    }
	  };
	};

	SceneViewAPIClient.prototype.measure = function measure(requestMessage, metadata, callback) {
	  if (arguments.length === 2) {
	    callback = arguments[1];
	  }
	  var client = grpc.unary(SceneViewAPI.Measure, {
	    request: requestMessage,
	    host: this.serviceHost,
	    metadata: metadata,
	    transport: this.options.transport,
	    debug: this.options.debug,
	    onEnd: function (response) {
	      if (callback) {
	        if (response.status !== grpc.Code.OK) {
	          var err = new Error(response.statusMessage);
	          err.code = response.status;
	          err.metadata = response.trailers;
	          callback(err, null);
	        } else {
	          callback(null, response.message);
	        }
	      }
	    }
	  });
	  return {
	    cancel: function () {
	      callback = null;
	      client.close();
	    }
	  };
	};

	SceneViewAPIClient.prototype.listSceneItemMetadata = function listSceneItemMetadata(requestMessage, metadata, callback) {
	  if (arguments.length === 2) {
	    callback = arguments[1];
	  }
	  var client = grpc.unary(SceneViewAPI.ListSceneItemMetadata, {
	    request: requestMessage,
	    host: this.serviceHost,
	    metadata: metadata,
	    transport: this.options.transport,
	    debug: this.options.debug,
	    onEnd: function (response) {
	      if (callback) {
	        if (response.status !== grpc.Code.OK) {
	          var err = new Error(response.statusMessage);
	          err.code = response.status;
	          err.metadata = response.trailers;
	          callback(err, null);
	        } else {
	          callback(null, response.message);
	        }
	      }
	    }
	  });
	  return {
	    cancel: function () {
	      callback = null;
	      client.close();
	    }
	  };
	};

	SceneViewAPIClient.prototype.getCanvas = function getCanvas(requestMessage, metadata, callback) {
	  if (arguments.length === 2) {
	    callback = arguments[1];
	  }
	  var client = grpc.unary(SceneViewAPI.GetCanvas, {
	    request: requestMessage,
	    host: this.serviceHost,
	    metadata: metadata,
	    transport: this.options.transport,
	    debug: this.options.debug,
	    onEnd: function (response) {
	      if (callback) {
	        if (response.status !== grpc.Code.OK) {
	          var err = new Error(response.statusMessage);
	          err.code = response.status;
	          err.metadata = response.trailers;
	          callback(err, null);
	        } else {
	          callback(null, response.message);
	        }
	      }
	    }
	  });
	  return {
	    cancel: function () {
	      callback = null;
	      client.close();
	    }
	  };
	};

	scene_view_api_pb_service.SceneViewAPIClient = SceneViewAPIClient;
	return scene_view_api_pb_service;
}

var scene_view_api_pb_serviceExports = requireScene_view_api_pb_service();

exports.scene_view_api_pb_serviceExports = scene_view_api_pb_serviceExports;
//# sourceMappingURL=scene_view_api_pb_service-DYpTDhrh.js.map

//# sourceMappingURL=scene_view_api_pb_service-DYpTDhrh.js.map