"""
    REST API

    Rockset's REST API allows for creating and managing all resources in Rockset. Each supported endpoint is documented below.  All requests must be authorized with a Rockset API key, which can be created in the [Rockset console](https://console.rockset.com). The API key must be provided as `ApiKey <api_key>` in the `Authorization` request header. For example: ``` Authorization: ApiKey aB35kDjg93J5nsf4GjwMeErAVd832F7ad4vhsW1S02kfZiab42sTsfW5Sxt25asT ```  All endpoints are only accessible via https.  Build something awesome!  # noqa: E501

    The version of the OpenAPI document: v1
    Generated by: https://openapi-generator.tech
"""


import re  # noqa: F401
import sys  # noqa: F401
import typing  # noqa: F401

import asyncio

from rockset.api_client import ApiClient, Endpoint as _Endpoint
from rockset.model_utils import (  # noqa: F401
    check_allowed_values,
    check_validations,
    date,
    datetime,
    file_type,
    none_type,
    validate_and_convert_types
)
from rockset.model.collection_mount_response import CollectionMountResponse
from rockset.model.create_collection_mount_request import CreateCollectionMountRequest
from rockset.model.create_collection_mounts_response import CreateCollectionMountsResponse
from rockset.model.create_virtual_instance_request import CreateVirtualInstanceRequest
from rockset.model.create_virtual_instance_response import CreateVirtualInstanceResponse
from rockset.model.delete_virtual_instance_response import DeleteVirtualInstanceResponse
from rockset.model.error_model import ErrorModel
from rockset.model.get_collection_commit import GetCollectionCommit
from rockset.model.get_collection_commit_request import GetCollectionCommitRequest
from rockset.model.get_virtual_instance_response import GetVirtualInstanceResponse
from rockset.model.list_collection_mounts_response import ListCollectionMountsResponse
from rockset.model.list_queries_response import ListQueriesResponse
from rockset.model.list_virtual_instances_response import ListVirtualInstancesResponse
from rockset.model.query_request import QueryRequest
from rockset.model.query_response import QueryResponse
from rockset.model.resume_virtual_instance_response import ResumeVirtualInstanceResponse
from rockset.model.suspend_virtual_instance_response import SuspendVirtualInstanceResponse
from rockset.model.update_virtual_instance_request import UpdateVirtualInstanceRequest
from rockset.model.update_virtual_instance_response import UpdateVirtualInstanceResponse
from rockset.models import *


class VirtualInstances(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client
        self.create_endpoint = _Endpoint(
            settings={
                'response_type': (CreateVirtualInstanceResponse,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances',
                'operation_id': 'create',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'create_virtual_instance_request',
                ],
                'required': [
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'create_virtual_instance_request':
                        (CreateVirtualInstanceRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'create_virtual_instance_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.delete_endpoint = _Endpoint(
            settings={
                'response_type': (DeleteVirtualInstanceResponse,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances/{virtualInstanceId}',
                'operation_id': 'delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'virtual_instance_id',
                ],
                'required': [
                    'virtual_instance_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'virtual_instance_id':
                        (str,),
                },
                'attribute_map': {
                    'virtual_instance_id': 'virtualInstanceId',
                },
                'location_map': {
                    'virtual_instance_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_endpoint = _Endpoint(
            settings={
                'response_type': (GetVirtualInstanceResponse,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances/{virtualInstanceId}',
                'operation_id': 'get',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'virtual_instance_id',
                ],
                'required': [
                    'virtual_instance_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'virtual_instance_id':
                        (str,),
                },
                'attribute_map': {
                    'virtual_instance_id': 'virtualInstanceId',
                },
                'location_map': {
                    'virtual_instance_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_collection_mount_endpoint = _Endpoint(
            settings={
                'response_type': (CollectionMountResponse,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances/{virtualInstanceId}/mounts/{collectionPath}',
                'operation_id': 'get_collection_mount',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'virtual_instance_id',
                    'collection_path',
                ],
                'required': [
                    'virtual_instance_id',
                    'collection_path',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'virtual_instance_id':
                        (str,),
                    'collection_path':
                        (str,),
                },
                'attribute_map': {
                    'virtual_instance_id': 'virtualInstanceId',
                    'collection_path': 'collectionPath',
                },
                'location_map': {
                    'virtual_instance_id': 'path',
                    'collection_path': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_mount_offsets_endpoint = _Endpoint(
            settings={
                'response_type': (GetCollectionCommit,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances/{virtualInstanceId}/mounts/{collectionPath}/offsets/commit',
                'operation_id': 'get_mount_offsets',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'virtual_instance_id',
                    'collection_path',
                    'get_collection_commit_request',
                ],
                'required': [
                    'virtual_instance_id',
                    'collection_path',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'virtual_instance_id':
                        (str,),
                    'collection_path':
                        (str,),
                    'get_collection_commit_request':
                        (GetCollectionCommitRequest,),
                },
                'attribute_map': {
                    'virtual_instance_id': 'virtualInstanceId',
                    'collection_path': 'collectionPath',
                },
                'location_map': {
                    'virtual_instance_id': 'path',
                    'collection_path': 'path',
                    'get_collection_commit_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.get_virtual_instance_queries_endpoint = _Endpoint(
            settings={
                'response_type': (ListQueriesResponse,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances/{virtualInstanceId}/queries',
                'operation_id': 'get_virtual_instance_queries',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'virtual_instance_id',
                ],
                'required': [
                    'virtual_instance_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'virtual_instance_id':
                        (str,),
                },
                'attribute_map': {
                    'virtual_instance_id': 'virtualInstanceId',
                },
                'location_map': {
                    'virtual_instance_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_endpoint = _Endpoint(
            settings={
                'response_type': (ListVirtualInstancesResponse,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances',
                'operation_id': 'list',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_collection_mounts_endpoint = _Endpoint(
            settings={
                'response_type': (ListCollectionMountsResponse,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances/{virtualInstanceId}/mounts',
                'operation_id': 'list_collection_mounts',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'virtual_instance_id',
                ],
                'required': [
                    'virtual_instance_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'virtual_instance_id':
                        (str,),
                },
                'attribute_map': {
                    'virtual_instance_id': 'virtualInstanceId',
                },
                'location_map': {
                    'virtual_instance_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.mount_collection_endpoint = _Endpoint(
            settings={
                'response_type': (CreateCollectionMountsResponse,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances/{virtualInstanceId}/mounts',
                'operation_id': 'mount_collection',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'virtual_instance_id',
                    'create_collection_mount_request',
                ],
                'required': [
                    'virtual_instance_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'virtual_instance_id':
                        (str,),
                    'create_collection_mount_request':
                        (CreateCollectionMountRequest,),
                },
                'attribute_map': {
                    'virtual_instance_id': 'virtualInstanceId',
                },
                'location_map': {
                    'virtual_instance_id': 'path',
                    'create_collection_mount_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.query_virtual_instance_endpoint = _Endpoint(
            settings={
                'response_type': (QueryResponse,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances/{virtualInstanceId}/queries',
                'operation_id': 'query_virtual_instance',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'virtual_instance_id',
                    'query_request',
                ],
                'required': [
                    'virtual_instance_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'virtual_instance_id':
                        (str,),
                    'query_request':
                        (QueryRequest,),
                },
                'attribute_map': {
                    'virtual_instance_id': 'virtualInstanceId',
                },
                'location_map': {
                    'virtual_instance_id': 'path',
                    'query_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.resume_virtual_instance_endpoint = _Endpoint(
            settings={
                'response_type': (ResumeVirtualInstanceResponse,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances/{virtualInstanceId}/resume',
                'operation_id': 'resume_virtual_instance',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'virtual_instance_id',
                ],
                'required': [
                    'virtual_instance_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'virtual_instance_id':
                        (str,),
                },
                'attribute_map': {
                    'virtual_instance_id': 'virtualInstanceId',
                },
                'location_map': {
                    'virtual_instance_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.suspend_virtual_instance_endpoint = _Endpoint(
            settings={
                'response_type': (SuspendVirtualInstanceResponse,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances/{virtualInstanceId}/suspend',
                'operation_id': 'suspend_virtual_instance',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'virtual_instance_id',
                ],
                'required': [
                    'virtual_instance_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'virtual_instance_id':
                        (str,),
                },
                'attribute_map': {
                    'virtual_instance_id': 'virtualInstanceId',
                },
                'location_map': {
                    'virtual_instance_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.unmount_collection_endpoint = _Endpoint(
            settings={
                'response_type': (CollectionMountResponse,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances/{virtualInstanceId}/mounts/{collectionPath}',
                'operation_id': 'unmount_collection',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'virtual_instance_id',
                    'collection_path',
                ],
                'required': [
                    'virtual_instance_id',
                    'collection_path',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'virtual_instance_id':
                        (str,),
                    'collection_path':
                        (str,),
                },
                'attribute_map': {
                    'virtual_instance_id': 'virtualInstanceId',
                    'collection_path': 'collectionPath',
                },
                'location_map': {
                    'virtual_instance_id': 'path',
                    'collection_path': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.update_endpoint = _Endpoint(
            settings={
                'response_type': (UpdateVirtualInstanceResponse,),
                'auth': [
                    'apikey'
                ],
                'endpoint_path': '/v1/orgs/self/virtualinstances/{virtualInstanceId}',
                'operation_id': 'update',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'virtual_instance_id',
                    'update_virtual_instance_request',
                ],
                'required': [
                    'virtual_instance_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'virtual_instance_id':
                        (str,),
                    'update_virtual_instance_request':
                        (UpdateVirtualInstanceRequest,),
                },
                'attribute_map': {
                    'virtual_instance_id': 'virtualInstanceId',
                },
                'location_map': {
                    'virtual_instance_id': 'path',
                    'update_virtual_instance_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )

    def create(
        self,
        *,
        name: str,
        auto_suspend_seconds: int = None,
        description: str = None,
        enable_remount_on_resume: bool = None,
        mount_refresh_interval_seconds: int = None,
        mount_type: str = None,
        type: str = None,
        **kwargs
    ) -> typing.Union[CreateVirtualInstanceResponse, asyncio.Future]:
        """Create Virtual Instance  # noqa: E501

        Create virtual instance  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.create(
            auto_suspend_seconds=3600,
            description="VI serving prod traffic",
            enable_remount_on_resume=True,
            mount_refresh_interval_seconds=0,
            mount_type="LIVE",
            name="prod_vi",
            type="LARGE",
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            auto_suspend_seconds (int): Number of seconds without queries after which the VI is suspended. [optional]
            description (str): Description of requested virtual instance.. [optional]
            enable_remount_on_resume (bool): When a Virtual Instance is resumed, it will remount all collections that were mounted when the Virtual Instance was suspended.. [optional]
            mount_refresh_interval_seconds (int): DEPRECATED. Use `mount_type` instead. Number of seconds between data refreshes for mounts on this Virtual Instance. The only valid values are 0 and null. 0 means the data will be refreshed continuously and null means the data will never refresh.. [optional]
            mount_type (str): The mount type of collections that this Virtual Instance will query. Live mounted collections stay up-to-date with the underlying collection in real-time. Static mounted collections do not stay up-to-date. See https://docs.rockset.com/documentation/docs/virtual-instances#virtual-instance-configuration. [optional]
            name (str): Unique identifier for virtual instance, can contain alphanumeric or dash characters.. [required]
            type (str): Requested virtual instance type.. [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            CreateVirtualInstanceResponse
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['create_virtual_instance_request'] = \
            kwargs['create_virtual_instance_request']
        return self.create_endpoint.call_with_http_info(**kwargs)

    def delete(
        self,
        *,
        virtual_instance_id: str,
        **kwargs
    ) -> typing.Union[DeleteVirtualInstanceResponse, asyncio.Future]:
        """Delete Virtual Instance  # noqa: E501

        Delete a virtual instance.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.delete(
            virtual_instance_id="virtualInstanceId_example",
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            virtual_instance_id (str): Virtual Instance RRN. [required]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            DeleteVirtualInstanceResponse
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['virtual_instance_id'] = \
            virtual_instance_id
        return self.delete_endpoint.call_with_http_info(**kwargs)

    def get(
        self,
        *,
        virtual_instance_id: str,
        **kwargs
    ) -> typing.Union[GetVirtualInstanceResponse, asyncio.Future]:
        """Retrieve Virtual Instance  # noqa: E501

        Get details about a virtual instance.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.get(
            virtual_instance_id="virtualInstanceId_example",
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            virtual_instance_id (str): Virtual Instance RRN. [required]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            GetVirtualInstanceResponse
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['virtual_instance_id'] = \
            virtual_instance_id
        return self.get_endpoint.call_with_http_info(**kwargs)

    def get_collection_mount(
        self,
        *,
        virtual_instance_id: str,
        collection_path: str,
        **kwargs
    ) -> typing.Union[CollectionMountResponse, asyncio.Future]:
        """Get Collection Mount  # noqa: E501

        Retrieve a mount on this virtual instance.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.get_collection_mount(
            virtual_instance_id="virtualInstanceId_example",
            collection_path="collectionPath_example",
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            virtual_instance_id (str): Virtual Instance RRN. [required]
            collection_path (str): [required]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            CollectionMountResponse
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['virtual_instance_id'] = \
            virtual_instance_id
        kwargs['collection_path'] = \
            collection_path
        return self.get_collection_mount_endpoint.call_with_http_info(**kwargs)

    def get_mount_offsets(
        self,
        *,
        virtual_instance_id: str,
        collection_path: str,
        name: typing.Sequence[str] = None,
        **kwargs
    ) -> typing.Union[GetCollectionCommit, asyncio.Future]:
        """Get Collection Commit  # noqa: E501

        Determines if the collection includes data at or after the specified fence(s) for close read-after-write semantics.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.get_mount_offsets(
            virtual_instance_id="virtualInstanceId_example",
            collection_path="collectionPath_example",
            name=["f1:0:14:9:7092","f1:0:14:9:7093"],
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            virtual_instance_id (str): Virtual Instance RRN. [required]
            collection_path (str): [required]
            name ([str]): a list of zero or more collection offset fences. [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            GetCollectionCommit
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['virtual_instance_id'] = \
            virtual_instance_id
        kwargs['collection_path'] = \
            collection_path
        kwargs['get_collection_commit_request'] = \
            kwargs['get_collection_commit_request']
        return self.get_mount_offsets_endpoint.call_with_http_info(**kwargs)

    def get_virtual_instance_queries(
        self,
        *,
        virtual_instance_id: str,
        **kwargs
    ) -> typing.Union[ListQueriesResponse, asyncio.Future]:
        """List Queries  # noqa: E501

        Lists actively queued and running queries for a particular Virtual Instance.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.get_virtual_instance_queries(
            virtual_instance_id="virtualInstanceId_example",
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            virtual_instance_id (str): Virtual Instance RRN. [required]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            ListQueriesResponse
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['virtual_instance_id'] = \
            virtual_instance_id
        return self.get_virtual_instance_queries_endpoint.call_with_http_info(**kwargs)

    def list(
        self,
        **kwargs
    ) -> typing.Union[ListVirtualInstancesResponse, asyncio.Future]:
        """List Virtual Instances  # noqa: E501

        Retrieve all virtual instances in an organization.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.list(
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            ListVirtualInstancesResponse
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        return self.list_endpoint.call_with_http_info(**kwargs)

    def list_collection_mounts(
        self,
        *,
        virtual_instance_id: str,
        **kwargs
    ) -> typing.Union[ListCollectionMountsResponse, asyncio.Future]:
        """List Collection Mounts  # noqa: E501

        List collection mounts for a particular VI.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.list_collection_mounts(
            virtual_instance_id="virtualInstanceId_example",
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            virtual_instance_id (str): Virtual Instance RRN. [required]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            ListCollectionMountsResponse
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['virtual_instance_id'] = \
            virtual_instance_id
        return self.list_collection_mounts_endpoint.call_with_http_info(**kwargs)

    def mount_collection(
        self,
        *,
        virtual_instance_id: str,
        collection_paths: typing.Sequence[str] = None,
        **kwargs
    ) -> typing.Union[CreateCollectionMountsResponse, asyncio.Future]:
        """Mount Collections  # noqa: E501

        Mount a collection to this virtual instance.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.mount_collection(
            virtual_instance_id="virtualInstanceId_example",
            collection_paths=["commons.foo","commons.bar"],
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            virtual_instance_id (str): Virtual Instance RRN. [required]
            collection_paths ([str]): Collections to mount.. [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            CreateCollectionMountsResponse
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['virtual_instance_id'] = \
            virtual_instance_id
        kwargs['create_collection_mount_request'] = \
            kwargs['create_collection_mount_request']
        return self.mount_collection_endpoint.call_with_http_info(**kwargs)

    def query_virtual_instance(
        self,
        *,
        virtual_instance_id: str,
        sql: QueryRequestSql,
        _async: bool = None,
        async_options: AsyncQueryOptions = None,
        debug_threshold_ms: int = None,
        max_initial_results: int = None,
        timeout_ms: int = None,
        **kwargs
    ) -> typing.Union[QueryResponse, asyncio.Future]:
        """Execute SQL Query on a specific Virtual Instance  # noqa: E501

        Make a SQL query to Rockset.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.query_virtual_instance(
            virtual_instance_id="virtualInstanceId_example",
            _async=True,
            async_options=AsyncQueryOptions(
                client_timeout_ms=1,
                max_initial_results=1,
                timeout_ms=1,
            ),
            debug_threshold_ms=1,
            max_initial_results=1,
            sql=QueryRequestSql(
                default_row_limit=1,
                initial_paginate_response_doc_count=1,
                parameters=[
                    QueryParameter(
                        name="_id",
                        type="string",
                        value="85beb391",
                    ),
                ],
                query="SELECT * FROM foo where _id = :_id",
            ),
            timeout_ms=1,
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            virtual_instance_id (str): Virtual Instance RRN. [required]
            _async (bool): If true, the query will run asynchronously for up to 30 minutes. The query request will immediately return with a query id that can be used to retrieve the query status and results. If false or not specified, the query will return with results once completed or timeout after 2 minutes. (To return results directly for shorter queries while still allowing a timeout of up to 30 minutes, set `async_options.client_timeout_ms`.) . [optional]
            async_options (AsyncQueryOptions): [optional]
            debug_threshold_ms (int): If query execution takes longer than this value, debug information will be logged. If the query text includes the DEBUG hint and this parameter is also provided, only this value will be used and the DEBUG hint will be ignored.. [optional]
            max_initial_results (int): This limits the maximum number of results in the initial response. A pagination cursor is returned if the number of results exceeds `max_initial_results`. If `max_initial_results` is not set, all results will be returned in the initial response up to 4 million. If `max_initial_results` is set, the value must be between 0 and 100,000. If the query is async and `client_timeout_ms` is exceeded, `max_initial_results` does not apply since none of the results will be returned with the initial response.. [optional]
            sql (QueryRequestSql): [required]
            timeout_ms (int): If a query exceeds the specified timeout, the query will automatically stop and return an error. The query timeout defaults to a maximum of 2 minutes. If `async` is true, the query timeout defaults to a maximum of 30 minutes.. [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            QueryResponse
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['virtual_instance_id'] = \
            virtual_instance_id
        kwargs['query_request'] = \
            kwargs['query_request']
        return self.query_virtual_instance_endpoint.call_with_http_info(**kwargs)

    def resume_virtual_instance(
        self,
        *,
        virtual_instance_id: str,
        **kwargs
    ) -> typing.Union[ResumeVirtualInstanceResponse, asyncio.Future]:
        """Resume Virtual Instance  # noqa: E501

        Resume a virtual instance.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.resume_virtual_instance(
            virtual_instance_id="virtualInstanceId_example",
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            virtual_instance_id (str): Virtual Instance RRN. [required]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            ResumeVirtualInstanceResponse
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['virtual_instance_id'] = \
            virtual_instance_id
        return self.resume_virtual_instance_endpoint.call_with_http_info(**kwargs)

    def suspend_virtual_instance(
        self,
        *,
        virtual_instance_id: str,
        **kwargs
    ) -> typing.Union[SuspendVirtualInstanceResponse, asyncio.Future]:
        """Suspend Virtual Instance  # noqa: E501

        Suspend a virtual instance.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.suspend_virtual_instance(
            virtual_instance_id="virtualInstanceId_example",
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            virtual_instance_id (str): Virtual Instance RRN. [required]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            SuspendVirtualInstanceResponse
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['virtual_instance_id'] = \
            virtual_instance_id
        return self.suspend_virtual_instance_endpoint.call_with_http_info(**kwargs)

    def unmount_collection(
        self,
        *,
        virtual_instance_id: str,
        collection_path: str,
        **kwargs
    ) -> typing.Union[CollectionMountResponse, asyncio.Future]:
        """Unmount Collection  # noqa: E501

        Unmount a collection from this virtual instance.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.unmount_collection(
            virtual_instance_id="virtualInstanceId_example",
            collection_path="collectionPath_example",
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            virtual_instance_id (str): Virtual Instance RRN. [required]
            collection_path (str): [required]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            CollectionMountResponse
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['virtual_instance_id'] = \
            virtual_instance_id
        kwargs['collection_path'] = \
            collection_path
        return self.unmount_collection_endpoint.call_with_http_info(**kwargs)

    def update(
        self,
        *,
        virtual_instance_id: str,
        auto_scaling_policy: AutoScalingPolicy = None,
        auto_suspend_enabled: bool = None,
        auto_suspend_seconds: int = None,
        description: str = None,
        enable_remount_on_resume: bool = None,
        mount_refresh_interval_seconds: int = None,
        mount_type: str = None,
        name: str = None,
        new_size: str = None,
        **kwargs
    ) -> typing.Union[UpdateVirtualInstanceResponse, asyncio.Future]:
        """Update Virtual Instance  # noqa: E501

        Update the properties of a virtual instance.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        ```python
        rs = RocksetClient(api_key=APIKEY)
        future = rs.VirtualInstances.update(
            virtual_instance_id="virtualInstanceId_example",
            auto_scaling_policy=AutoScalingPolicy(
                enabled=True,
                max_size="XLARGE2",
                min_size="LARGE",
            ),
            auto_suspend_enabled=True,
            auto_suspend_seconds=3600,
            description="VI for prod traffic",
            enable_remount_on_resume=True,
            mount_refresh_interval_seconds=0,
            mount_type="LIVE",
            name="prod_vi",
            new_size="LARGE",
            async_req=True,
        )
        result = await future
        ```

        Keyword Args:
            virtual_instance_id (str): Virtual Instance RRN. [required]
            auto_scaling_policy (AutoScalingPolicy): [optional]
            auto_suspend_enabled (bool): Whether Query VI auto-suspend should be enabled for this Virtual Instance.. [optional]
            auto_suspend_seconds (int): Number of seconds without queries after which the Query VI is suspended. [optional]
            description (str): New virtual instance description.. [optional]
            enable_remount_on_resume (bool): When a Virtual Instance is resumed, it will remount all collections that were mounted when the Virtual Instance was suspended.. [optional]
            mount_refresh_interval_seconds (int): DEPRECATED. Use `mount_type` instead. Number of seconds between data refreshes for mounts on this Virtual Instance. The only valid values are 0 and null. 0 means the data will be refreshed continuously and null means the data will never refresh.. [optional]
            mount_type (str): The mount type of collections that this Virtual Instance will query. Live mounted collections stay up-to-date with the underlying collection in real-time. Static mounted collections do not stay up-to-date. See https://docs.rockset.com/documentation/docs/virtual-instances#virtual-instance-configuration. [optional]
            name (str): New virtual instance name.. [optional]
            new_size (str): Requested virtual instance size.. [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done on the data received from the server.
                If False, the client will also not convert nested inner objects
                into the respective model types (the outermost object
                is still converted to the model).
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            UpdateVirtualInstanceResponse
                If the method is called asynchronously, returns an asyncio.Future which resolves to the response.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['virtual_instance_id'] = \
            virtual_instance_id
        kwargs['update_virtual_instance_request'] = \
            kwargs['update_virtual_instance_request']
        return self.update_endpoint.call_with_http_info(**kwargs)


    body_params_dict = dict()
    return_types_dict = dict()
    body_params_dict['create'] = 'create_virtual_instance_request'
    return_types_dict['create'] = CreateVirtualInstanceRequest
    body_params_dict['get_mount_offsets'] = 'get_collection_commit_request'
    return_types_dict['get_mount_offsets'] = GetCollectionCommitRequest
    body_params_dict['mount_collection'] = 'create_collection_mount_request'
    return_types_dict['mount_collection'] = CreateCollectionMountRequest
    body_params_dict['query_virtual_instance'] = 'query_request'
    return_types_dict['query_virtual_instance'] = QueryRequest
    body_params_dict['update'] = 'update_virtual_instance_request'
    return_types_dict['update'] = UpdateVirtualInstanceRequest
