otdf-python 0.1.10__py3-none-any.whl → 0.3.0__py3-none-any.whl

otdf_python_proto/kas/kas_pb2.pyi

@@ -0,0 +1,170 @@
+from google.api import annotations_pb2 as _annotations_pb2
+from google.protobuf import struct_pb2 as _struct_pb2
+from google.protobuf import wrappers_pb2 as _wrappers_pb2
+from protoc_gen_openapiv2.options import annotations_pb2 as _annotations_pb2_1
+from google.protobuf.internal import containers as _containers
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from collections.abc import Iterable as _Iterable, Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class InfoRequest(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class InfoResponse(_message.Message):
+    __slots__ = ("version",)
+    VERSION_FIELD_NUMBER: _ClassVar[int]
+    version: str
+    def __init__(self, version: _Optional[str] = ...) -> None: ...
+
+class LegacyPublicKeyRequest(_message.Message):
+    __slots__ = ("algorithm",)
+    ALGORITHM_FIELD_NUMBER: _ClassVar[int]
+    algorithm: str
+    def __init__(self, algorithm: _Optional[str] = ...) -> None: ...
+
+class PolicyBinding(_message.Message):
+    __slots__ = ("algorithm", "hash")
+    ALGORITHM_FIELD_NUMBER: _ClassVar[int]
+    HASH_FIELD_NUMBER: _ClassVar[int]
+    algorithm: str
+    hash: str
+    def __init__(self, algorithm: _Optional[str] = ..., hash: _Optional[str] = ...) -> None: ...
+
+class KeyAccess(_message.Message):
+    __slots__ = ("encrypted_metadata", "policy_binding", "protocol", "key_type", "kas_url", "kid", "split_id", "wrapped_key", "header", "ephemeral_public_key")
+    ENCRYPTED_METADATA_FIELD_NUMBER: _ClassVar[int]
+    POLICY_BINDING_FIELD_NUMBER: _ClassVar[int]
+    PROTOCOL_FIELD_NUMBER: _ClassVar[int]
+    KEY_TYPE_FIELD_NUMBER: _ClassVar[int]
+    KAS_URL_FIELD_NUMBER: _ClassVar[int]
+    KID_FIELD_NUMBER: _ClassVar[int]
+    SPLIT_ID_FIELD_NUMBER: _ClassVar[int]
+    WRAPPED_KEY_FIELD_NUMBER: _ClassVar[int]
+    HEADER_FIELD_NUMBER: _ClassVar[int]
+    EPHEMERAL_PUBLIC_KEY_FIELD_NUMBER: _ClassVar[int]
+    encrypted_metadata: str
+    policy_binding: PolicyBinding
+    protocol: str
+    key_type: str
+    kas_url: str
+    kid: str
+    split_id: str
+    wrapped_key: bytes
+    header: bytes
+    ephemeral_public_key: str
+    def __init__(self, encrypted_metadata: _Optional[str] = ..., policy_binding: _Optional[_Union[PolicyBinding, _Mapping]] = ..., protocol: _Optional[str] = ..., key_type: _Optional[str] = ..., kas_url: _Optional[str] = ..., kid: _Optional[str] = ..., split_id: _Optional[str] = ..., wrapped_key: _Optional[bytes] = ..., header: _Optional[bytes] = ..., ephemeral_public_key: _Optional[str] = ...) -> None: ...
+
+class UnsignedRewrapRequest(_message.Message):
+    __slots__ = ("client_public_key", "requests", "key_access", "policy", "algorithm")
+    class WithPolicy(_message.Message):
+        __slots__ = ("id", "body")
+        ID_FIELD_NUMBER: _ClassVar[int]
+        BODY_FIELD_NUMBER: _ClassVar[int]
+        id: str
+        body: str
+        def __init__(self, id: _Optional[str] = ..., body: _Optional[str] = ...) -> None: ...
+    class WithKeyAccessObject(_message.Message):
+        __slots__ = ("key_access_object_id", "key_access_object")
+        KEY_ACCESS_OBJECT_ID_FIELD_NUMBER: _ClassVar[int]
+        KEY_ACCESS_OBJECT_FIELD_NUMBER: _ClassVar[int]
+        key_access_object_id: str
+        key_access_object: KeyAccess
+        def __init__(self, key_access_object_id: _Optional[str] = ..., key_access_object: _Optional[_Union[KeyAccess, _Mapping]] = ...) -> None: ...
+    class WithPolicyRequest(_message.Message):
+        __slots__ = ("key_access_objects", "policy", "algorithm")
+        KEY_ACCESS_OBJECTS_FIELD_NUMBER: _ClassVar[int]
+        POLICY_FIELD_NUMBER: _ClassVar[int]
+        ALGORITHM_FIELD_NUMBER: _ClassVar[int]
+        key_access_objects: _containers.RepeatedCompositeFieldContainer[UnsignedRewrapRequest.WithKeyAccessObject]
+        policy: UnsignedRewrapRequest.WithPolicy
+        algorithm: str
+        def __init__(self, key_access_objects: _Optional[_Iterable[_Union[UnsignedRewrapRequest.WithKeyAccessObject, _Mapping]]] = ..., policy: _Optional[_Union[UnsignedRewrapRequest.WithPolicy, _Mapping]] = ..., algorithm: _Optional[str] = ...) -> None: ...
+    CLIENT_PUBLIC_KEY_FIELD_NUMBER: _ClassVar[int]
+    REQUESTS_FIELD_NUMBER: _ClassVar[int]
+    KEY_ACCESS_FIELD_NUMBER: _ClassVar[int]
+    POLICY_FIELD_NUMBER: _ClassVar[int]
+    ALGORITHM_FIELD_NUMBER: _ClassVar[int]
+    client_public_key: str
+    requests: _containers.RepeatedCompositeFieldContainer[UnsignedRewrapRequest.WithPolicyRequest]
+    key_access: KeyAccess
+    policy: str
+    algorithm: str
+    def __init__(self, client_public_key: _Optional[str] = ..., requests: _Optional[_Iterable[_Union[UnsignedRewrapRequest.WithPolicyRequest, _Mapping]]] = ..., key_access: _Optional[_Union[KeyAccess, _Mapping]] = ..., policy: _Optional[str] = ..., algorithm: _Optional[str] = ...) -> None: ...
+
+class PublicKeyRequest(_message.Message):
+    __slots__ = ("algorithm", "fmt", "v")
+    ALGORITHM_FIELD_NUMBER: _ClassVar[int]
+    FMT_FIELD_NUMBER: _ClassVar[int]
+    V_FIELD_NUMBER: _ClassVar[int]
+    algorithm: str
+    fmt: str
+    v: str
+    def __init__(self, algorithm: _Optional[str] = ..., fmt: _Optional[str] = ..., v: _Optional[str] = ...) -> None: ...
+
+class PublicKeyResponse(_message.Message):
+    __slots__ = ("public_key", "kid")
+    PUBLIC_KEY_FIELD_NUMBER: _ClassVar[int]
+    KID_FIELD_NUMBER: _ClassVar[int]
+    public_key: str
+    kid: str
+    def __init__(self, public_key: _Optional[str] = ..., kid: _Optional[str] = ...) -> None: ...
+
+class RewrapRequest(_message.Message):
+    __slots__ = ("signed_request_token",)
+    SIGNED_REQUEST_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    signed_request_token: str
+    def __init__(self, signed_request_token: _Optional[str] = ...) -> None: ...
+
+class KeyAccessRewrapResult(_message.Message):
+    __slots__ = ("metadata", "key_access_object_id", "status", "kas_wrapped_key", "error")
+    class MetadataEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: _struct_pb2.Value
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_struct_pb2.Value, _Mapping]] = ...) -> None: ...
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    KEY_ACCESS_OBJECT_ID_FIELD_NUMBER: _ClassVar[int]
+    STATUS_FIELD_NUMBER: _ClassVar[int]
+    KAS_WRAPPED_KEY_FIELD_NUMBER: _ClassVar[int]
+    ERROR_FIELD_NUMBER: _ClassVar[int]
+    metadata: _containers.MessageMap[str, _struct_pb2.Value]
+    key_access_object_id: str
+    status: str
+    kas_wrapped_key: bytes
+    error: str
+    def __init__(self, metadata: _Optional[_Mapping[str, _struct_pb2.Value]] = ..., key_access_object_id: _Optional[str] = ..., status: _Optional[str] = ..., kas_wrapped_key: _Optional[bytes] = ..., error: _Optional[str] = ...) -> None: ...
+
+class PolicyRewrapResult(_message.Message):
+    __slots__ = ("policy_id", "results")
+    POLICY_ID_FIELD_NUMBER: _ClassVar[int]
+    RESULTS_FIELD_NUMBER: _ClassVar[int]
+    policy_id: str
+    results: _containers.RepeatedCompositeFieldContainer[KeyAccessRewrapResult]
+    def __init__(self, policy_id: _Optional[str] = ..., results: _Optional[_Iterable[_Union[KeyAccessRewrapResult, _Mapping]]] = ...) -> None: ...
+
+class RewrapResponse(_message.Message):
+    __slots__ = ("metadata", "entity_wrapped_key", "session_public_key", "schema_version", "responses")
+    class MetadataEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: _struct_pb2.Value
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[_struct_pb2.Value, _Mapping]] = ...) -> None: ...
+    METADATA_FIELD_NUMBER: _ClassVar[int]
+    ENTITY_WRAPPED_KEY_FIELD_NUMBER: _ClassVar[int]
+    SESSION_PUBLIC_KEY_FIELD_NUMBER: _ClassVar[int]
+    SCHEMA_VERSION_FIELD_NUMBER: _ClassVar[int]
+    RESPONSES_FIELD_NUMBER: _ClassVar[int]
+    metadata: _containers.MessageMap[str, _struct_pb2.Value]
+    entity_wrapped_key: bytes
+    session_public_key: str
+    schema_version: str
+    responses: _containers.RepeatedCompositeFieldContainer[PolicyRewrapResult]
+    def __init__(self, metadata: _Optional[_Mapping[str, _struct_pb2.Value]] = ..., entity_wrapped_key: _Optional[bytes] = ..., session_public_key: _Optional[str] = ..., schema_version: _Optional[str] = ..., responses: _Optional[_Iterable[_Union[PolicyRewrapResult, _Mapping]]] = ...) -> None: ...

otdf_python_proto/kas/kas_pb2_connect.py

@@ -0,0 +1,192 @@
+# Generated Connect client code
+
+from __future__ import annotations
+from collections.abc import AsyncIterator
+from collections.abc import Iterator
+from collections.abc import Iterable
+import aiohttp
+import urllib3
+import typing
+import sys
+
+from connectrpc.client_async import AsyncConnectClient
+from connectrpc.client_sync import ConnectClient
+from connectrpc.client_protocol import ConnectProtocol
+from connectrpc.client_connect import ConnectProtocolError
+from connectrpc.headers import HeaderInput
+from connectrpc.server import ClientRequest
+from connectrpc.server import ClientStream
+from connectrpc.server import ServerResponse
+from connectrpc.server import ServerStream
+from connectrpc.server_sync import ConnectWSGI
+from connectrpc.streams import StreamInput
+from connectrpc.streams import AsyncStreamOutput
+from connectrpc.streams import StreamOutput
+from connectrpc.unary import UnaryOutput
+from connectrpc.unary import ClientStreamingOutput
+
+if typing.TYPE_CHECKING:
+    # wsgiref.types was added in Python 3.11.
+    if sys.version_info >= (3, 11):
+        from wsgiref.types import WSGIApplication
+    else:
+        from _typeshed.wsgi import WSGIApplication
+
+import google.protobuf.wrappers_pb2
+from . import kas_pb2
+
+class AccessServiceClient:
+    def __init__(
+        self,
+        base_url: str,
+        http_client: urllib3.PoolManager | None = None,
+        protocol: ConnectProtocol = ConnectProtocol.CONNECT_PROTOBUF,
+    ):
+        self.base_url = base_url
+        self._connect_client = ConnectClient(http_client, protocol)
+    def call_public_key(
+        self, req: kas_pb2.PublicKeyRequest,extra_headers: HeaderInput | None=None, timeout_seconds: float | None=None
+    ) -> UnaryOutput[kas_pb2.PublicKeyResponse]:
+        """Low-level method to call PublicKey, granting access to errors and metadata"""
+        url = self.base_url + "/kas.AccessService/PublicKey"
+        return self._connect_client.call_unary(url, req, kas_pb2.PublicKeyResponse,extra_headers, timeout_seconds)
+
+
+    def public_key(
+        self, req: kas_pb2.PublicKeyRequest,extra_headers: HeaderInput | None=None, timeout_seconds: float | None=None
+    ) -> kas_pb2.PublicKeyResponse:
+        response = self.call_public_key(req, extra_headers, timeout_seconds)
+        err = response.error()
+        if err is not None:
+            raise err
+        msg = response.message()
+        if msg is None:
+            raise ConnectProtocolError('missing response message')
+        return msg
+
+    def call_legacy_public_key(
+        self, req: kas_pb2.LegacyPublicKeyRequest,extra_headers: HeaderInput | None=None, timeout_seconds: float | None=None
+    ) -> UnaryOutput[google.protobuf.wrappers_pb2.StringValue]:
+        """Low-level method to call LegacyPublicKey, granting access to errors and metadata"""
+        url = self.base_url + "/kas.AccessService/LegacyPublicKey"
+        return self._connect_client.call_unary(url, req, google.protobuf.wrappers_pb2.StringValue,extra_headers, timeout_seconds)
+
+
+    def legacy_public_key(
+        self, req: kas_pb2.LegacyPublicKeyRequest,extra_headers: HeaderInput | None=None, timeout_seconds: float | None=None
+    ) -> google.protobuf.wrappers_pb2.StringValue:
+        response = self.call_legacy_public_key(req, extra_headers, timeout_seconds)
+        err = response.error()
+        if err is not None:
+            raise err
+        msg = response.message()
+        if msg is None:
+            raise ConnectProtocolError('missing response message')
+        return msg
+
+    def call_rewrap(
+        self, req: kas_pb2.RewrapRequest,extra_headers: HeaderInput | None=None, timeout_seconds: float | None=None
+    ) -> UnaryOutput[kas_pb2.RewrapResponse]:
+        """Low-level method to call Rewrap, granting access to errors and metadata"""
+        url = self.base_url + "/kas.AccessService/Rewrap"
+        return self._connect_client.call_unary(url, req, kas_pb2.RewrapResponse,extra_headers, timeout_seconds)
+
+
+    def rewrap(
+        self, req: kas_pb2.RewrapRequest,extra_headers: HeaderInput | None=None, timeout_seconds: float | None=None
+    ) -> kas_pb2.RewrapResponse:
+        response = self.call_rewrap(req, extra_headers, timeout_seconds)
+        err = response.error()
+        if err is not None:
+            raise err
+        msg = response.message()
+        if msg is None:
+            raise ConnectProtocolError('missing response message')
+        return msg
+
+
+class AsyncAccessServiceClient:
+    def __init__(
+        self,
+        base_url: str,
+        http_client: aiohttp.ClientSession,
+        protocol: ConnectProtocol = ConnectProtocol.CONNECT_PROTOBUF,
+    ):
+        self.base_url = base_url
+        self._connect_client = AsyncConnectClient(http_client, protocol)
+
+    async def call_public_key(
+        self, req: kas_pb2.PublicKeyRequest,extra_headers: HeaderInput | None=None, timeout_seconds: float | None=None
+    ) -> UnaryOutput[kas_pb2.PublicKeyResponse]:
+        """Low-level method to call PublicKey, granting access to errors and metadata"""
+        url = self.base_url + "/kas.AccessService/PublicKey"
+        return await self._connect_client.call_unary(url, req, kas_pb2.PublicKeyResponse,extra_headers, timeout_seconds)
+
+    async def public_key(
+        self, req: kas_pb2.PublicKeyRequest,extra_headers: HeaderInput | None=None, timeout_seconds: float | None=None
+    ) -> kas_pb2.PublicKeyResponse:
+        response = await self.call_public_key(req, extra_headers, timeout_seconds)
+        err = response.error()
+        if err is not None:
+            raise err
+        msg = response.message()
+        if msg is None:
+            raise ConnectProtocolError('missing response message')
+        return msg
+
+    async def call_legacy_public_key(
+        self, req: kas_pb2.LegacyPublicKeyRequest,extra_headers: HeaderInput | None=None, timeout_seconds: float | None=None
+    ) -> UnaryOutput[google.protobuf.wrappers_pb2.StringValue]:
+        """Low-level method to call LegacyPublicKey, granting access to errors and metadata"""
+        url = self.base_url + "/kas.AccessService/LegacyPublicKey"
+        return await self._connect_client.call_unary(url, req, google.protobuf.wrappers_pb2.StringValue,extra_headers, timeout_seconds)
+
+    async def legacy_public_key(
+        self, req: kas_pb2.LegacyPublicKeyRequest,extra_headers: HeaderInput | None=None, timeout_seconds: float | None=None
+    ) -> google.protobuf.wrappers_pb2.StringValue:
+        response = await self.call_legacy_public_key(req, extra_headers, timeout_seconds)
+        err = response.error()
+        if err is not None:
+            raise err
+        msg = response.message()
+        if msg is None:
+            raise ConnectProtocolError('missing response message')
+        return msg
+
+    async def call_rewrap(
+        self, req: kas_pb2.RewrapRequest,extra_headers: HeaderInput | None=None, timeout_seconds: float | None=None
+    ) -> UnaryOutput[kas_pb2.RewrapResponse]:
+        """Low-level method to call Rewrap, granting access to errors and metadata"""
+        url = self.base_url + "/kas.AccessService/Rewrap"
+        return await self._connect_client.call_unary(url, req, kas_pb2.RewrapResponse,extra_headers, timeout_seconds)
+
+    async def rewrap(
+        self, req: kas_pb2.RewrapRequest,extra_headers: HeaderInput | None=None, timeout_seconds: float | None=None
+    ) -> kas_pb2.RewrapResponse:
+        response = await self.call_rewrap(req, extra_headers, timeout_seconds)
+        err = response.error()
+        if err is not None:
+            raise err
+        msg = response.message()
+        if msg is None:
+            raise ConnectProtocolError('missing response message')
+        return msg
+
+
+@typing.runtime_checkable
+class AccessServiceProtocol(typing.Protocol):
+    def public_key(self, req: ClientRequest[kas_pb2.PublicKeyRequest]) -> ServerResponse[kas_pb2.PublicKeyResponse]:
+        ...
+    def legacy_public_key(self, req: ClientRequest[kas_pb2.LegacyPublicKeyRequest]) -> ServerResponse[google.protobuf.wrappers_pb2.StringValue]:
+        ...
+    def rewrap(self, req: ClientRequest[kas_pb2.RewrapRequest]) -> ServerResponse[kas_pb2.RewrapResponse]:
+        ...
+
+ACCESS_SERVICE_PATH_PREFIX = "/kas.AccessService"
+
+def wsgi_access_service(implementation: AccessServiceProtocol) -> WSGIApplication:
+    app = ConnectWSGI()
+    app.register_unary_rpc("/kas.AccessService/PublicKey", implementation.public_key, kas_pb2.PublicKeyRequest)
+    app.register_unary_rpc("/kas.AccessService/LegacyPublicKey", implementation.legacy_public_key, kas_pb2.LegacyPublicKeyRequest)
+    app.register_unary_rpc("/kas.AccessService/Rewrap", implementation.rewrap, kas_pb2.RewrapRequest)
+    return app

otdf_python_proto/legacy_grpc/__init__.py

@@ -0,0 +1 @@
+"""legacy_grpc protobuf definitions."""

otdf_python_proto/legacy_grpc/authorization/authorization_pb2_grpc.py

@@ -0,0 +1,163 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+from authorization import authorization_pb2 as authorization_dot_authorization__pb2
+
+
+class AuthorizationServiceStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.GetDecisions = channel.unary_unary(
+                '/authorization.AuthorizationService/GetDecisions',
+                request_serializer=authorization_dot_authorization__pb2.GetDecisionsRequest.SerializeToString,
+                response_deserializer=authorization_dot_authorization__pb2.GetDecisionsResponse.FromString,
+                _registered_method=True)
+        self.GetDecisionsByToken = channel.unary_unary(
+                '/authorization.AuthorizationService/GetDecisionsByToken',
+                request_serializer=authorization_dot_authorization__pb2.GetDecisionsByTokenRequest.SerializeToString,
+                response_deserializer=authorization_dot_authorization__pb2.GetDecisionsByTokenResponse.FromString,
+                _registered_method=True)
+        self.GetEntitlements = channel.unary_unary(
+                '/authorization.AuthorizationService/GetEntitlements',
+                request_serializer=authorization_dot_authorization__pb2.GetEntitlementsRequest.SerializeToString,
+                response_deserializer=authorization_dot_authorization__pb2.GetEntitlementsResponse.FromString,
+                _registered_method=True)
+
+
+class AuthorizationServiceServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def GetDecisions(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetDecisionsByToken(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetEntitlements(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_AuthorizationServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'GetDecisions': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetDecisions,
+                    request_deserializer=authorization_dot_authorization__pb2.GetDecisionsRequest.FromString,
+                    response_serializer=authorization_dot_authorization__pb2.GetDecisionsResponse.SerializeToString,
+            ),
+            'GetDecisionsByToken': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetDecisionsByToken,
+                    request_deserializer=authorization_dot_authorization__pb2.GetDecisionsByTokenRequest.FromString,
+                    response_serializer=authorization_dot_authorization__pb2.GetDecisionsByTokenResponse.SerializeToString,
+            ),
+            'GetEntitlements': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetEntitlements,
+                    request_deserializer=authorization_dot_authorization__pb2.GetEntitlementsRequest.FromString,
+                    response_serializer=authorization_dot_authorization__pb2.GetEntitlementsResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'authorization.AuthorizationService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('authorization.AuthorizationService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class AuthorizationService(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def GetDecisions(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/authorization.AuthorizationService/GetDecisions',
+            authorization_dot_authorization__pb2.GetDecisionsRequest.SerializeToString,
+            authorization_dot_authorization__pb2.GetDecisionsResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def GetDecisionsByToken(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/authorization.AuthorizationService/GetDecisionsByToken',
+            authorization_dot_authorization__pb2.GetDecisionsByTokenRequest.SerializeToString,
+            authorization_dot_authorization__pb2.GetDecisionsByTokenResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def GetEntitlements(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/authorization.AuthorizationService/GetEntitlements',
+            authorization_dot_authorization__pb2.GetEntitlementsRequest.SerializeToString,
+            authorization_dot_authorization__pb2.GetEntitlementsResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)