from cloud_runtimes import CloudRuntimesClient

# Initialize client
client = CloudRuntimesClient(
    endpoint="http://localhost:3500",
    timeout=30.0
)

# Use the RPC service
response = client.rpc.invoke_method(
    service="service-name",
    method="my-method",
    data={"key": "value"}
)

# Use the State service
client.state.save(
    store_name="state-store",
    key="my-key",
    value={"data": "value"}
)

# Retrieve state
state = client.state.get(
    store_name="state-store",
    key="my-key"
)

import asyncio
from cloud_runtimes import CloudRuntimesClient

async def main():
    client = CloudRuntimesClient()

    # Async method invocation
    response = await client.rpc.invoke_method_async(
        service="service-name",
        method="my-method",
        data={"key": "value"}
    )

    # Async state operations
    await client.state.save_async(
        store_name="state-store",
        key="my-key",
        value={"data": "value"}
    )

asyncio.run(main())

from typing import Any, Dict
from cloud_runtimes.rpc import RpcService

class RpcService:
    def invoke_method(
        self,
        service: str,
        method: str,
        data: Dict[str, Any]
    ) -> Dict[str, Any]:
        """Invoke a method on a remote service."""
        ...

    async def invoke_method_async(
        self,
        service: str,
        method: str,
        data: Dict[str, Any]
    ) -> Dict[str, Any]:
        """Async method invocation."""
        ...

from typing import List, Dict
from cloud_runtimes.configuration import ConfigurationService

class ConfigurationService:
    def get_configuration(
        self,
        store_name: str,
        keys: List[str]
    ) -> Dict[str, str]:
        """Get configuration values."""
        ...

    def subscribe_configuration(
        self,
        store_name: str,
        keys: List[str]
    ) -> "ConfigurationSubscription":
        """Subscribe to configuration changes."""
        ...

from typing import Any, Optional
from cloud_runtimes.state import StateService, StateItem

class StateService:
    def get(
        self,
        store_name: str,
        key: str
    ) -> Optional[Any]:
        """Get a state value."""
        ...

    def save(
        self,
        store_name: str,
        key: str,
        value: Any,
        metadata: Optional[dict] = None
    ) -> None:
        """Save a state value."""
        ...

    def delete(
        self,
        store_name: str,
        key: str
    ) -> None:
        """Delete a state value."""
        ...